@pcircle/memesh 4.0.3 → 4.1.1

package/scripts/hooks/_shared.js

@@ -1,6 +1,212 @@
-import { chmodSync, mkdirSync, writeFileSync } from 'fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { createRequire } from 'module';
 import { homedir } from 'os';
 import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Resolve the package root from a hook file's `import.meta.url`.
+ *
+ * Hooks live at `<pkgRoot>/scripts/hooks/<file>.js`, so the path needs
+ * three `dirname()` hops to reach `<pkgRoot>`. Centralising this here
+ * prevents the off-by-one regression that silently disabled noise
+ * compression and LLM failure analysis between 4.0.4–4.1.0 (the inline
+ * `dirname(dirname(...))` only reached `<pkgRoot>/scripts`, and the
+ * surrounding `catch` swallowed the resulting ENOENT).
+ *
+ * The path is derived strictly from the caller's URL — there is no env
+ * override — so a malicious project's `.envrc` cannot redirect dynamic
+ * imports to attacker-controlled code (the F5 boundary).
+ *
+ * @param {string} metaUrl - typically `import.meta.url` of the caller
+ * @returns {string} absolute path to the package root
+ */
+export function resolvePluginRoot(metaUrl) {
+  return dirname(dirname(dirname(fileURLToPath(metaUrl))));
+}
+
+/**
+ * Read ~/.memesh/config.json directly. Hooks must not depend on dist/
+ * (F5 boundary), so this reads the JSON as a plain file rather than
+ * importing readConfig from src/core/config.ts.
+ *
+ * Always reads `~/.memesh/config.json` to stay consistent with
+ * `src/core/config.ts`, which is the single writer. Earlier versions
+ * read `dirname(MEMESH_DB_PATH)/config.json`, which silently diverged
+ * from the CLI-managed config any time a custom DB path was set: hooks
+ * would ignore `memesh config set autoCapture …` and friends. Fixed
+ * by treating the homedir path as the canonical source.
+ *
+ * Returns an empty object on missing/unreadable/malformed file —
+ * callers must always be defensive about which fields are set.
+ *
+ * @param {NodeJS.ProcessEnv} [_env=process.env] - kept for signature
+ *   compatibility (env was the prior MEMESH_DB_PATH source); ignored.
+ * @returns {Record<string, any>}
+ */
+export function readHookConfig(_env = process.env) {
+  const path = join(homedir(), '.memesh', 'config.json');
+  if (!existsSync(path)) return {};
+  try {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    return (parsed && typeof parsed === 'object') ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Resolve the agentic-orchestration opt-in flag.
+ * Precedence: env > config > default(false).
+ * Env semantics preserved: only `=== '1'` enables (avoids accidental
+ * truthy unlock from a stray env value).
+ *
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {boolean}
+ */
+export function isAgenticOrchestrationEnabled(env = process.env) {
+  const envVal = env.MEMESH_ENABLE_AGENTIC_ORCHESTRATION;
+  if (envVal !== undefined) return envVal === '1';
+  const cfg = readHookConfig(env);
+  return cfg.enableAgenticOrchestration === true;
+}
+
+/**
+ * Resolve the auto-capture flag.
+ * Precedence: env > config > default(true).
+ * Env semantics preserved: explicit `=== 'false'` disables; any other
+ * value (including undefined) leaves it on or defers to config.
+ *
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {boolean}
+ */
+export function isAutoCaptureEnabled(env = process.env) {
+  const envVal = env.MEMESH_AUTO_CAPTURE;
+  if (envVal === 'false') return false;
+  if (envVal === 'true') return true;
+  // env unset or other value — fall through to config
+  const cfg = readHookConfig(env);
+  if (cfg.autoCapture === false) return false;
+  return true; // default
+}
+
+/**
+ * Resolve the session-start memory-injection top-N limit.
+ * Precedence: env > config > default(10).
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {number}
+ */
+export function resolveSessionLimit(env = process.env) {
+  const envVal = env.MEMESH_SESSION_LIMIT;
+  if (envVal !== undefined) {
+    const n = parseInt(envVal, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const cfg = readHookConfig(env);
+  if (typeof cfg.sessionLimit === 'number' && cfg.sessionLimit > 0) {
+    return cfg.sessionLimit;
+  }
+  return 10;
+}
+
+// Canonical SQLite schema for hook-written entities. Mirrors src/db.ts.
+// Hooks must NOT depend on dist/ (F5 security boundary), so this is a
+// duplicate string by necessity. When src/db.ts changes, this must
+// change in lockstep.
+export 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);
+`;
+
+// FTS5 virtual table — separate so hooks that don't need it stay lean.
+export const FTS_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+  name, observations, content='',
+  tokenize='unicode61 remove_diacritics 1'
+);
+`;
+
+/**
+ * Open the hook-side memesh DB with schema + status migration applied.
+ *
+ * Two of three hooks (post-commit, pre-compact) previously inlined the
+ * same SCHEMA_SQL but skipped the v2.11→v2.12 status migration that
+ * session-summary.js ran. This unified helper closes the drift gap so
+ * every hook converges on the same shape regardless of order.
+ *
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @param {object} [opts]
+ * @param {boolean} [opts.fts=false] - Also create the FTS5 virtual table.
+ * @returns {{ db: any, dbPath: string }}
+ */
+export function openHookDb(env = process.env, opts = {}) {
+  const dbPath = env.MEMESH_DB_PATH || join(homedir(), '.memesh', 'knowledge-graph.db');
+  const dbDir = env.MEMESH_DB_PATH ? dirname(env.MEMESH_DB_PATH) : join(homedir(), '.memesh');
+  if (!existsSync(dbDir)) mkdirSync(dbDir, { recursive: true });
+
+  const Database = require('better-sqlite3');
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(SCHEMA_SQL);
+  if (opts.fts) db.exec(FTS_SQL);
+
+  const cols = db.prepare("PRAGMA table_info(entities)").all();
+  if (!cols.some((c) => c.name === 'status')) {
+    db.exec("ALTER TABLE entities ADD COLUMN status TEXT NOT NULL DEFAULT 'active'");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status)");
+  }
+
+  return { db, dbPath };
+}
 
 const PRIVATE_DIR_MODE = 0o700;
 const PRIVATE_FILE_MODE = 0o600;

package/scripts/hooks/post-commit.js

@@ -1,67 +1,8 @@
 #!/usr/bin/env node
 
-import { createRequire } from 'module';
 import { execFileSync } from 'child_process';
-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'
-);
-`;
+import { basename } from 'path';
+import { openHookDb } from './_shared.js';
 
 let input = '';
 process.stdin.setEncoding('utf8');
@@ -88,22 +29,10 @@ process.stdin.on('end', () => {
     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);
+    // Open DB via shared helper — applies SCHEMA_SQL + status migration.
+    // Pass fts:true so the FTS5 entity-search index is also available.
+    const { db } = openHookDb(process.env, { fts: true });
     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

package/scripts/hooks/pre-bash-orchestration-nudge.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+// Orchestration Nudge — PreToolUse hook for Bash
+// When Claude is about to run a high-verifiability command (tests, builds, lint,
+// deploys, etc.), injects a one-time-per-category advisory hint to consider
+// dispatching it as a background agent instead of blocking the conversation.
+//
+// Throttle: one nudge per category per session. State is one marker file per
+// category in ${memeshDir}/agent-nudge-flags/${category}.flag. The flag IS
+// the lock — created with O_EXCL so concurrent hooks racing on the same
+// category resolve atomically (winner emits the nudge, loser silently passes).
+// session-start.js clears the directory at the start of each session.
+
+import { join } from 'path';
+import { openSync, closeSync } from 'fs';
+import { ensurePrivateDir, getMemeshDir, isAgenticOrchestrationEnabled } from './_shared.js';
+
+const memeshDir = getMemeshDir(process.env);
+const FLAGS_DIR = join(memeshDir, 'agent-nudge-flags');
+
+// ---------------------------------------------------------------------------
+// Pattern definitions
+// Each entry has:
+//   category: string key used for per-session throttle dedup
+//   test:     RegExp that must match somewhere in the command (case-insensitive)
+// ---------------------------------------------------------------------------
+const PATTERNS = [
+  {
+    category: 'test',
+    test: /\bnpm\s+(?:run\s+)?test\b|\bvitest\b|\bjest\b|\bpytest\b|\bgo\s+test\b|\bcargo\s+test\b|\bmocha\b|\bava\b/i,
+  },
+  {
+    category: 'build',
+    test: /\bnpm\s+run\s+build\b|\btsc\b|\bnext\s+build\b|\bnest\s+build\b|\bcargo\s+build\b|\bvite\s+build\b|\bwebpack\b/i,
+  },
+  {
+    category: 'lint',
+    test: /\bnpm\s+run\s+lint\b|\beslint\b|\bprettier\b(?!\s+--version|\s+-v)|\btsc\s+--noEmit\b|\bbiome\b/i,
+  },
+  {
+    category: 'migrate',
+    test: /\bprisma\s+(?:migrate|db\s+push)\b|\bknex\s+migrate\b|\bsequelize\s+db:migrate\b/i,
+  },
+  {
+    category: 'benchmark',
+    test: /\bnpm\s+run\s+bench\b|\bbenchmark\b/i,
+  },
+  {
+    category: 'deploy',
+    test: /\bvercel\s+(?:deploy|--prod)\b|\bgh\s+(?:workflow\s+run|run)\b|\bwrangler\s+deploy\b|\bfly\s+deploy\b/i,
+  },
+  {
+    category: 'npm-run-check',
+    // Generic: `npm run <script>` where the script name suggests slow CI-like work
+    test: /\bnpm\s+run\s+(?:check|typecheck|type-check|ci|e2e|integration|coverage|storybook|compile)\b/i,
+  },
+];
+
+// Commands that are definitely NOT long-running, even if they somehow matched
+// a pattern above. Short-circuit exclusions — if the command matches any of
+// these, skip the nudge.
+//
+// Note: short-form `-v` was intentionally removed. In test runners (pytest,
+// go test, cargo test, bun test) `-v` is the *verbose* flag, and those
+// invocations are genuinely long-running. `node -v` / `npm -v` style
+// version checks don't reach this exclusion list anyway because they
+// never match any PATTERN entry above.
+const NOISE_EXCLUSIONS = /--version\b|--help\b|\b-h\b|\bls\b|\bcat\b|\becho\b|\bpwd\b|\bwhich\b|\bwhere\b/i;
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    // Opt-in gate: the agentic-orchestration protocol is a separable
+    // experiment from memesh's core memory features. Enable with
+    // MEMESH_ENABLE_AGENTIC_ORCHESTRATION=1. The default is OFF so users
+    // who installed memesh purely for memory don't see protocol nudges
+    // they never asked for.
+    if (!isAgenticOrchestrationEnabled(process.env)) return pass();
+
+    const data = JSON.parse(input);
+    const command = (data.tool_input?.command ?? '').trim();
+
+    if (!command) return pass();
+
+    // Short-circuit: known noise commands never warrant a nudge
+    if (NOISE_EXCLUSIONS.test(command)) return pass();
+
+    // Find the first matching category
+    const match = PATTERNS.find((p) => p.test.test(command));
+    if (!match) return pass();
+
+    // Throttle: only nudge once per category per session.
+    //
+    // Per-category marker file with O_EXCL atomic create. The flag IS the
+    // lock — there is no shared state to read-modify-write, so concurrent
+    // hooks for *different* categories cannot clobber each other's marker
+    // (the previous shared-JSON design lost one of two parallel writes).
+    // session-start.js wipes ${FLAGS_DIR} at the top of each new session.
+    //
+    // No pre-check (existsSync) before the open — that would be a TOCTOU
+    // window. The openSync('wx') is itself the atomic check-and-create:
+    // EEXIST means already-throttled, success means we won the race.
+    const flagPath = join(FLAGS_DIR, `${match.category}.flag`);
+
+    try {
+      ensurePrivateDir(FLAGS_DIR);
+      const fd = openSync(flagPath, 'wx', 0o600);
+      closeSync(fd);
+    } catch (err) {
+      if (err && err.code === 'EEXIST') {
+        // Marker already exists — this category was already nudged in this
+        // session (either by an earlier hook invocation or a parallel one).
+        return pass();
+      }
+      // Other errors (permission, FS full, EROFS): silent degrade — without
+      // a marker we cannot honor the once-per-session contract, so emitting
+      // the nudge would spam every matching command. Better to skip the
+      // nudge entirely and let the user notice the FS issue via
+      // `memesh doctor` if they care.
+      return pass();
+    }
+
+    // Emit the advisory nudge
+    const nudge = [
+      'Orchestration hint: this looks like high-verifiability work.',
+      'If it will take >10s, consider dispatching it as a background agent',
+      '(Task tool with run_in_background:true) instead of blocking the conversation.',
+      'See the agentic-orchestration skill for the dispatch pattern.',
+    ].join('\n');
+
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: nudge,
+      },
+    }));
+  } catch {
+    // Never crash Claude Code — always exit cleanly
+    pass();
+  }
+});
+
+function pass() {
+  process.exit(0);
+}

package/scripts/hooks/pre-compact.js

@@ -1,66 +1,8 @@
 #!/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'
-);
-`;
+import { basename } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { isAutoCaptureEnabled, openHookDb } from './_shared.js';
 
 // Timeout guard: always exit within 10 seconds
 const TIMEOUT_MS = 10000;
@@ -75,8 +17,8 @@ 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') {
+    // Opt-out check (env > config > default-on)
+    if (!isAutoCaptureEnabled(process.env)) {
       return exit0();
     }
 
@@ -130,20 +72,10 @@ process.stdin.on('end', () => {
       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);
+    // Open DB via shared helper — applies SCHEMA_SQL + status migration.
+    // FTS5 needed for the entity-search index updates below.
+    const { db } = openHookDb(process.env, { fts: true });
     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;