@pcircle/memesh 4.8.3 → 4.9.0

package/dist/core/doctor.js

@@ -4,22 +4,16 @@ import path from 'path';
 import net from 'node:net';
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
-import { pathToFileURL } from 'url';
 import { execFileSync } from 'child_process';
-import { detectCapabilities, getConfigPath, isTranscriptMiningEnabled, readConfig } from './config.js';
-import { embedText } from './embedder.js';
-import { probeProvider } from './llm-validator.js';
-import { openDatabase, closeDatabase, getPendingReindexInfo, isDatabaseOpen, readVectorGeneration, generationRowIds, } from '../db.js';
+import { findRetiredConfigKeys, getConfigPath, readConfig } from './config.js';
+import { openDatabase, closeDatabase, isDatabaseOpen, } from '../db.js';
 import { getUpdateCheck } from './version-check.js';
 import { classifyBump } from './updater.js';
 import { getCurrentInstallChannel, getInstallChannelSupport, detectPluginHost, pluginHostConfigRoot, versionedPluginCacheRoots, PLUGIN_REFRESH_COMMANDS, } from './install-channel.js';
 import { getInstallRecord } from './install-id.js';
 import { citationRulePath, citationRuleState } from './citation-rule.js';
-import { getDbPath, getMemeshDirFromDbPath, homeDir, memeshDir, getProjectName } from './paths.js';
+import { getAgentRouterSocketPath, getDbPath, getMemeshDirFromDbPath, homeDir, memeshDir } from './paths.js';
 import { detectPluginRuntime, readInstallMarker } from './install-hooks.js';
-import { lastTranscriptMineAt } from './transcript-source.js';
-import { countMissingVectors } from './operations.js';
-import { hasVectorIndex } from '../storage/vector-index.js';
 import { UNSPACED_SCRIPT_GLOB_RUN3 } from '../storage/fts-index.js';
 import { MemeshDatabase } from '../storage/sqlite.js';
 import { AUTO_CAPTURE_TAG } from './types.js';
@@ -28,7 +22,6 @@ import { autoCaptureDecision } from './capture-flag.js';
 import { guardFromMetadata } from './guards.js';
 import { getAgentMessageStorageReport } from './agent-message-storage.js';
 import { readHostConfigFile } from '../host-runtime/config.js';
-const EMBEDDING_PROBE_TIMEOUT_MS = 15000;
 const EXPECTED_HOOK_TYPES = ['PreToolUse', 'SessionStart', 'PostToolUse', 'Stop', 'PreCompact'];
 const AGENT_MESSAGE_STORAGE_QUOTA_ENV = 'MEMESH_AGENT_MESSAGE_STORAGE_QUOTA_BYTES';
 const LOCALE_README_FILES = [
@@ -153,9 +146,9 @@ function inspectCodexSessionSetup(codexPluginCacheDetected, existsSyncImpl) {
         return null;
     const configPath = path.join(getMemeshDirFromDbPath(), 'hosts', 'codex-session.json');
     if (existsSyncImpl(configPath)) {
-        return createCheck('codex-session-setup', 'Codex ordinary-session notification setup', 'pass', 'A Codex plugin cache copy was detected, but this proves only that cached source exists, not that the plugin is enabled or registered. The explicit opt-in ordinary-session notification setup is present; durable inbox remains available, and MeMesh will not auto-attach.');
+        return createInfo('codex-session-setup', 'Codex ordinary-session notifications', 'A Codex identity override file is present and will be validated at SessionStart. A valid override applies only in its configured workspace; other Codex plugin sessions use automatic thread-scoped identities. A cached plugin copy does not prove a live registration; use `memesh message discover --project <project>` to read current presence.');
     }
-    return createCheck('codex-session-setup', 'Codex ordinary-session notification setup', 'warn', 'A Codex plugin cache copy was detected, but this proves only that cached source exists, not that the plugin is enabled or registered. Durable inbox remains available, but live ordinary-session wakeup is inactive. Setup is explicit opt-in; MeMesh will not auto-attach.', 'Run `memesh agent setup codex-session --project <project> --principal <principal> --workspace <exact-workspace>`, then restart Codex.', { code: 'codex-session.config-missing' });
+    return createInfo('codex-session-setup', 'Codex ordinary-session notifications', 'No explicit identity override is configured. When the Codex plugin is enabled, each startup or resumed thread registers automatically under a thread-scoped identity. A cached plugin copy does not prove a live registration; use `memesh message discover --project <project>` to read current presence.');
 }
 function configuredAgentMessageStoragePolicy(explicit) {
     if (explicit !== undefined)
@@ -194,14 +187,10 @@ function parseJsonFile(filePath, readFileSyncImpl) {
         };
     }
 }
-function inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl, envLlm) {
+function inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl) {
     const configPath = getConfigPathImpl();
     if (!existsSyncImpl(configPath)) {
-        return createCheck('config', 'Config', 'pass', envLlm
-            ? `No config file yet (${configPath}), but your environment names ${envLlm.provider}${envLlm.apiKey ? ' (via its API key)' : ' (via OLLAMA_HOST)'}, which enables Smart Mode. A file is only needed to pin a provider or change defaults.`
-            : `No config file yet (${configPath}). MeMesh will run in Core mode until you configure Smart Mode.`, envLlm
-            ? `Optional: \`memesh config set llm.provider ${envLlm.provider}\` pins it so it does not depend on which shell you run from.`
-            : 'Optional: run `memesh config list` or set an LLM with `memesh config set llm.provider anthropic`.');
+        return createCheck('config', 'Config', 'pass', `No config file yet (${configPath}); default settings are in effect.`, 'Optional: run memesh config list to inspect settings.');
     }
     try {
         const raw = readFileSyncImpl(configPath, 'utf8');
@@ -209,35 +198,66 @@ function inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl,
         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 } });
         }
+        const retiredKeys = findRetiredConfigKeys(parsed);
+        if (retiredKeys.length > 0) {
+            const keys = retiredKeys.join(', ');
+            return createCheck('config', 'Config', 'warn', `${configPath} is valid JSON but still contains ${retiredKeys.length} retired top-level setting(s) (${keys}). ` +
+                'This version ignores them, but legacy provider credentials or settings may remain on disk.', `Review ${configPath} locally and remove only those retired top-level keys. ` +
+                'Do not paste the file into an issue because it may contain credentials. Then run memesh doctor again.', {
+                code: 'config-parse.retired-settings',
+                params: { path: configPath, count: retiredKeys.length, keys },
+            });
+        }
         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', 'fail', `${configPath} could not be read or parsed (${msg}). Its settings are being 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 } });
     }
 }
-function inspectMcpConfig(packageRoot, existsSyncImpl, readFileSyncImpl) {
-    const mcpPath = path.join(packageRoot, '.mcp.json');
+const MCP_PLACEHOLDER = '${CLAUDE_PLUGIN_ROOT}';
+function declaredMcpManifest(packageRoot, readFileSyncImpl) {
+    const parsed = parseJsonFile(path.join(packageRoot, '.claude-plugin', 'plugin.json'), readFileSyncImpl);
+    if (!parsed.ok)
+        return null;
+    const declared = parsed.value.mcpServers;
+    if (typeof declared !== 'string' || !declared.startsWith('./'))
+        return null;
+    return declared.slice(2);
+}
+function inspectMcpConfig(packageRoot, installChannel, existsSyncImpl, readFileSyncImpl, env) {
+    const relativeManifest = declaredMcpManifest(packageRoot, readFileSyncImpl);
+    if (relativeManifest === null) {
+        return createCheck('mcp-config', 'MCP config', 'fail', '.claude-plugin/plugin.json declares no `mcpServers` path, so Claude Code has no MeMesh MCP server to start.', 'Reinstall MeMesh so the plugin manifest and the MCP manifest it names are both restored.', { code: 'mcp-config.missing' });
+    }
+    const label = relativeManifest;
+    const mcpPath = path.join(packageRoot, relativeManifest);
     if (!existsSyncImpl(mcpPath)) {
-        return createCheck('mcp-config', 'MCP config', 'fail', '.mcp.json is missing.', 'Restore `.mcp.json` from the package or reinstall MeMesh.', { code: 'mcp-config.missing' });
+        return createCheck('mcp-config', 'MCP config', 'fail', `${label} is missing.`, 'Reinstall MeMesh so the plugin manifest and the MCP manifest it names are both restored.', { code: 'mcp-config.missing' });
     }
     const parsed = parseJsonFile(mcpPath, readFileSyncImpl);
     if (!parsed.ok) {
-        return createCheck('mcp-config', 'MCP config', 'fail', '.mcp.json is not valid JSON.', `Fix ${mcpPath} so Claude Code can read the MCP server definition.`, { code: 'mcp-config.invalid-json', params: { path: mcpPath } });
+        return createCheck('mcp-config', 'MCP config', 'fail', `${label} is not valid JSON.`, `Fix ${mcpPath} so Claude Code can read the MCP server definition.`, { code: 'mcp-config.invalid-json', params: { path: mcpPath } });
     }
     const server = parsed.value.mcpServers?.memesh;
     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', 'fail', `${label} does not define a usable \`memesh\` MCP server entry.`, `Reinstall MeMesh or restore the \`mcpServers.memesh\` entry in \`${label}\`.`, { code: 'mcp-config.no-entry' });
     }
     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));
+        const pluginRoot = installChannel === 'plugin-marketplace' ? packageRoot : (env.CLAUDE_PLUGIN_ROOT || null);
+        if (entry.includes(MCP_PLACEHOLDER) && pluginRoot === null) {
+            return createCheck('mcp-config', 'MCP config', 'warn', `${label} starts \`${entry}\`. NOT VERIFIED: \`${MCP_PLACEHOLDER}\` is substituted by the Claude Code plugin runtime, and this is a ${installChannel} install with CLAUDE_PLUGIN_ROOT unset — so the file it names was not checked.`, `Verify it the way the plugin runtime would: CLAUDE_PLUGIN_ROOT=${packageRoot} memesh doctor`, { code: 'mcp-config.placeholder-unresolved', params: { entry, channel: installChannel } });
+        }
+        const resolved = pluginRoot === null
+            ? path.resolve(packageRoot, entry)
+            : path.resolve(entry.replaceAll(MCP_PLACEHOLDER, pluginRoot));
         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', 'fail', `${label} starts \`${entry}\`, and that file is not in this install — so every memesh MCP tool fails to start.`, `Reinstall MeMesh; if you edited \`${label}\` by hand, point it back at \`${MCP_PLACEHOLDER}/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.');
+    return createCheck('mcp-config', 'MCP config', 'pass', `${label} is present, defines the memesh MCP server, and the script it starts exists.`);
 }
 function extractHookScriptPaths(hooksConfig, packageRoot) {
     const hooks = hooksConfig.hooks;
@@ -530,19 +550,11 @@ function defaultResolveShellMemesh() {
         return null;
     }
 }
-const RUNTIME_TOO_OLD = 'memesh:node-sqlite-too-old';
-function defaultNativeBindingProbe(packageRoot) {
+function defaultNativeBindingProbe(_packageRoot) {
     try {
-        const probe = new MemeshDatabase(':memory:', { allowExtension: true });
+        const probe = new MemeshDatabase(':memory:');
         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();
+            probe.prepare('SELECT 1').get();
         }
         finally {
             probe.close();
@@ -607,19 +619,36 @@ export function hasBuiltInSqlite() {
 }
 function inspectNativeBinding(packageRoot, _existsSyncImpl, probeImpl = defaultNativeBindingProbe) {
     const result = probeImpl(packageRoot);
-    if (result.ok) {
-        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 } });
+    return result.ok
+        ? createCheck('native-binding', 'SQLite', 'pass', 'node:sqlite opened a database (probe succeeded).')
+        : createCheck('native-binding', 'SQLite', 'fail', `SQLite could not open a database: ${result.message}`, 'Check the Node runtime and reinstall if necessary.', { code: 'native-binding.load-failed', params: { detail: result.message, root: packageRoot } });
+}
+function readVersionFromInstalledBinary(binaryPath, existsSyncImpl, readFileSyncImpl, realpathSyncImpl = fs.realpathSync) {
+    let resolved;
+    try {
+        resolved = realpathSyncImpl(binaryPath);
     }
-    const isMissingPackage = /MODULE_NOT_FOUND|Cannot find module/i.test(result.message);
-    if (isMissingPackage) {
-        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' });
+    catch {
+        resolved = binaryPath;
     }
-    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 } });
+    let dir = path.dirname(resolved);
+    for (let depth = 0; depth < 8; depth += 1) {
+        const pkgPath = path.join(dir, 'package.json');
+        if (existsSyncImpl(pkgPath)) {
+            const parsed = parseJsonFile(pkgPath, readFileSyncImpl);
+            if (!parsed.ok)
+                return null;
+            const { name, version } = parsed.value;
+            return name === '@pcircle/memesh' && typeof version === 'string' ? version : null;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
 }
-function inspectShellCli(installChannel, packageRoot, resolveShellMemeshImpl) {
+function inspectShellCli(installChannel, packageRoot, packageVersion, resolveShellMemeshImpl, existsSyncImpl, readFileSyncImpl) {
     const shellPath = resolveShellMemeshImpl();
     const isSameAsCurrent = shellPath ? path.resolve(shellPath).startsWith(path.resolve(packageRoot)) : false;
     const hasDistinctShellCli = !!shellPath && !isSameAsCurrent;
@@ -629,12 +658,20 @@ function inspectShellCli(installChannel, packageRoot, resolveShellMemeshImpl) {
             : 'Running from npm-global install — shell access available in this terminal.');
     }
     if (hasDistinctShellCli) {
-        return createCheck('shell-cli', 'Shell CLI on PATH', 'pass', `\`memesh\` resolves to ${shellPath} (separate from this install at ${packageRoot}). Both paths coexist and share the same DB.`);
+        const shellVersion = readVersionFromInstalledBinary(shellPath, existsSyncImpl, readFileSyncImpl);
+        if (shellVersion) {
+            return {
+                ...createInfo('shell-cli', 'Shell CLI on PATH', `Installed versions: this interface ${packageVersion}; terminal ${shellVersion}.`),
+                code: 'shell-cli.versions',
+                params: { current: packageVersion, terminal: shellVersion, shellPath: shellPath, packageRoot },
+            };
+        }
+        return createCheck('shell-cli', 'Shell CLI on PATH', 'pass', `\`memesh\` resolves to ${shellPath} (separate from this install at ${packageRoot}) — could not read the shell copy's own version to compare.`);
     }
     if (installChannel === 'plugin-marketplace') {
         const host = detectPluginHost(packageRoot) === 'codex' ? 'Codex CLI' : 'Claude Code';
         return createCheck('shell-cli', 'Shell CLI on PATH', 'warn', 'Plugin is installed but `memesh` is not on the shell PATH. Typing `memesh` in a regular terminal will report `command not found`. '
-            + `${host} MCP / hooks / \`/memesh\` skill still work — this only affects standalone shell usage and other MCP clients (Cursor, Cline, etc.).`, 'Run `npm install -g @pcircle/memesh` to add the shell CLI. Both paths coexist; they share the same `~/.memesh/knowledge-graph.db`.', { code: 'shell-cli.not-on-path' });
+            + `${host} MCP / hooks / \`/memesh\` skill still work — this only affects standalone shell usage and other MCP clients (Cursor, Cline, etc.).`, 'Run `npm install -g @pcircle/memesh` if you want the separate shell CLI. Its database path depends on its environment and configuration.', { code: 'shell-cli.not-on-path' });
     }
     return createCheck('shell-cli', 'Shell CLI on PATH', 'pass', shellPath
         ? `\`memesh\` resolves to ${shellPath}.`
@@ -827,6 +864,24 @@ function inspectPluginCacheCurrency(installChannel, pluginHost, packageRoot, ins
     }
     return createCheck('plugin-cache', `Plugin cache source record is current (${hostLabel})`, 'warn', `The plugin cache records commit ${installedSha.slice(0, 8)}, but the marketplace has moved to ${marketplaceSha.slice(0, 8)} under the same version — ${hostLabel} does not normally refresh a cache whose version did not change, so refresh the cache before relying on the newer marketplace code.`, `Run \`${command}\` to refresh the cache in place, then restart ${hostLabel}.`, { code: 'plugin-cache.stale', params: { installed: installedSha.slice(0, 8), marketplace: marketplaceSha.slice(0, 8), host: hostLabel, command } });
 }
+function isClaudeChannelCommand(command) {
+    if (command === 'memesh-host-claude')
+        return true;
+    if (typeof command !== 'string' || !path.isAbsolute(command) || path.basename(command) !== 'memesh-host-claude') {
+        return false;
+    }
+    try {
+        const target = fs.realpathSync(command);
+        const stat = fs.statSync(target);
+        if (!stat.isFile())
+            return false;
+        fs.accessSync(target, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function inspectClaudeChannelRegistration(existsSyncImpl, readFileSyncImpl) {
     const configPath = path.join(homeDir(), '.claude.json');
     let parsed = null;
@@ -875,14 +930,15 @@ function inspectClaudeChannelRegistration(existsSyncImpl, readFileSyncImpl) {
             targetConfigValid = false;
         }
     }
-    const coherent = command === 'memesh-host-claude'
+    const commandValid = isClaudeChannelCommand(command);
+    const coherent = commandValid
         && args !== null
         && args.length === 2
         && configIndex === 0
         && target !== null
         && targetConfigValid;
     if (!coherent) {
-        const reason = command !== 'memesh-host-claude' || args === null || configIndex !== 0 || target === null
+        const reason = !commandValid || args === null || configIndex !== 0 || target === null
             ? 'the command or --config declaration is malformed'
             : 'the declared owner config target is missing, insecure, malformed, or incomplete';
         return createCheck('claude-channel', 'Claude Channel registration', 'warn', `The user-scoped memesh-channel registration is present but ${reason}. Live Claude Channel notification is not established.`, 'Remove and re-register the owner-controlled memesh-channel entry with `memesh agent setup claude`; keep its generated config file owner-private.');
@@ -977,7 +1033,13 @@ async function inspectUpdateStatus(packageVersion, getUpdateCheckImpl, installSu
             return createCheck('update-status', 'Update status', 'pass', `Running pre-release version (${packageVersion}), npm latest is ${update.latestVersion}`);
         }
     }
-    return createCheck('update-status', 'Update status', update.freshness === 'stale' ? 'warn' : 'pass', `Version ${packageVersion} is current${update.freshness === 'stale' ? ', but cached update data is stale.' : '.'}`, update.freshness === 'stale'
+    const checkedHoursAgo = update.lastSuccessfulCheckAt === null
+        ? null
+        : (Date.now() - Date.parse(update.lastSuccessfulCheckAt)) / 3600_000;
+    const checkedAgo = formatHoursAgo(checkedHoursAgo);
+    return createCheck('update-status', 'Update status', update.freshness === 'stale' ? 'warn' : 'pass', update.freshness === 'stale'
+        ? `As of the last check (${checkedAgo}), ${packageVersion} was the latest version — that check is more than 24h old, so a newer release may exist since. Doctor never makes a live registry call itself.`
+        : `As of the last check (${checkedAgo}), ${packageVersion} was the latest version.`, update.freshness === 'stale'
         ? 'Run `memesh status` while online to refresh cached update metadata.'
         : undefined, update.freshness === 'stale'
         ? { code: 'update-status.stale', params: { version: packageVersion } }
@@ -1099,8 +1161,7 @@ function inspectMessageCapability(packageRoot, enabled, probe) {
     return createCheck('message-capability', 'Message adapter imports', 'fail', `Installed message capability probe failed: ${result.message}.`, 'Reinstall or rebuild this package, then retry with MEMESH_DOCTOR_PROBE_MESSAGE_CAPABILITY=1.', { code: 'message-capability.probe-failed', params: { detail: result.message } });
 }
 async function defaultMessageRouterStatusProbe() {
-    const socketPath = process.env.MEMESH_ROUTER_SOCKET
-        ?? path.join(getMemeshDirFromDbPath(), 'agent-router.sock');
+    const socketPath = process.env.MEMESH_ROUTER_SOCKET ?? getAgentRouterSocketPath();
     let stat;
     try {
         stat = fs.lstatSync(socketPath);
@@ -1147,54 +1208,6 @@ async function inspectMessageRouterStatus(enabled, probe) {
             return createCheck('message-router-status', 'Live message router / host registration', 'warn', `An owner-private router socket exists at ${result.socket_path}, but it did not accept a local connection. No host registration or native delivery is verified.`, 'Check the owner-configured `memesh-router` process, then run this opt-in probe again.', { code: 'message-router.socket-unreachable', params: { path: result.socket_path } });
     }
 }
-async function inspectEmbeddingProbe(capabilities, probeCapabilities, embedTextImpl) {
-    if (capabilities.embeddings === 'tfidf') {
-        return createInfo('embeddings_probe', 'Embeddings work', 'No neural embedder configured — recall runs on FTS5 keyword search alone. That is a supported mode, not a fault.');
-    }
-    if (!probeCapabilities) {
-        return createInfo('embeddings_probe', 'Embeddings work', `NOT VERIFIED. Config names "${capabilities.embeddings}", but generating a test embedding is a network call (billed on hosted providers) so it was not made — a revoked key or an unreachable host would look identical to a healthy setup here.`, 'Run: memesh doctor --probe   (generates one test embedding to confirm)');
-    }
-    let timer;
-    try {
-        const vector = await Promise.race([
-            embedTextImpl('memesh doctor embedding probe'),
-            new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`no response within ${EMBEDDING_PROBE_TIMEOUT_MS / 1000}s`)), EMBEDDING_PROBE_TIMEOUT_MS);
-            }),
-        ]);
-        if (!vector || vector.length === 0) {
-            return createCheck('embeddings_probe', 'Embeddings work', 'warn', `Config selects "${capabilities.embeddings}" but generating a test embedding returned nothing. Semantic recall is degraded to FTS5-only; keyword search still works.`, 'Run: memesh doctor --probe for detail, or check network access to the embedding provider.', { code: 'embeddings.empty', params: { provider: String(capabilities.embeddings) } });
-        }
-        return createCheck('embeddings_probe', 'Embeddings work', 'pass', `Generated a ${vector.length}-dim test embedding via "${capabilities.embeddings}".`);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return createCheck('embeddings_probe', 'Embeddings work', 'warn', `Config selects "${capabilities.embeddings}" but the embedder threw (${msg}). Semantic recall is degraded to FTS5-only.`, 'Check the embedding provider is reachable (e.g. run `ollama serve`), or remove embedder config to use keyword-only search.', { code: 'embeddings.threw', params: { provider: String(capabilities.embeddings), detail: msg } });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-async function inspectLlmProbe(capabilities, probeCapabilities, probeProviderImpl) {
-    const llm = capabilities.llm;
-    if (!llm) {
-        return createInfo('llm_probe', 'LLM reachable', 'No LLM configured — Core Mode. Write-side features (lessons, auto-tag, dream) are off by design.');
-    }
-    if (!probeCapabilities) {
-        return createInfo('llm_probe', 'LLM reachable', `NOT VERIFIED. Config names ${llm.provider} (${llm.model ?? 'default'}), but no live call was made — an expired key or an unreachable host would look identical to a healthy setup here.`, 'Run: memesh doctor --probe   (makes one small live call to confirm)');
-    }
-    try {
-        const result = await probeProviderImpl(llm.provider, llm.apiKey);
-        if (result.valid) {
-            return createCheck('llm_probe', 'LLM reachable', 'pass', `${llm.provider} answered a live probe.`);
-        }
-        return createCheck('llm_probe', 'LLM reachable', 'fail', `${llm.provider} is configured but did not answer: ${result.error ?? 'unknown error'}. Every LLM-backed feature is silently doing nothing.`, 'Check the API key / host, then re-run: memesh doctor --probe', { code: 'llm.unreachable', params: { provider: llm.provider, detail: result.error ?? 'unknown error' } });
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return createCheck('llm_probe', 'LLM reachable', 'fail', `${llm.provider} probe threw: ${msg}. Every LLM-backed feature is silently doing nothing.`, 'Check the API key / host, then re-run: memesh doctor --probe', { code: 'llm.threw', params: { provider: llm.provider, detail: msg } });
-    }
-}
 function summarizeOverallStatus(checks) {
     const assertions = checks.filter((check) => !check.informational);
     if (assertions.some((check) => check.status === 'fail'))
@@ -1204,7 +1217,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, installedPluginsPathImpl, marketplaceHeadShaImpl = defaultMarketplaceHeadSha, pluginCacheDiscoveryImpl, getInstallChannelSupportImpl = getInstallChannelSupport, existsSyncImpl = fs.existsSync, readFileSyncImpl = fs.readFileSync, statSyncImpl = fs.statSync, fetchImpl = fetch, agentMessageStoragePolicy, nativeBindingProbeImpl, resolveShellMemeshImpl = defaultResolveShellMemesh, probeMessageCapability = process.env.MEMESH_DOCTOR_PROBE_MESSAGE_CAPABILITY === '1', messageCapabilityProbeImpl = probeInstalledMessageCapability, probeMessageRouterStatus = process.env.MEMESH_DOCTOR_PROBE_MESSAGE_ROUTER === '1', messageRouterStatusProbeImpl = defaultMessageRouterStatusProbe, } = options;
+    const { packageRoot, packageVersion, probeHttp = false, httpBaseUrl = 'http://127.0.0.1:3737', platform = process.platform, envImpl = process.env, openDatabaseImpl = openDatabase, closeDatabaseImpl = closeDatabase, isDatabaseOpenImpl = isDatabaseOpen, getConfigPathImpl = getConfigPath, getUpdateCheckImpl = getUpdateCheck, getCurrentInstallChannelImpl = getCurrentInstallChannel, installedPluginsPathImpl, marketplaceHeadShaImpl = defaultMarketplaceHeadSha, pluginCacheDiscoveryImpl, getInstallChannelSupportImpl = getInstallChannelSupport, existsSyncImpl = fs.existsSync, readFileSyncImpl = fs.readFileSync, statSyncImpl = fs.statSync, fetchImpl = fetch, agentMessageStoragePolicy, nativeBindingProbeImpl, resolveShellMemeshImpl = defaultResolveShellMemesh, probeMessageCapability = process.env.MEMESH_DOCTOR_PROBE_MESSAGE_CAPABILITY === '1', messageCapabilityProbeImpl = probeInstalledMessageCapability, probeMessageRouterStatus = process.env.MEMESH_DOCTOR_PROBE_MESSAGE_ROUTER === '1', messageRouterStatusProbeImpl = defaultMessageRouterStatusProbe, } = options;
     const wasDbOpenBeforeUs = isDatabaseOpenImpl();
     const safeCloseDatabaseImpl = wasDbOpenBeforeUs
         ? () => undefined
@@ -1240,39 +1253,6 @@ export async function runDoctor(options) {
                     `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();
-        const vectorDb = db;
-        let missingVectors;
-        let vectorsPossible = true;
-        try {
-            vectorsPossible = hasVectorIndex(vectorDb);
-            missingVectors = vectorsPossible ? countMissingVectors(vectorDb) : 0;
-        }
-        catch {
-            missingVectors = null;
-        }
-        const payableDebt = pendingReindex && !(pendingReindex.reason === 'vectors-missing' && !vectorsPossible);
-        if (payableDebt || missingVectors === null || missingVectors > 0) {
-            const owed = pendingReindex && pendingReindex.reason !== 'vectors-missing'
-                ? 'Search index needs rebuilding (embedding configuration changed)'
-                : missingVectors === null
-                    ? 'The vector index could not be read, so how much of your memory semantic recall can see is unknown'
-                    : `${missingVectors} memor${missingVectors === 1 ? 'y has' : 'ies have'} no search vector, `
-                        + 'so semantic recall cannot find them (keyword search still works)';
-            dbChecks.push(createCheck('vector_index', 'Vector Index', 'warn', owed, `Run 'memesh reindex' to fix. This will restore full search functionality.`, { code: 'vector-index.stale', params: { missing: missingVectors ?? -1 } }));
-        }
-        const generation = readVectorGeneration();
-        if (generation.state !== 'none') {
-            const staged = generationRowIds().size;
-            const detail = generation.state === 'open'
-                ? `${staged} vectors staged at ${generation.info.dimension} dimensions `
-                    + `(provider ${generation.info.provider}, started ${generation.info.startedAt})`
-                : `${staged} vectors staged, but the marker cannot be read (${generation.detail})`;
-            dbChecks.push(createCheck('vector_generation', 'Half-built search index', 'warn', `An unfinished index rebuild is holding disk space: ${detail}.`, generation.state === 'open'
-                ? `Run 'memesh reindex' to finish it (the vectors already produced are reused), `
-                    + `or 'memesh reindex --discard-generation' to reclaim the space.`
-                : `Run 'memesh reindex --discard-generation' to clear it, then 'memesh reindex'.`, { code: 'vector-generation.open', params: { staged } }));
-        }
         try {
             const guardRows = db
                 .prepare(`SELECT id, name, metadata FROM entities
@@ -1406,8 +1386,8 @@ export async function runDoctor(options) {
         catch {
         }
     }
-    checks.push(inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl, detectCapabilitiesImpl().llm));
-    checks.push(inspectMcpConfig(packageRoot, existsSyncImpl, readFileSyncImpl));
+    checks.push(inspectConfigFile(existsSyncImpl, readFileSyncImpl, getConfigPathImpl));
+    checks.push(inspectMcpConfig(packageRoot, install, existsSyncImpl, readFileSyncImpl, envImpl));
     checks.push(...inspectHooksConfig(packageRoot, platform, existsSyncImpl, readFileSyncImpl, statSyncImpl));
     const pluginHost = detectPluginHost(packageRoot);
     let codexPluginCacheDetected = pluginHost === 'codex';
@@ -1450,24 +1430,10 @@ export async function runDoctor(options) {
     checks.push(inspectDashboardArtifact(packageRoot, existsSyncImpl));
     checks.push(inspectNodeRuntime(packageRoot, existsSyncImpl, readFileSyncImpl));
     checks.push(inspectNativeBinding(packageRoot, existsSyncImpl, nativeBindingProbeImpl));
-    checks.push(inspectShellCli(install, packageRoot, resolveShellMemeshImpl));
+    checks.push(inspectShellCli(install, packageRoot, packageVersion, resolveShellMemeshImpl, existsSyncImpl, readFileSyncImpl));
     checks.push(verifySkillsManifest(packageRoot, existsSyncImpl, readFileSyncImpl, installSupport));
     checks.push(inspectMessageCapability(packageRoot, probeMessageCapability, messageCapabilityProbeImpl));
     checks.push(await inspectMessageRouterStatus(probeMessageRouterStatus, messageRouterStatusProbeImpl));
-    const capabilities = detectCapabilitiesImpl();
-    checks.push(createInfo('capabilities', 'Capabilities (configured)', `Search level ${capabilities.searchLevel} (${capabilities.searchLevel === 1 ? 'Smart Mode' : 'Core'}); embeddings: ${capabilities.embeddings}; LLM: ${capabilities.llm ? `${capabilities.llm.provider} (${capabilities.llm.model ?? 'default'})` : 'not configured'}. Configured values only — see the probe rows below for what actually works.`));
-    if (!isTranscriptMiningEnabled()) {
-        checks.push(createInfo('transcript-mining', 'Scheduled transcript mining', 'Off (opt-in). memesh can mine this project\'s Claude Code session transcripts for decisions and lessons and STAGE them for your review. Turn it on with `memesh config set transcriptMining true`, then have a scheduler (cron/launchd) run `memesh dream run --from-transcripts --if-due` — it self-throttles and stages only, so nothing enters your graph without `dream accept`.'));
-    }
-    else {
-        const last = lastTranscriptMineAt(getProjectName(process.cwd()));
-        const when = last === null
-            ? 'not yet run for this project'
-            : `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 inspectEmbeddingProbe(capabilities, probeCapabilities, embedTextImpl));
-    checks.push(await inspectLlmProbe(capabilities, probeCapabilities, probeProviderImpl));
     checks.push(await inspectUpdateStatus(packageVersion, getUpdateCheckImpl, installSupport));
     try {
         const record = getInstallRecord();