@pcircle/memesh 4.5.0 → 4.6.0

package/dist/core/doctor.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { detectCapabilities, getConfigPath, isTranscriptMiningEnabled } from './config.js';
+import { detectCapabilities, getConfigPath, isTranscriptMiningEnabled, readConfig } from './config.js';
 import { embedText } from './embedder.js';
 import { probeProvider } from './llm-validator.js';
 import { openDatabase, closeDatabase, getPendingReindexInfo, isDatabaseOpen } from '../db.js';
@@ -11,20 +11,17 @@ import { getUpdateCheck } from './version-check.js';
 import { getCurrentInstallChannel, getInstallChannelSupport } from './install-channel.js';
 import { getInstallRecord } from './install-id.js';
 import { getDbPath, memeshDir, getProjectName } from './paths.js';
+import { detectPluginRuntime } from './install-hooks.js';
 import { lastTranscriptMineAt } from './transcript-source.js';
 import { UNSPACED_SCRIPT_GLOB_RUN3 } from '../storage/fts-index.js';
+import { MemeshDatabase } from '../storage/sqlite.js';
+import { AUTO_CAPTURE_TAG } from './types.js';
+import { parseSqliteUtcMs } from './time-utils.js';
+import { autoCaptureDecision } from './capture-flag.js';
 const EMBEDDING_PROBE_TIMEOUT_MS = 15000;
 const EXPECTED_HOOK_TYPES = ['PreToolUse', 'SessionStart', 'PostToolUse', 'Stop', 'PreCompact'];
 const LOCALE_README_FILES = [
     'README.de.md',
-    'README.es.md',
-    'README.fr.md',
-    'README.ja.md',
-    'README.ko.md',
-    'README.pt.md',
-    'README.th.md',
-    'README.vi.md',
-    'README.zh-CN.md',
     'README.zh-TW.md',
 ];
 const LOCALE_H2_TOLERANCE = 1;
@@ -92,8 +89,8 @@ function inspectLocaleReadmeParity(packageRoot, existsSyncImpl, readFileSyncImpl
 function resolveDatabasePath() {
     return getDbPath();
 }
-function createCheck(id, label, status, summary, fix, i18n) {
-    return { id, label, status, summary, fix, code: i18n?.code, params: i18n?.params };
+function createCheck(id, label, status, summary, fix, i18n, fixId) {
+    return { id, label, status, summary, fix, code: i18n?.code, params: i18n?.params, fixId };
 }
 function createInfo(id, label, summary, fix) {
     return { id, label, status: 'pass', summary, fix, informational: true };
@@ -119,11 +116,18 @@ function inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl)
     if (!existsSyncImpl(configPath)) {
         return createCheck('config', 'Config', 'pass', `No config file yet (${configPath}). MeMesh will run in Core mode until you configure Smart Mode.`, 'Optional: run `memesh config list` or set an LLM with `memesh config set llm.provider anthropic`.');
     }
-    const parsed = parseJsonFile(configPath, readFileSyncImpl);
-    if (!parsed.ok) {
-        return createCheck('config', 'Config', 'fail', `Config file is invalid JSON at ${configPath}.`, `Fix or remove ${configPath}, then run \`memesh config list\` to confirm it loads cleanly.`, { code: 'config.invalid-json', params: { path: configPath } });
+    try {
+        const raw = readFileSyncImpl(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return createCheck('config', 'Config', 'fail', `${configPath} parsed but is not a JSON object — every setting is being ignored.`, `Fix or remove ${configPath}, then re-run memesh doctor.`, { code: 'config-parse.not-object', params: { path: configPath } });
+        }
+        return createCheck('config', 'Config', 'pass', `${configPath} is valid JSON and its settings are in effect.`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return createCheck('config', 'Config', 'fail', `${configPath} could not be read or parsed (${msg}). Every setting in it — LLM provider, fallbacks, embedder — is being silently ignored right now.`, `Fix the JSON or remove the file to fall back to defaults: mv ${configPath} ${configPath}.bak`, { code: 'config-parse.unreadable', params: { path: configPath, detail: msg } });
     }
-    return createCheck('config', 'Config', 'pass', `Config file is readable at ${configPath}.`);
 }
 function inspectMcpConfig(packageRoot, existsSyncImpl, readFileSyncImpl) {
     const mcpPath = path.join(packageRoot, '.mcp.json');
@@ -138,7 +142,15 @@ function inspectMcpConfig(packageRoot, existsSyncImpl, readFileSyncImpl) {
     if (!server || typeof server.command !== 'string') {
         return createCheck('mcp-config', 'MCP config', 'fail', '.mcp.json does not define a usable `memesh` MCP server entry.', 'Reinstall MeMesh or restore the `mcpServers.memesh` entry in `.mcp.json`.', { code: 'mcp-config.no-entry' });
     }
-    return createCheck('mcp-config', 'MCP config', 'pass', '.mcp.json is present and defines the memesh MCP server.');
+    const args = Array.isArray(server.args) ? server.args : [];
+    const entry = typeof args[0] === 'string' ? args[0] : null;
+    if (entry) {
+        const resolved = path.resolve(entry.replaceAll('${CLAUDE_PLUGIN_ROOT}', packageRoot));
+        if (!existsSyncImpl(resolved)) {
+            return createCheck('mcp-config', 'MCP config', 'fail', `.mcp.json starts \`${entry}\`, and that file is not in this install — so every memesh MCP tool fails to start.`, 'Reinstall MeMesh; if you edited `.mcp.json` by hand, point it back at `${CLAUDE_PLUGIN_ROOT}/dist/mcp/server.js`.', { code: 'mcp-config.entry-missing', params: { entry, resolved } });
+        }
+    }
+    return createCheck('mcp-config', 'MCP config', 'pass', '.mcp.json is present, defines the memesh MCP server, and the script it starts exists.');
 }
 function extractHookScriptPaths(hooksConfig, packageRoot) {
     const hooks = hooksConfig.hooks;
@@ -206,16 +218,16 @@ function inspectHooksConfig(packageRoot, platform, existsSyncImpl, readFileSyncI
         createCheck('hook-scripts', 'Hook scripts', 'pass', `All ${scriptPaths.length} hook scripts are present${platform === 'win32' ? '' : ' and executable'}.`),
     ];
 }
-function inspectHookWiring(existsSyncImpl, readFileSyncImpl, memeshDir, packageRoot) {
+function inspectHookWiring(existsSyncImpl, readFileSyncImpl, memeshDir, installChannel, installedPluginsPath) {
     const markerPath = path.join(memeshDir, 'install-hooks.json');
     if (!existsSyncImpl(markerPath)) {
-        if (packageRoot) {
-            const pluginManifest = path.join(packageRoot, '.claude-plugin', 'plugin.json');
-            if (existsSyncImpl(pluginManifest)) {
-                return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'pass', 'Wired via Claude Code plugin runtime (.claude-plugin/plugin.json present). The install-hooks marker is not used on this install path.');
-            }
+        if (installChannel === 'plugin-marketplace') {
+            return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'pass', 'Wired via the Claude Code plugin runtime (this is a plugin-marketplace install). The install-hooks marker is not used on this install path.');
         }
-        return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'warn', 'memesh is not connected to Claude Code yet, so nothing gets remembered automatically from your sessions.', 'Run `memesh install-hooks` once to connect it, then `memesh doctor` to confirm.', { code: 'hook-wiring.no-marker' });
+        if (detectPluginRuntime(installedPluginsPath)) {
+            return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'pass', 'Wired via the Claude Code plugin runtime (found in installed_plugins.json). This copy is not the one doing the capturing — the plugin manages the hooks.');
+        }
+        return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'warn', 'memesh is not connected to Claude Code yet, so nothing gets remembered automatically from your sessions.', 'Run `memesh install-hooks` once to connect it, then `memesh doctor` to confirm.', { code: 'hook-wiring.no-marker' }, 'install-hooks');
     }
     const parsed = parseJsonFile(markerPath, readFileSyncImpl);
     if (!parsed.ok) {
@@ -232,58 +244,147 @@ function inspectHookWiring(existsSyncImpl, readFileSyncImpl, memeshDir, packageR
     if (!settingsParsed.ok) {
         return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'fail', `${marker.settings_path} is no longer valid JSON.`, 'Restore from your ~/.claude backups or re-create with `memesh install-hooks`.', { code: 'hook-wiring.settings-invalid', params: { path: String(marker.settings_path) } });
     }
+    const CAPTURE_EVENTS = new Set(['Stop', 'PostToolUse', 'PreCompact']);
     const hooks = settingsParsed.value.hooks;
     let hasMemeshHook = false;
+    let hasCaptureHook = false;
+    let missingScript = null;
     if (hooks && typeof hooks === 'object') {
-        for (const entries of Object.values(hooks)) {
+        for (const [event, entries] of Object.entries(hooks)) {
             if (!Array.isArray(entries))
                 continue;
             for (const entry of entries) {
                 const cmds = entry.hooks;
                 if (!Array.isArray(cmds))
                     continue;
-                if (cmds.some((c) => c._memesh === true)) {
+                for (const c of cmds) {
+                    const cmd = c;
+                    if (cmd._memesh !== true)
+                        continue;
                     hasMemeshHook = true;
-                    break;
+                    if (CAPTURE_EVENTS.has(event))
+                        hasCaptureHook = true;
+                    if (missingScript === null && typeof cmd.command === 'string'
+                        && path.isAbsolute(cmd.command) && !existsSyncImpl(cmd.command)) {
+                        missingScript = cmd.command;
+                    }
                 }
             }
-            if (hasMemeshHook)
-                break;
         }
     }
+    if (missingScript !== null) {
+        return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'fail', `A wired memesh hook points at ${missingScript}, which no longer exists — the agent invokes a missing file on every matching event. This is usually residue from an upgrade that retired the hook.`, 'Run `memesh install-hooks` to re-wire (it now removes retired entries), then restart your agent.', { code: 'hook-wiring.script-missing', params: { path: missingScript } });
+    }
     if (!hasMemeshHook) {
         return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'fail', `Marker recorded a memesh install at ${marker.settings_path}, but no _memesh:true hook entries are present anymore. Settings drifted (manual edit?) or memesh was uninstalled out-of-band.`, 'Re-run `memesh install-hooks` to re-wire.', { code: 'hook-wiring.entries-removed', params: { path: String(marker.settings_path) } });
     }
     if (typeof marker.plugin_root === 'string' && !existsSyncImpl(marker.plugin_root)) {
         return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'fail', `Hook commands point at ${marker.plugin_root}, which no longer exists (likely after an npm-global path change).`, 'Re-run `memesh install-hooks` to refresh paths.', { code: 'hook-wiring.root-moved', params: { path: String(marker.plugin_root) } });
     }
-    return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'pass', `Wired in ${marker.settings_path} (scope: ${marker.scope ?? 'user'}, version: ${marker.version ?? 'unknown'}).`);
+    return createCheck('hook-wiring', 'Hooks wired into Claude Code', 'pass', `Wired in ${marker.settings_path} (scope: ${marker.scope ?? 'user'}, version: ${marker.version ?? 'unknown'}).`, undefined, { params: { captureWired: hasCaptureHook ? 1 : 0 } });
 }
-function inspectHookActivity(openDatabaseImpl, closeDatabaseImpl, existsSyncImpl = fs.existsSync, statSyncImpl = fs.statSync) {
+function inspectHookActivity(openDatabaseImpl, closeDatabaseImpl, existsSyncImpl = fs.existsSync, statSyncImpl = fs.statSync, wiringPresent = true) {
+    const TITLE = 'Hook activity';
+    const captureOff = autoCaptureOffSource();
+    if (captureOff === 'config') {
+        return createCheck('hook-activity', TITLE, 'pass', 'Automatic capture is turned off (config autoCapture: false) — deliberately, so hook silence is expected. Re-enable it to resume capturing sessions.', undefined, { code: 'hook-activity.disabled' });
+    }
+    if (captureOff === 'env') {
+        return createCheck('hook-activity', TITLE, 'pass', 'Automatic capture is turned off by MEMESH_AUTO_CAPTURE=false in this shell\'s environment. Doctor can only see its own environment — if your agent runs without this variable, capture there is unaffected.', undefined, { code: 'hook-activity.disabled-env' });
+    }
     let db = null;
     try {
         db = openDatabaseImpl();
-        const row = db.prepare(`SELECT COUNT(*) as c FROM entities
-       WHERE type IN ('session-insight', 'session-summary', 'commit', 'lesson_learned')
-         AND created_at > datetime('now', '-24 hours')`).get();
-        const count = row?.c ?? 0;
-        if (count === 0) {
-            const markerPath = path.join(memeshDir(), 'install-hooks.json');
-            if (existsSyncImpl(markerPath)) {
-                try {
-                    const ageMs = Date.now() - statSyncImpl(markerPath).mtimeMs;
-                    if (ageMs < 24 * 60 * 60 * 1000) {
-                        return createCheck('hook-activity', 'Hook activity (last 24h)', 'pass', 'Hooks wired recently — no captureable sessions yet (this is normal for a fresh install).');
-                    }
+        const hookRunsTablePresent = !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'hook_runs'").get();
+        const rows = hookRunsTablePresent
+            ? db.prepare(`SELECT hook, last_run_at FROM hook_runs`).all()
+            : [];
+        const captured = db.prepare(`SELECT COUNT(DISTINCT e.id) as c FROM entities e
+       JOIN tags t ON t.entity_id = e.id
+       WHERE t.tag = ?
+         AND e.created_at > datetime('now', '-24 hours')`).get(AUTO_CAPTURE_TAG)?.c ?? 0;
+        const since = db.prepare("SELECT value FROM memesh_metadata WHERE key = 'hook_runs_since'").get()?.value;
+        const measuringHours = since !== undefined ? hoursSince(since) : null;
+        const SKEW_TOLERANCE_H = 5 / 60;
+        const KNOWN_HOOKS = new Set(['session-summary', 'post-commit', 'pre-compact']);
+        const ages = new Map();
+        for (const r of rows) {
+            if (!KNOWN_HOOKS.has(r.hook))
+                continue;
+            const age = hoursSince(r.last_run_at);
+            ages.set(r.hook, age !== null && age >= -SKEW_TOLERANCE_H ? Math.max(age, 0) : null);
+        }
+        if (ages.size > 0) {
+            const capturedTail = captured > 0
+                ? `${captured} memor${captured === 1 ? 'y' : 'ies'} captured in the last 24h.`
+                : 'Nothing was worth saving in that time, which is normal — the loop still ran.';
+            const staleUnknown = (hook) => createCheck('hook-activity', TITLE, 'fail', `The ${hook} hook's last-run timestamp cannot be read (corrupt, or stamped by a machine with a wrong clock). ` +
+                'Capture health is unknown, which is not the same as healthy.', 'End one work session, then re-run `memesh doctor` — a fresh run overwrites the bad timestamp.', { code: 'hook-activity.stale-unknown', params: { hook } });
+            const stale = (hook, age, status) => createCheck('hook-activity', TITLE, status, `The ${hook} hook last ran ${formatHoursAgo(Math.ceil(age))}. ` +
+                'If you have worked since then, capture has stopped and nothing from those sessions was saved.', 'Restart your agent, then end one session and re-run `memesh doctor`. If it does not recover, run `memesh install-hooks`.', { code: 'hook-activity.stale', params: { hook, hours: Math.ceil(age) } });
+            const ssAge = ages.has('session-summary') ? ages.get('session-summary') : undefined;
+            if (ssAge === null)
+                return staleUnknown('session-summary');
+            if (ssAge !== undefined) {
+                if (ssAge <= 24) {
+                    return createCheck('hook-activity', TITLE, 'pass', `The session-summary hook last ran ${formatHoursAgo(ssAge)} — auto-capture is alive. ${capturedTail}`);
+                }
+                if (ssAge <= 72)
+                    return stale('session-summary', ssAge, 'warn');
+                const ccWrites = db.prepare(`SELECT COUNT(*) as c FROM entities
+           WHERE created_at > datetime('now', '-72 hours')
+             AND json_valid(metadata)
+             AND json_extract(metadata, '$.provenance.source_host') = 'claude-code'`).get()?.c ?? 0;
+                if (ccWrites > 0)
+                    return stale('session-summary', ssAge, 'fail');
+                return createCheck('hook-activity', TITLE, 'warn', `The session-summary hook last ran ${formatHoursAgo(Math.ceil(ssAge))}, and no Claude Code writes landed in the last 3 days either. If this machine has moved to another agent (Codex / Gemini), this is expected; if you still use Claude Code here, capture has stopped.`, 'If you still use Claude Code on this machine: restart it, end one session, and re-run `memesh doctor`. If it does not recover, run `memesh install-hooks`.', { code: 'hook-activity.stale-unconfirmed', params: { hook: 'session-summary', hours: Math.ceil(ssAge) } });
+            }
+            const known = [...ages.entries()].filter((e) => e[1] !== null);
+            if (known.length === 0) {
+                const [hook] = [...ages.keys()].sort();
+                return staleUnknown(hook);
+            }
+            const [freshestHook, freshestAge] = known.sort((a, b) => a[1] - b[1])[0];
+            if (freshestAge <= 24) {
+                if (measuringHours !== null && measuringHours > 72) {
+                    return createCheck('hook-activity', TITLE, 'warn', `The ${freshestHook} hook is stamping (last ran ${formatHoursAgo(freshestAge)}), but the session-summary hook has never run once in the ${Math.round(measuringHours)} hours since tracking began — session capture may be broken while commit capture hides it.`, 'End one work session and re-run `memesh doctor`. If session-summary still has not run, run `memesh install-hooks` and restart your agent.', { code: 'hook-activity.stop-silent', params: { hook: freshestHook, hours: Math.round(measuringHours) } });
+                }
+                return createCheck('hook-activity', TITLE, 'pass', `The ${freshestHook} hook last ran ${formatHoursAgo(freshestAge)} — auto-capture is alive. ` +
+                    `(session-summary has not stamped yet — expected until a session with real work ends.) ${capturedTail}`);
+            }
+            return stale(freshestHook, freshestAge, 'warn');
+        }
+        if (since !== undefined && (measuringHours === null || measuringHours < 0)) {
+            return createCheck('hook-activity', TITLE, 'pass', 'The hook-run tracking marker is unreadable — it will be re-stamped automatically the next time the database is opened for writing (any session, commit, or memesh command does it). Tracking restarts then.');
+        }
+        if (measuringHours === null || measuringHours < 24) {
+            return createCheck('hook-activity', TITLE, 'pass', 'Hook-run tracking has only just started on this database — the first work session will fill it in.');
+        }
+        const markerPath = path.join(memeshDir(), 'install-hooks.json');
+        if (existsSyncImpl(markerPath)) {
+            try {
+                if (Date.now() - statSyncImpl(markerPath).mtimeMs < 24 * 60 * 60 * 1000) {
+                    return createCheck('hook-activity', TITLE, 'pass', 'Hooks were wired in the last day and no session has ended yet — normal for a fresh install.');
                 }
-                catch { }
             }
-            return createCheck('hook-activity', 'Hook activity (last 24h)', 'warn', 'memesh has not saved anything automatically in the last 24 hours. Everything is set up — it just has not seen a work session to remember yet. If you HAVE been working all day, Claude Code may need a restart to pick the connection up.', 'Do a normal Claude Code work session (or make a git commit), then check again with `memesh doctor`.', { code: 'hook-activity.quiet' });
+            catch { }
         }
-        return createCheck('hook-activity', 'Hook activity (last 24h)', 'pass', `${count} memesh-attributed entit${count === 1 ? 'y' : 'ies'} captured in the past 24h — auto-capture loop is alive.`);
+        const legacyCaptured = db.prepare(`SELECT COUNT(DISTINCT e.id) as c FROM entities e
+       JOIN tags t ON t.entity_id = e.id
+       WHERE t.tag = ?
+         AND e.created_at > ?`).get(AUTO_CAPTURE_TAG, since)?.c ?? 0;
+        if (legacyCaptured > 0) {
+            return createCheck('hook-activity', TITLE, 'warn', `No hook has stamped the heartbeat, but ${legacyCaptured} auto-capture memor${legacyCaptured === 1 ? 'y' : 'ies'} landed since tracking began — hooks from a version before heartbeat tracking are probably still running.`, 'Update the memesh hooks to the current version (plugin installs: `/plugin update memesh`; npm installs: `memesh install-hooks`), then restart your agent.', { code: 'hook-activity.never-ran-legacy', params: { captured: legacyCaptured } });
+        }
+        if (!wiringPresent) {
+            return createCheck('hook-activity', TITLE, 'warn', 'No capture hook has ever run — and no capture hook (Stop / PostToolUse / PreCompact) is confirmed wired on this machine, so there is nothing to run.', 'If you want automatic capture, run `memesh install-hooks`. If this install is MCP-only (Codex / Gemini), this is expected and safe to ignore.', { code: 'hook-activity.not-wired' });
+        }
+        return createCheck('hook-activity', TITLE, 'fail', `No capture hook has run since tracking began ${formatHoursAgo(measuringHours)}. ` +
+            'Hook wiring is in place, so they should be executing and are not — nothing is being remembered.', 'Run `memesh doctor` after ending one work session. If this still says no hook has run, run `memesh install-hooks` and restart your agent.', { code: 'hook-activity.never-ran', params: { hours: Math.round(measuringHours) } });
     }
     catch (err) {
-        return createCheck('hook-activity', 'Hook activity (last 24h)', 'warn', `Could not query the database: ${err instanceof Error ? err.message : String(err)}`, undefined, { code: 'hook-activity.query-failed', params: { detail: err instanceof Error ? err.message : String(err) } });
+        const detail = err instanceof Error ? err.message : String(err);
+        return createCheck('hook-activity', TITLE, 'fail', `Could not read hook activity from the database: ${detail}. Capture health is unknown, which is not the same as healthy.`, 'Run `memesh doctor --verbose` for the full error, and check that ~/.memesh is readable and not out of disk.', { code: 'hook-activity.query-failed', params: { detail } });
     }
     finally {
         try {
@@ -293,6 +394,34 @@ function inspectHookActivity(openDatabaseImpl, closeDatabaseImpl, existsSyncImpl
         catch { }
     }
 }
+function autoCaptureOffSource() {
+    let configAutoCapture;
+    try {
+        configAutoCapture = readConfig().autoCapture;
+    }
+    catch {
+        configAutoCapture = undefined;
+    }
+    return autoCaptureDecision(process.env.MEMESH_AUTO_CAPTURE, configAutoCapture).offSource;
+}
+export function hoursSince(sqliteTimestamp) {
+    const then = parseSqliteUtcMs(sqliteTimestamp);
+    if (then === null)
+        return null;
+    return (Date.now() - then) / (60 * 60 * 1000);
+}
+function formatHoursAgo(hours) {
+    if (hours === null || !Number.isFinite(hours) || hours < 0)
+        return 'at an unknown time';
+    if (hours < 1)
+        return 'less than an hour ago';
+    if (hours < 48) {
+        const h = Math.round(hours);
+        return `${h} hour${h === 1 ? '' : 's'} ago`;
+    }
+    const d = Math.round(hours / 24);
+    return `${d} day${d === 1 ? '' : 's'} ago`;
+}
 function defaultResolveShellMemesh() {
     try {
         const cmd = process.platform === 'win32' ? 'where' : 'which';
@@ -306,12 +435,23 @@ function defaultResolveShellMemesh() {
         return null;
     }
 }
+const RUNTIME_TOO_OLD = 'memesh:node-sqlite-too-old';
 function defaultNativeBindingProbe(packageRoot) {
     try {
-        const localRequire = createRequire(pathToFileURL(path.join(packageRoot, 'package.json')).href);
-        const Database = localRequire('better-sqlite3');
-        const probe = new Database(':memory:');
-        probe.close();
+        const probe = new MemeshDatabase(':memory:', { allowExtension: true });
+        try {
+            if (typeof probe.enableLoadExtension !== 'function') {
+                return { ok: false, message: `${RUNTIME_TOO_OLD}: node:sqlite in ${process.version} has no enableLoadExtension` };
+            }
+            probe.enableLoadExtension(true);
+            const localRequire = createRequire(pathToFileURL(path.join(packageRoot, 'package.json')).href);
+            const sqliteVec = localRequire('sqlite-vec');
+            sqliteVec.load(probe);
+            probe.prepare('SELECT vec_version()').get();
+        }
+        finally {
+            probe.close();
+        }
         return { ok: true };
     }
     catch (err) {
@@ -373,20 +513,16 @@ export function hasBuiltInSqlite() {
 function inspectNativeBinding(packageRoot, _existsSyncImpl, probeImpl = defaultNativeBindingProbe) {
     const result = probeImpl(packageRoot);
     if (result.ok) {
-        return createCheck('native-binding', 'Native SQLite binding', 'pass', 'better-sqlite3 native binding loads cleanly (Database probe succeeded).');
+        return createCheck('native-binding', 'SQLite and vector search', 'pass', 'node:sqlite opened a database and sqlite-vec loaded (probe succeeded).');
+    }
+    if (result.message.startsWith(RUNTIME_TOO_OLD)) {
+        return createCheck('native-binding', 'SQLite and vector search', 'fail', `The node:sqlite in this Node (${process.version}) is too old for memesh — it cannot load the vector-search extension. The complete version arrived in Node 22.13.`, 'Upgrade Node to 22.13 or newer, then re-run `memesh doctor`.', { code: 'native-binding.node-too-old', params: { version: process.version } });
     }
-    const isMissingBinding = /bindings file|locate the bindings/i.test(result.message);
     const isMissingPackage = /MODULE_NOT_FOUND|Cannot find module/i.test(result.message);
     if (isMissingPackage) {
-        return createCheck('native-binding', 'Native SQLite binding', 'fail', 'better-sqlite3 is not installed (Node could not resolve the module from any '
-            + 'parent node_modules). Memesh hooks and database operations will not work.', `Run: npm install   (in the directory that depends on @pcircle/memesh)`, { code: 'native-binding.not-installed' });
+        return createCheck('native-binding', 'SQLite and vector search', 'warn', 'sqlite-vec is not installed, so memesh cannot search by meaning. Memories are still saved, and still found by keyword.', 'Run: npm install   (in the directory that depends on @pcircle/memesh)', { code: 'native-binding.not-installed' });
     }
-    if (isMissingBinding) {
-        return createCheck('native-binding', 'Native SQLite binding', 'fail', 'better-sqlite3 is installed but the native binding (.node file) is missing. '
-            + 'Hooks will silently skip-and-exit, and auto-capture will NOT write any entities. '
-            + 'This is the plugin-marketplace silent-dropout class of bug.', `Run: cd "${packageRoot}" && npm rebuild better-sqlite3   (or "npm install --omit=dev" for a clean reinstall)`, { code: 'native-binding.missing', params: { root: packageRoot } });
-    }
-    return createCheck('native-binding', 'Native SQLite binding', 'fail', `better-sqlite3 failed to load: ${result.message}`, `Run: cd "${packageRoot}" && npm rebuild better-sqlite3`, { code: 'native-binding.load-failed', params: { detail: result.message, root: packageRoot } });
+    return createCheck('native-binding', 'SQLite and vector search', 'warn', `sqlite-vec could not be loaded: ${result.message}. Memories are still saved and found by keyword; only search by meaning is off.`, `Run: cd "${packageRoot}" && npm install --omit=dev`, { code: 'native-binding.load-failed', params: { detail: result.message, root: packageRoot } });
 }
 function inspectShellCli(installChannel, packageRoot, resolveShellMemeshImpl) {
     const shellPath = resolveShellMemeshImpl();
@@ -540,25 +676,7 @@ function verifySkillsManifest(packageRoot, existsSyncImpl, readFileSyncImpl) {
         missing.length > 0 ? `${missing.length} missing: ${missing.slice(0, 3).join(', ')}${missing.length > 3 ? ` (+${missing.length - 3} more)` : ''}` : null,
         mismatches.length > 0 ? `${mismatches.length} tampered: ${mismatches.slice(0, 3).join(', ')}${mismatches.length > 3 ? ` (+${mismatches.length - 3} more)` : ''}` : null,
     ].filter(Boolean).join('; ');
-    return createCheck('skills-manifest', 'Skills + hooks integrity', 'fail', `Manifest verification failed: ${detail}.`, 'Reinstall the package: `npm install -g @pcircle/memesh`. If the problem reproduces on a fresh install, open a security issue at https://github.com/PCIRCLE-AI/memesh-llm-memory/security.', { code: 'skills-manifest.verify-failed', params: { detail } });
-}
-async function inspectConfigParse(getConfigPathImpl, existsSyncImpl, readFileSyncImpl) {
-    const configPath = getConfigPathImpl();
-    if (!existsSyncImpl(configPath)) {
-        return createCheck('config_parse', 'Config parses', 'pass', 'No config file yet — defaults apply. This is normal for a fresh install.');
-    }
-    try {
-        const raw = readFileSyncImpl(configPath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return createCheck('config_parse', 'Config parses', 'fail', `${configPath} parsed but is not a JSON object — every setting is being ignored.`, `Fix or remove ${configPath}, then re-run memesh doctor.`, { code: 'config-parse.not-object', params: { path: configPath } });
-        }
-        return createCheck('config_parse', 'Config parses', 'pass', `${configPath} is valid JSON and its settings are in effect.`);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return createCheck('config_parse', 'Config parses', 'fail', `${configPath} could not be read or parsed (${msg}). Every setting in it — LLM provider, fallbacks, embedder — is being silently ignored right now.`, `Fix the JSON or remove the file to fall back to defaults: mv ${configPath} ${configPath}.bak`, { code: 'config-parse.unreadable', params: { path: configPath, detail: msg } });
-    }
+    return createCheck('skills-manifest', 'Skills + hooks integrity', 'fail', `Manifest verification failed: ${detail}.`, 'Reinstall the package: `npm install -g @pcircle/memesh`. If the problem reproduces on a fresh install, open a security issue at https://github.com/PCIRCLE-AI/memesh/security.', { code: 'skills-manifest.verify-failed', params: { detail } });
 }
 async function inspectEmbeddingProbe(capabilities, probeCapabilities, embedTextImpl) {
     if (capabilities.embeddings === 'tfidf') {
@@ -617,7 +735,7 @@ function summarizeOverallStatus(checks) {
     return 'PASS';
 }
 export async function runDoctor(options) {
-    const { packageRoot, packageVersion, probeHttp = false, probeCapabilities = false, embedTextImpl = embedText, probeProviderImpl = probeProvider, httpBaseUrl = 'http://127.0.0.1:3737', platform = process.platform, openDatabaseImpl = openDatabase, closeDatabaseImpl = closeDatabase, isDatabaseOpenImpl = isDatabaseOpen, detectCapabilitiesImpl = detectCapabilities, getConfigPathImpl = getConfigPath, getUpdateCheckImpl = getUpdateCheck, getCurrentInstallChannelImpl = getCurrentInstallChannel, getInstallChannelSupportImpl = getInstallChannelSupport, existsSyncImpl = fs.existsSync, readFileSyncImpl = fs.readFileSync, statSyncImpl = fs.statSync, fetchImpl = fetch, nativeBindingProbeImpl, resolveShellMemeshImpl = defaultResolveShellMemesh, } = options;
+    const { packageRoot, packageVersion, probeHttp = false, probeCapabilities = false, embedTextImpl = embedText, probeProviderImpl = probeProvider, httpBaseUrl = 'http://127.0.0.1:3737', platform = process.platform, openDatabaseImpl = openDatabase, closeDatabaseImpl = closeDatabase, isDatabaseOpenImpl = isDatabaseOpen, detectCapabilitiesImpl = detectCapabilities, getConfigPathImpl = getConfigPath, getUpdateCheckImpl = getUpdateCheck, getCurrentInstallChannelImpl = getCurrentInstallChannel, installedPluginsPathImpl, getInstallChannelSupportImpl = getInstallChannelSupport, existsSyncImpl = fs.existsSync, readFileSyncImpl = fs.readFileSync, statSyncImpl = fs.statSync, fetchImpl = fetch, nativeBindingProbeImpl, resolveShellMemeshImpl = defaultResolveShellMemesh, } = options;
     const wasDbOpenBeforeUs = isDatabaseOpenImpl();
     const safeCloseDatabaseImpl = wasDbOpenBeforeUs
         ? () => undefined
@@ -647,7 +765,7 @@ export async function runDoctor(options) {
                 dbChecks.push(createCheck('fts_segmentation', 'Keyword index segmentation', 'warn', `The keyword index holds ${unsegmented.c} unsegmented term(s), so some memories are only ` +
                     `findable by their exact full text. This happens when an older build wrote to a database ` +
                     `that a newer one had already migrated — the version marker only moves forward, so the ` +
-                    `automatic rebuild cannot notice. Re-run doctor after the rebuild: this count should be 0.`, `Run 'memesh reindex --fts' to rebuild the keyword index.`, { code: 'fts.unsegmented', params: { count: unsegmented.c } }));
+                    `automatic rebuild cannot notice. Re-run doctor after the rebuild: this count should be 0.`, `Run 'memesh reindex --fts' to rebuild the keyword index.`, { code: 'fts.unsegmented', params: { count: unsegmented.c } }, 'fts-rebuild'));
             }
         }
         const pendingReindex = getPendingReindexInfo();
@@ -659,6 +777,7 @@ export async function runDoctor(options) {
         const message = err instanceof Error ? err.message : 'unknown database error';
         let diagnosis;
         let fix;
+        let fixId;
         if (existsSyncImpl(databasePath)) {
             try {
                 const stat = statSyncImpl(databasePath);
@@ -667,6 +786,7 @@ export async function runDoctor(options) {
                 if (!canRead || !canWrite) {
                     diagnosis = `Database file exists but has insufficient permissions (${(stat.mode & 0o777).toString(8)})`;
                     fix = `Fix permissions: chmod 600 "${databasePath}"`;
+                    fixId = 'chmod-db';
                 }
                 else if (stat.size === 0) {
                     diagnosis = 'Database file is empty (0 bytes) — likely corrupted';
@@ -708,7 +828,7 @@ export async function runDoctor(options) {
             }
         }
         dbChecks.length = 0;
-        dbChecks.push(createCheck('database', 'Database', 'fail', diagnosis, fix, { code: 'database.broken', params: { detail: diagnosis } }));
+        dbChecks.push(createCheck('database', 'Database', 'fail', diagnosis, fix, { code: 'database.broken', params: { detail: diagnosis } }, fixId));
     }
     finally {
         checks.push(...dbChecks);
@@ -721,8 +841,11 @@ export async function runDoctor(options) {
     checks.push(inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl));
     checks.push(inspectMcpConfig(packageRoot, existsSyncImpl, readFileSyncImpl));
     checks.push(...inspectHooksConfig(packageRoot, platform, existsSyncImpl, readFileSyncImpl, statSyncImpl));
-    checks.push(inspectHookWiring(existsSyncImpl, readFileSyncImpl, memeshDir(), packageRoot));
-    checks.push(inspectHookActivity(openDatabaseImpl, safeCloseDatabaseImpl, existsSyncImpl, statSyncImpl));
+    const wiring = inspectHookWiring(existsSyncImpl, readFileSyncImpl, memeshDir(), install, installedPluginsPathImpl);
+    checks.push(wiring);
+    const captureWired = wiring.status === 'pass'
+        && (wiring.params === undefined || wiring.params.captureWired === 1);
+    checks.push(inspectHookActivity(openDatabaseImpl, safeCloseDatabaseImpl, existsSyncImpl, statSyncImpl, captureWired));
     checks.push(inspectDashboardArtifact(packageRoot, existsSyncImpl));
     checks.push(inspectNodeRuntime(packageRoot, existsSyncImpl, readFileSyncImpl));
     checks.push(inspectNativeBinding(packageRoot, existsSyncImpl, nativeBindingProbeImpl));
@@ -740,7 +863,6 @@ export async function runDoctor(options) {
             : `last mined ${((Date.now() - last) / 3600_000).toFixed(1)}h ago`;
         checks.push(createInfo('transcript-mining', 'Scheduled transcript mining', `On for this project — ${when}. Have a scheduler run \`memesh dream run --from-transcripts --if-due\`; it mines when due (default every 24h) and stages proposals. Review the queue with \`memesh dream list\`.`));
     }
-    checks.push(await inspectConfigParse(getConfigPathImpl, existsSyncImpl, readFileSyncImpl));
     checks.push(await inspectEmbeddingProbe(capabilities, probeCapabilities, embedTextImpl));
     checks.push(await inspectLlmProbe(capabilities, probeCapabilities, probeProviderImpl));
     checks.push(await inspectUpdateStatus(packageVersion, getUpdateCheckImpl, installSupport));