@pcircle/memesh 4.5.1 → 4.6.1

package/dist/transports/cli/cli.js

@@ -1,16 +1,21 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { randomBytes } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { openDatabase, closeDatabase, getDatabase, reindexFts, allowVectorIndexRebuild } from '../../db.js';
+import { openDatabase, closeDatabase, getDatabase, reindexFts, readVectorGeneration, generationRowIds, discardVectorGeneration, } from '../../db.js';
 import { remember, recallWithConflicts, forget, exportMemories, importMemories, learn, reindex, setPinned } from '../../core/operations.js';
 import { readConfig, writeConfig, maskApiKey, detectCapabilities } from '../../core/config.js';
 import { MAX_LANGUAGE_LENGTH, languageValueError } from '../../core/output-language.js';
-import { getDbPath, redactSecrets, redactUserPaths } from '../../core/paths.js';
+import { getDbPath, getProjectName, homeDir, redactSecrets, redactUserPaths } from '../../core/paths.js';
 import { flushPendingEmbeddings, canRefillVectorIndex } from '../../core/embedder.js';
 import { NAMESPACES } from '../../core/types.js';
+import { assembleBriefing } from '../../core/briefing.js';
+import { inspectHosts, allWired } from '../../core/setup.js';
+import { installHooks } from '../../core/install-hooks.js';
+import { getTaskState, setTaskState } from '../../core/task-state-store.js';
+import { TASK_STATE_FIELDS, taskStateLines } from '../../core/task-state.js';
 async function withDatabase(fn) {
     openDatabase();
     try {
@@ -26,13 +31,34 @@ function requireOneOf(value, allowed, flag) {
     console.error(`Error: ${flag} "${value}" is not valid. Use one of: ${allowed.join(', ')}.`);
     process.exit(1);
 }
+function isOnPath(tool) {
+    const exts = process.platform === 'win32'
+        ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+        : [''];
+    for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            try {
+                fs.accessSync(path.join(dir, tool + ext), fs.constants.X_OK);
+                return true;
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+function wireUserHooks() {
+    const r = installHooks({ pluginRoot: packageRoot, pluginVersion: pkg.version, scope: 'user' });
+    return `hooks: added ${r.added}, skipped ${r.skipped} already-installed${r.backupPath ? ` (backup: ${r.backupPath})` : ''}`;
+}
 const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../package.json');
 const packageRoot = path.dirname(packageJsonPath);
 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
 const program = new Command();
 program
     .name('memesh')
-    .description('MeMesh — Local memory for Claude Code and MCP coding agents')
+    .description('MeMesh — Agentic memory for coding agents')
     .version(pkg.version)
     .allowExcessArguments(true)
     .showSuggestionAfterError(true);
@@ -42,6 +68,7 @@ program
     .description('Store knowledge as an entity (use flags for explicit form, or positional text for quick capture)')
     .option('--name <name>', 'Entity name')
     .option('--type <type>', 'Entity type')
+    .option('--title <title>', 'Short human-readable label shown as the headline (name stays the stable machine key)')
     .option('--obs <observations...>', 'Observations (space-separated)')
     .option('--tags <tags...>', 'Tags (space-separated)')
     .option('--namespace <namespace>', 'Namespace: personal, team, or global. On a NEW memory this places it (default personal); on one that already exists it MOVES it out of the scope it is in — omit the flag to leave it alone.')
@@ -60,6 +87,8 @@ program
         const suffix = randomBytes(3).toString('hex');
         opts.name = `quick-${date}-${slug || 'note'}-${suffix}`;
         opts.type = 'note';
+        if (!opts.title)
+            opts.title = String(text).slice(0, 200);
         if (!opts.obs || opts.obs.length === 0)
             opts.obs = [String(text)];
         else
@@ -85,6 +114,7 @@ program
         const result = remember({
             name: opts.name,
             type: opts.type,
+            title: opts.title,
             observations: opts.obs,
             tags: opts.tags,
             namespace: opts.namespace,
@@ -129,7 +159,7 @@ program
     .action(async (query, opts) => {
     requireOneOf(opts.namespace, NAMESPACES, '--namespace');
     await withDatabase(async () => {
-        const { entities, conflicts } = await recallWithConflicts({
+        const { entities, conflicts, retrieval } = await recallWithConflicts({
             query: query || undefined,
             tag: opts.tag,
             limit: parseInt(opts.limit),
@@ -138,12 +168,7 @@ program
             cross_project: opts.crossProject,
         });
         if (opts.json) {
-            if (conflicts.length > 0) {
-                console.log(JSON.stringify({ entities, conflicts }));
-            }
-            else {
-                console.log(JSON.stringify(entities));
-            }
+            console.log(JSON.stringify(conflicts.length > 0 ? { entities, retrieval, conflicts } : { entities, retrieval }));
         }
         else if (entities.length === 0) {
             console.log('No results found.');
@@ -173,7 +198,11 @@ program
                     console.log(`    ... +${e.observations.length - 3} more`);
                 }
             }
-            console.log(`\n${entities.length} result(s)`);
+            const truncatedNote = retrieval.truncated ? ' (limit reached — more may exist)' : '';
+            console.log(`\n${entities.length} result(s)${truncatedNote}`);
+            if (retrieval.degraded) {
+                console.log('Warning: semantic search unavailable right now — keyword-only results (degraded). Run `memesh doctor` to see why.');
+            }
             if (conflicts.length > 0) {
                 console.log('\nWarning: Conflicts detected:');
                 for (const c of conflicts) {
@@ -400,6 +429,242 @@ program
         }
     });
 });
+program
+    .command('briefing')
+    .description('The assembled work topology for a project — task state, decisions, lessons, knowledge, recent activity')
+    .option('--project <name>', 'Project name (default: the current directory’s project)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    await withDatabase(() => {
+        const result = assembleBriefing(opts.project);
+        if (opts.json) {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        if (!result.text) {
+            console.log(`No memories for "${result.project}" yet.\n` +
+                `Capture happens automatically as you work; or set the task state:  memesh task --goal "…"`);
+            return;
+        }
+        console.log(result.text);
+    });
+});
+const WHY_ABSTENTION_TEXT = {
+    git_unavailable: 'git is not installed or not on PATH — commit attribution unavailable.',
+    not_a_git_repo: 'Not inside a git repository — commit attribution unavailable.',
+    file_not_tracked: 'File is not tracked by git — commit attribution unavailable.',
+    history_unreadable: "git could not read this file's history (too much output, too slow, or the repository has no commits yet) — nothing is listed because the question went unanswered, not because no commit touched the file.",
+    no_commits_supplied: 'No commit hashes were supplied — only the file-tag half of this answer ran.',
+    line_out_of_range: 'That line does not exist in the tracked file.',
+    line_uncommitted: 'That line is not committed yet — nothing to attribute.',
+    no_commit_entity: 'memesh has no memory of this commit (it predates capture, or was made without hooks / on another machine).',
+    no_session_link: 'This commit was captured before commits recorded their session — the session link does not exist.',
+};
+program
+    .command('why')
+    .description('Explain a file: commits memesh remembers touching it, their sessions, and related memories')
+    .argument('<file>', 'File path (relative to the current directory or absolute)')
+    .option('--line <n>', 'Attribute one line via git blame instead of file history')
+    .option('--limit <n>', 'Max commits to inspect', '10')
+    .option('--json', 'Output as JSON')
+    .action(async (file, opts) => {
+    await withDatabase(async () => {
+        const { resolveFileCommits, explainCommits } = await import('../../core/why.js');
+        const cwd = process.cwd();
+        const limit = parseInt(opts.limit, 10);
+        const line = opts.line !== undefined ? parseInt(opts.line, 10) : undefined;
+        for (const [flag, value] of [['--limit', limit], ['--line', line]]) {
+            if (value !== undefined && (!Number.isInteger(value) || value < 1)) {
+                console.error(`Error: ${flag} needs a whole number of 1 or more.`);
+                process.exit(1);
+            }
+        }
+        const resolved = resolveFileCommits(cwd, file, { line, limit });
+        const result = explainCommits(getDatabase(), {
+            file,
+            commits: resolved.commits,
+            project: getProjectName(cwd),
+            limit,
+            abstentions: resolved.abstention ? [resolved.abstention] : [],
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`why ${result.file}  (project: ${result.project ?? 'all'})`);
+        for (const code of result.abstentions) {
+            console.log(`  ! ${WHY_ABSTENTION_TEXT[code] ?? code}`);
+        }
+        if (result.commits.length === 0 && result.abstentions.length === 0) {
+            console.log('  No commits touch this file.');
+        }
+        for (const c of result.commits) {
+            const head = [c.commit.hash.slice(0, 10), c.commit.date, c.commit.subject].filter(Boolean).join('  ');
+            console.log(`\n  ${head}`);
+            if (c.entity) {
+                console.log(`    memory: ${c.entity.name} [mem:${c.entity.id}]`);
+                for (const obs of c.entity.observations.slice(0, 3))
+                    console.log(`      - ${obs}`);
+            }
+            if (c.session) {
+                console.log(`    session: ${c.session.session_id}`);
+                for (const s of c.session.entities)
+                    console.log(`      - ${s.name} (${s.type})`);
+                if (c.session.truncated) {
+                    console.log(`      … first ${c.session.entities.length} of a larger session — more exist`);
+                }
+            }
+            for (const code of c.abstentions) {
+                console.log(`    ! ${WHY_ABSTENTION_TEXT[code] ?? code}`);
+            }
+        }
+        const fm = result.file_memories.entities;
+        if (fm.length > 0) {
+            console.log(`\n  Related by file tag (file:${result.basename} — associated, not commit-derived):`);
+            for (const e of fm)
+                console.log(`    - ${e.name} (${e.type})${e.title ? `: ${e.title}` : ''}`);
+        }
+    });
+});
+program
+    .command('setup')
+    .description('Detect Claude Code / Codex / Gemini on this machine, wire memesh into each, and verify')
+    .option('--check', 'Only report wiring status per host; change nothing (exit 1 if a present host is unwired)')
+    .option('--yes', 'Apply every wiring action without asking')
+    .action(async (opts) => {
+    const { spawnSync, execFileSync } = await import('child_process');
+    const runSeam = (cmd, args) => {
+        try {
+            let target = cmd;
+            let useShell = false;
+            if (process.platform === 'win32') {
+                const resolved = execFileSync('where', [cmd], { encoding: 'utf8' }).split(/\r?\n/)[0]?.trim();
+                if (resolved) {
+                    target = resolved;
+                    useShell = /\.(cmd|bat)$/i.test(resolved);
+                }
+            }
+            const r = spawnSync(target, args, { encoding: 'utf8', shell: useShell });
+            return { status: r.status, stderr: r.stderr ?? '' };
+        }
+        catch (err) {
+            return { status: null, stderr: err instanceof Error ? err.message : String(err) };
+        }
+    };
+    const seams = { home: () => homeDir(), isOnPath, run: runSeam };
+    const render = (statuses) => {
+        for (const st of statuses) {
+            if (!st.present) {
+                console.log(`   ${st.title}: not found (looked for ${st.presenceDetail}) — skipped`);
+                continue;
+            }
+            const mark = st.wired === true ? '✅' : st.wired === false ? '❌' : '❓';
+            console.log(`${mark} ${st.title}: ${st.wiredDetail}`);
+        }
+    };
+    let statuses = inspectHosts(seams);
+    if (opts.check) {
+        render(statuses);
+        process.exit(allWired(statuses) ? 0 : 1);
+    }
+    const pending = statuses.filter((st) => st.present && st.actions.length > 0);
+    if (pending.length === 0) {
+        render(statuses);
+        console.log(allWired(statuses)
+            ? '\nEverything present is wired. Nothing to do.'
+            : '\nNothing to wire automatically — see the lines above.');
+        process.exit(allWired(statuses) ? 0 : 1);
+    }
+    render(statuses);
+    console.log('\nPlanned actions:');
+    for (const st of pending)
+        for (const a of st.actions) {
+            console.log(`  • [${st.title}] ${a.label}${a.cmd ? `\n      ${a.cmd} ${(a.args ?? []).join(' ')}` : ''}`);
+        }
+    if (!opts.yes && !process.stdin.isTTY) {
+        console.error('\nNot a terminal and --yes not given — nothing was changed. Re-run with: memesh setup --yes');
+        process.exit(1);
+    }
+    const confirmAll = Boolean(opts.yes);
+    let rl = null;
+    if (!confirmAll) {
+        const { createInterface } = await import('node:readline/promises');
+        rl = createInterface({ input: process.stdin, output: process.stdout });
+    }
+    let failed = false;
+    for (const st of pending) {
+        for (const action of st.actions) {
+            if (!confirmAll && rl) {
+                const answer = (await rl.question(`\n[${st.title}] ${action.label} — proceed? [y/N] `)).trim().toLowerCase();
+                if (answer !== 'y' && answer !== 'yes') {
+                    console.log('  skipped');
+                    continue;
+                }
+            }
+            if (action.kind === 'install-hooks') {
+                console.log(`  ✅ ${wireUserHooks()}`);
+            }
+            else if (action.cmd) {
+                const r = runSeam(action.cmd, action.args ?? []);
+                if (r.status === 0)
+                    console.log(`  ✅ done (${action.cmd} ${(action.args ?? []).join(' ')})`);
+                else {
+                    console.error(`  ❌ ${action.cmd} exited ${r.status ?? 'without running'}${r.stderr ? `: ${r.stderr.trim()}` : ''}`);
+                    failed = true;
+                }
+            }
+        }
+    }
+    rl?.close();
+    console.log('\nAfter wiring:');
+    statuses = inspectHosts(seams);
+    render(statuses);
+    process.exit(failed || !allWired(statuses) ? 1 : 0);
+});
+program
+    .command('task')
+    .description('Show or update where the work stands on this project')
+    .option('--project <name>', 'Project name (default: the current directory’s project)')
+    .option('--goal <text>', 'What this work is FOR — the outcome being aimed at')
+    .option('--next <text>', 'The next concrete step')
+    .option('--blocked <text>', 'What is standing in the way (pass "" to clear it once resolved)')
+    .option('--done <text>', 'What was just finished')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    await withDatabase(() => {
+        const patch = {};
+        for (const field of TASK_STATE_FIELDS) {
+            if (opts[field] !== undefined)
+                patch[field] = opts[field];
+        }
+        if (Object.keys(patch).length === 0) {
+            const { project, state } = getTaskState(opts.project);
+            if (opts.json) {
+                console.log(JSON.stringify({ project, state }));
+                return;
+            }
+            const lines = taskStateLines(state, project);
+            if (lines.length === 0) {
+                console.log(`Nothing recorded for "${project}" yet.\n` +
+                    `Set it with:  memesh task --goal "…" --next "…"`);
+                return;
+            }
+            console.log(lines.join('\n'));
+            return;
+        }
+        const result = setTaskState({ project: opts.project, patch, sourceHost: 'cli' });
+        if (opts.json) {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        if (result.changed.length === 0) {
+            console.log(`No change — "${result.project}" already said exactly that.`);
+            return;
+        }
+        console.log(`Updated ${result.changed.join(', ')} for "${result.project}".`);
+        console.log(taskStateLines(result.state, result.project).join('\n'));
+    });
+});
 const configCmd = program.command('config').description('Manage configuration');
 configCmd
     .command('list')
@@ -426,12 +691,12 @@ const ALLOWED_KEYS = new Set([
     'llm.apiKey',
     'llm.model',
     'embedder.provider',
-    'embedder.model',
     'autoUpdate',
     'sessionLimit',
     'autoCapture',
     'llmFallbacks',
     'language',
+    'transcriptMining',
 ]);
 const KEY_VALIDATORS = {
     'llm.provider': (v) => ['anthropic', 'openai', 'ollama'].includes(v) ? null : `must be one of: anthropic, openai, ollama`,
@@ -498,7 +763,7 @@ function formatConfigValue(key, raw) {
         return JSON.stringify(raw);
     return String(raw);
 }
-export function buildConfigListing(config) {
+function buildConfigListing(config) {
     const rows = [];
     for (const key of Array.from(ALLOWED_KEYS).sort()) {
         const raw = getNested(config, key.split('.'));
@@ -555,6 +820,9 @@ configCmd
     if (canonical === 'autoCapture') {
         coerced = value === 'true' || value === '1';
     }
+    if (canonical === 'transcriptMining') {
+        coerced = value === 'true' || value === '1';
+    }
     const config = readConfig();
     setNested(config, canonical.split('.'), coerced);
     writeConfig(config);
@@ -680,6 +948,53 @@ program
         process.exit(1);
     }
 });
+program
+    .command('upgrade-plugin')
+    .description('Upgrade the Claude Code plugin install (finds and runs its bundled upgrade script)')
+    .action(async () => {
+    const { spawnSync } = await import('child_process');
+    const cacheRoot = path.join(homeDir(), '.claude', 'plugins', 'cache', 'pcircle-memesh', 'memesh');
+    let versions = [];
+    try {
+        versions = fs.readdirSync(cacheRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && /^\d+\.\d+\.\d+/.test(entry.name))
+            .map((entry) => entry.name);
+    }
+    catch { }
+    if (versions.length === 0) {
+        console.error('No Claude Code plugin install found (looked in ~/.claude/plugins/cache/pcircle-memesh).');
+        console.error('If you installed via npm, upgrade with: memesh update');
+        process.exit(1);
+    }
+    versions.sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+    const newest = versions[versions.length - 1];
+    const script = path.join(cacheRoot, newest, 'scripts', 'upgrade-plugin.sh');
+    if (!fs.existsSync(script)) {
+        console.error(`Plugin install found (v${newest}), but it has no scripts/upgrade-plugin.sh — plugin versions before 4.2.5 shipped without it.`);
+        console.error('Reinstall once from the Claude Code /plugin UI, or run the npm-global copy directly:');
+        console.error('  bash "$(npm prefix -g)/lib/node_modules/@pcircle/memesh/scripts/upgrade-plugin.sh"');
+        process.exit(1);
+    }
+    const installHints = {
+        node: 'node is required by the upgrade script. Install Node.js from https://nodejs.org',
+        npm: 'npm is required by the upgrade script. It ships with Node.js — reinstall from https://nodejs.org',
+        rsync: 'rsync is required by the upgrade script. macOS: already installed; Debian/Ubuntu: sudo apt install rsync',
+    };
+    const missing = Object.keys(installHints).filter((tool) => !isOnPath(tool));
+    if (missing.length > 0) {
+        for (const tool of missing)
+            console.error(installHints[tool]);
+        process.exit(1);
+    }
+    const run = spawnSync('bash', [script], { stdio: 'inherit' });
+    if (run.error) {
+        console.error(`Could not run the upgrade script: ${run.error.message}`);
+        console.error('bash is required to run it. If bash is available under another name, run it yourself:');
+        console.error(`  bash ${script}`);
+        process.exit(1);
+    }
+    process.exit(run.status ?? 1);
+});
 program
     .command('telemetry')
     .description('Show LLM call telemetry (per-flow scorecard for the last N days)')
@@ -765,7 +1080,8 @@ kgCmd
     .option('--session-cooccurrence', 'Rule 3: link high-signal orphans co-created in the same session')
     .option('--name-tokens', 'Rule 4: link orphans sharing ≥3 name content tokens (or Jaccard ≥ 0.50)')
     .option('--min-jaccard <n>', 'Jaccard threshold for name similarity (default 0.50)', parseFloat)
-    .option('--all-rules', 'Enable all heuristic rules (Rules 1–4)')
+    .option('--all-rules', 'Enable all heuristic rules (Rules 1–5)')
+    .option('--no-evidence-links', 'Disable Rule 5: evidence → work-item links via shared session id (on by default — these edges feed the graph\'s evidence badges)')
     .option('--reset-idempotency', 'Clear the persistent "already-attempted" orphan cache before running (use after schema changes or to reconsider every orphan)')
     .option('--json', 'Output as JSON')
     .action(async (opts) => {
@@ -780,6 +1096,7 @@ kgCmd
             dryRun: !!opts.dryRun,
             includeSessionCooccurrence: allRules || !!opts.sessionCooccurrence,
             includeNameTokenSimilarity: allRules || !!opts.nameTokens,
+            includeEvidenceLinks: opts.evidenceLinks !== false,
             minNameJaccard: opts.minJaccard,
             resetIdempotency: !!opts.resetIdempotency,
         };
@@ -819,6 +1136,7 @@ kgCmd
         console.log(`  project clustering: ${result.byRule.projectClustering}`);
         console.log(`  session co-occurrence: ${result.byRule.sessionCooccurrence}`);
         console.log(`  name token similarity: ${result.byRule.nameTokenSimilarity}`);
+        console.log(`  evidence links: ${result.byRule.evidenceLinks}`);
         if (result.candidatesProposed > result.edgesWritten) {
             console.log(`  (${result.candidatesProposed - result.edgesWritten} candidates were already-existing edges; INSERT OR IGNORE skipped them.)`);
         }
@@ -908,15 +1226,82 @@ program
     .option('--probe-http', 'Also probe the local HTTP server health endpoint')
     .option('--probe', 'Make one small live call to the configured LLM to confirm it actually answers')
     .option('--url <url>', 'Base URL for --probe-http', 'http://127.0.0.1:3737')
+    .option('--fix', 'Apply the whitelisted fixes doctor prescribes (asks per fix; --yes skips asking)')
+    .option('--yes', 'With --fix: apply without asking')
     .action(async (opts) => {
     const { formatDoctorReport, runDoctor } = await import('../../core/doctor.js');
-    const result = await runDoctor({
+    let result = await runDoctor({
         packageRoot,
         packageVersion: pkg.version,
         probeHttp: opts.probeHttp,
         probeCapabilities: opts.probe,
         httpBaseUrl: opts.url,
     });
+    if (opts.fix) {
+        const FIX_ACTIONS = {
+            'install-hooks': wireUserHooks,
+            'fts-rebuild': () => {
+                openDatabase();
+                try {
+                    return `keyword index rebuilt (${reindexFts().entities} entities)`;
+                }
+                finally {
+                    closeDatabase();
+                }
+            },
+            'chmod-db': () => {
+                fs.chmodSync(getDbPath(), 0o600);
+                return `permissions restored: chmod 600 ${getDbPath()}`;
+            },
+        };
+        const fixable = result.checks.filter((c) => c.fixId && (c.status === 'warn' || c.status === 'fail'));
+        if (fixable.length === 0) {
+            console.log('Nothing on the --fix whitelist to apply.');
+        }
+        else {
+            if (!opts.yes && !process.stdin.isTTY) {
+                console.error('Not a terminal and --yes not given — nothing was changed. Re-run with: memesh doctor --fix --yes');
+                process.exit(1);
+            }
+            let rl = null;
+            if (!opts.yes) {
+                const { createInterface } = await import('node:readline/promises');
+                rl = createInterface({ input: process.stdin, output: process.stdout });
+            }
+            for (const check of fixable) {
+                console.log(`\n${check.label}: ${check.summary}`);
+                if (rl) {
+                    const answer = (await rl.question(`Apply fix (${check.fixId})? [y/N] `)).trim().toLowerCase();
+                    if (answer !== 'y' && answer !== 'yes') {
+                        console.log('  skipped');
+                        continue;
+                    }
+                }
+                try {
+                    console.log(`  ✅ ${FIX_ACTIONS[check.fixId]()}`);
+                }
+                catch (err) {
+                    console.error(`  ❌ ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            rl?.close();
+            console.log('\nAfter fixes:');
+            const before = new Map(result.checks.map((c) => [c.id, c.status]));
+            const fixedIds = new Set(fixable.map((c) => c.id));
+            result = await runDoctor({
+                packageRoot,
+                packageVersion: pkg.version,
+                probeHttp: false,
+                probeCapabilities: false,
+                httpBaseUrl: opts.url,
+            });
+            for (const c of result.checks) {
+                const was = before.get(c.id);
+                if (fixedIds.has(c.id) && was && was !== c.status)
+                    console.log(`  ${c.label}: ${was} → ${c.status}`);
+            }
+        }
+    }
     if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
     }
@@ -1151,7 +1536,8 @@ dreamCmd
         console.log(`${proposals.length} ${opts.status} proposal(s):`);
         console.log('');
         for (const p of proposals) {
-            const srcLabel = p.source_kind === 'transcript' ? ' (transcript)' : '';
+            const srcLabel = p.kind === 'relation' ? ' (conflict)'
+                : p.source_kind === 'transcript' ? ' (transcript)' : '';
             console.log(`  #${p.id}  [${p.project}/${p.cluster_key}]${srcLabel}  ${p.source_count} source(s) → "${p.digest_name}"`);
             if (p.digest_observations_preview !== null) {
                 console.log(`         ${p.digest_observations_preview}`);
@@ -1162,6 +1548,49 @@ dreamCmd
         console.log(`Inspect: memesh dream show <id>   |   Apply: memesh dream accept <id>   |   Reject: memesh dream reject <id>`);
     });
 });
+dreamCmd
+    .command('conflicts')
+    .description('Judge semantically-close memory pairs for contradiction / supersession / duplication (LLM) and stage relation proposals for review')
+    .option('--max-pairs <n>', 'Judge at most N of the tightest candidate pairs this run (default 20)', (v) => parseInt(v, 10))
+    .option('--dry-run', 'Show how many candidates are queued without calling an LLM or writing anything')
+    .action(async (opts) => {
+    await withDatabase(async () => {
+        const cfg = readConfig();
+        const llm = detectCapabilities().llm;
+        if (!llm) {
+            console.error('No LLM configured. Run `memesh config set llm.provider <anthropic|openai|ollama>` first (or set ANTHROPIC_API_KEY / OPENAI_API_KEY).');
+            console.error('LLM is required for `memesh dream conflicts` because "do these two entries disagree" is a semantic judgement, not a rule.');
+            process.exit(1);
+        }
+        const { judgeConflicts, CONFLICT_JUDGE_MAX_PAIRS } = await import('../../core/conflict-judge.js');
+        const { getDatabase } = await import('../../db.js');
+        const result = await judgeConflicts(getDatabase(), llm, {
+            maxPairs: typeof opts.maxPairs === 'number' && !Number.isNaN(opts.maxPairs) ? opts.maxPairs : CONFLICT_JUDGE_MAX_PAIRS,
+            dryRun: !!opts.dryRun,
+            fallbacks: cfg.llmFallbacks,
+        });
+        console.log(`${opts.dryRun ? '[dry-run] ' : ''}Conflict pass complete in ${result.durationMs}ms`);
+        console.log(`  candidate pairs available: ${result.candidatesAvailable}`);
+        if (opts.dryRun) {
+            console.log('  (dry run — no LLM called, nothing judged or written)');
+            return;
+        }
+        console.log(`  LLM calls:      ${result.llmCalls}`);
+        console.log(`  judged:         ${result.judged} (${result.unrelated} unrelated, remembered so they are never re-bought)`);
+        console.log(`  staged:         ${result.staged} relation proposal(s)`);
+        if (result.llmFailures > 0) {
+            console.log(`  failed:         ${result.llmFailures} (unparseable or errored LLM responses; those pairs stay at the head of the candidate list and are retried next run)`);
+        }
+        if (result.aborted) {
+            console.error(`  ABORTED after the work above: ${result.aborted}`);
+            process.exit(1);
+        }
+        if (result.staged > 0) {
+            console.log('');
+            console.log('Review: memesh dream list   |   Apply: memesh dream accept <id>   |   Reject: memesh dream reject <id>');
+        }
+    });
+});
 dreamCmd
     .command('show <id>')
     .description('Show a proposal in full — name, type, ALL observations, tags, source — so you can review the whole thing before accepting')
@@ -1183,6 +1612,31 @@ dreamCmd
         console.log(`Proposal #${detail.id}  [${detail.project}/${detail.cluster_key}]  source: ${detail.source_kind}  status: ${detail.status}`);
         console.log(`created: ${detail.created_at}`);
         console.log('');
+        if (detail.kind === 'relation') {
+            const rel = detail.relation;
+            if (!rel) {
+                console.error('relation payload is corrupt — reject this proposal');
+                process.exit(1);
+            }
+            const [fromE, toE] = rel.relation_type === 'supersedes' && rel.direction === 'b_supersedes_a' ? [rel.b, rel.a] : [rel.a, rel.b];
+            console.log(`verdict: ${rel.verdict}  (severity: ${rel.severity ?? 'unknown'})`);
+            console.log(`accepting creates: ${fromE?.name} —${rel.relation_type}→ ${toE?.name}`);
+            if (rel.relation_type === 'supersedes') {
+                console.log(`  survivor: ${fromE?.name}  (the arrow points from the surviving claim to the obsolete one)`);
+            }
+            console.log(`rationale: ${rel.rationale ?? '(none given)'}`);
+            if (rel.recommended_action)
+                console.log(`recommended action: ${rel.recommended_action}`);
+            if (rel.excerpts?.a || rel.excerpts?.b) {
+                console.log(`excerpt A (${rel.a?.name}): ${rel.excerpts?.a ?? ''}`);
+                console.log(`excerpt B (${rel.b?.name}): ${rel.excerpts?.b ?? ''}`);
+            }
+            if (typeof rel.cosine_distance === 'number')
+                console.log(`cosine distance: ${rel.cosine_distance.toFixed(3)}`);
+            console.log('');
+            console.log(`Accept: memesh dream accept ${detail.id}   |   Reject: memesh dream reject ${detail.id}`);
+            return;
+        }
         console.log(`name: ${detail.digest.name}`);
         console.log(`type: ${detail.digest.type}`);
         console.log(`observations (${detail.digest.observations.length}):`);
@@ -1350,7 +1804,7 @@ program
         }
     }
     body = redactUserPaths(redactSecrets(body));
-    const url = `https://github.com/PCIRCLE-AI/memesh-llm-memory/issues/new?title=${encodeURIComponent(`[${typeLabel}] `)}&body=${encodeURIComponent(body)}&labels=${encodeURIComponent(labels)}`;
+    const url = `https://github.com/PCIRCLE-AI/memesh/issues/new?title=${encodeURIComponent(`[${typeLabel}] `)}&body=${encodeURIComponent(body)}&labels=${encodeURIComponent(labels)}`;
     if (opts.open === false) {
         console.log(url);
         return;
@@ -1383,17 +1837,60 @@ program
     .description('Regenerate vector embeddings for all entities (--fts rebuilds the keyword index instead)')
     .option('--namespace <namespace>', 'Reindex only entities in this namespace')
     .option('--fts', 'Rebuild the full-text keyword index instead of the vector index')
-    .option('--vectors', 'Also rebuild the vector index at the configured dimension. DESTRUCTIVE: drops every ' +
-    'stored embedding first. Needed only when switching embedding providers.')
+    .option('--discard-generation', 'Throw away a half-built vector index left by an interrupted rebuild, without rebuilding')
     .option('--json', 'Output as JSON')
+    .addOption(new Option('--vectors').hideHelp())
     .action(async (opts) => {
+    if (opts.vectors) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                refused: true,
+                reason: 'the --vectors flag is retired',
+                fix: 'run plain memesh reindex; to change provider first: memesh config set embedder.provider ollama|openai',
+                indexTouched: false,
+            }));
+            process.exit(1);
+        }
+        console.error('`memesh reindex --vectors` has been retired.');
+        console.error('');
+        console.error('It existed to consent to dropping every stored embedding before a refill.');
+        console.error('A rebuild now happens beside the live index and replaces it only when');
+        console.error('complete, so there is nothing left to consent to.');
+        console.error('');
+        console.error('Run plain `memesh reindex`. To change embedding provider first:');
+        console.error('  memesh config set embedder.provider ollama   (or openai)');
+        process.exit(1);
+    }
     requireOneOf(opts.namespace, NAMESPACES, '--namespace');
+    if (opts.discardGeneration) {
+        await withDatabase(async () => {
+            const read = readVectorGeneration();
+            const staged = generationRowIds().size;
+            if (read.state === 'none' && staged === 0) {
+                if (opts.json)
+                    console.log(JSON.stringify({ discarded: false, staged: 0 }));
+                else
+                    console.log('Nothing to discard: there is no half-built vector index.');
+                return;
+            }
+            const describe = read.state === 'open'
+                ? `${read.info.dimension}-dim, provider ${read.info.provider}, started ${read.info.startedAt}`
+                : read.state === 'unreadable'
+                    ? `marker unreadable (${read.detail})`
+                    : 'no marker';
+            discardVectorGeneration();
+            if (opts.json) {
+                console.log(JSON.stringify({ discarded: true, staged, generation: read, liveIndexTouched: false }));
+            }
+            else {
+                console.log(`Discarded a half-built vector index: ${staged} staged vectors (${describe}).\n` +
+                    '   Your live index was not touched. Run `memesh reindex` to build a new one.');
+            }
+        });
+        return;
+    }
     try {
         if (opts.fts) {
-            if (opts.vectors) {
-                console.error('❌ --fts and --vectors rebuild different indexes. Run them separately.');
-                process.exit(1);
-            }
             await withDatabase(async () => {
                 const { entities } = reindexFts();
                 if (opts.json) {
@@ -1405,68 +1902,84 @@ program
             });
             return;
         }
-        if (opts.vectors) {
-            if (opts.namespace) {
-                console.error('❌ --vectors rebuilds the whole vector index, which is shared by every\n' +
-                    '   namespace, so it cannot be limited to one. Combining it with\n' +
-                    '   --namespace would delete the other namespaces\' embeddings and never\n' +
-                    '   regenerate them. Run `memesh reindex --vectors` on its own, or drop\n' +
-                    '   --vectors to reindex just this namespace at the current dimension.');
-                process.exit(1);
+        if (!opts.namespace && !(await canRefillVectorIndex())) {
+            const embedder = detectCapabilities().embeddings;
+            const written = readConfig().embedder?.provider;
+            const known = embedder === 'openai' || embedder === 'ollama';
+            const invalid = written !== undefined && !known;
+            const unconfigured = written === undefined && !known;
+            const reason = invalid
+                ? `embedder.provider is set to '${written}', which is not a provider MeMesh knows`
+                : unconfigured
+                    ? 'no embedding provider is configured, so there is nothing to build vectors with'
+                    : 'could not produce a test embedding at the configured vector width';
+            const fix = invalid || unconfigured
+                ? (invalid ? 'Set it to one MeMesh knows: ' : 'Pick one first: ') +
+                    '`memesh config set embedder.provider ollama` (local, needs `ollama serve`) ' +
+                    'or `memesh config set embedder.provider openai` (needs OPENAI_API_KEY). Until then, recall ' +
+                    'runs on keyword search, which needs no rebuild.'
+                : 'Check that Ollama is running (or that your OpenAI API key is valid), then run this again. ' +
+                    '`memesh doctor` reports which provider is configured.';
+            if (opts.json) {
+                console.log(JSON.stringify({ refused: true, reason, fix, indexTouched: false }));
             }
-            if (!(await allowVectorIndexRebuild(getDbPath(), canRefillVectorIndex))) {
-                console.error('❌ Could not produce a test embedding at this database\'s vector width, so\n' +
-                    '   the index was left untouched. Rebuilding it deletes every stored\n' +
-                    '   embedding, and nothing here could regenerate them.\n' +
-                    '   Check that Ollama is running (or that your OpenAI API key is valid) —\n' +
-                    '   then run this again. `memesh doctor` reports which provider is configured.');
-                process.exit(1);
+            else {
+                console.error(`❌ Nothing was rebuilt: ${reason}.\n` +
+                    '   Your existing index is untouched and still answering queries.\n' +
+                    `   ${fix}`);
             }
+            process.exit(1);
         }
         await withDatabase(async () => {
             const result = await reindex({ namespace: opts.namespace });
-            const incomplete = result.missingVectors > 0 || result.failed > 0;
+            const incomplete = result.missingVectors > 0
+                || result.failed > 0
+                || result.generationSwapped === false
+                || result.abortedAfter !== null;
             if (opts.json) {
                 console.log(JSON.stringify(result));
             }
-            else if (incomplete) {
-                console.log(`⚠️  Reindex incomplete:`);
+            else {
+                console.log(incomplete ? `⚠️  Reindex incomplete:` : `✅ Reindex complete:`);
                 console.log(`   Processed: ${result.processed}`);
                 console.log(`   Embedded:  ${result.embedded}`);
                 console.log(`   Skipped:   ${result.skipped}`);
-                if (result.missingVectors > 0) {
-                    console.log(`   Still without a vector: ${result.missingVectors}`);
-                }
-                if (result.failed > 0 && result.missingVectors === 0) {
-                    console.log(`   Could not be regenerated: ${result.failed} ` +
-                        `(these still hold their previous embedding)`);
+                if (incomplete) {
+                    if (result.abortedAfter !== null) {
+                        console.log(`   Stopped early after ${result.abortedAfter} entities: the provider failed ` +
+                            `repeatedly. Everything embedded so far is kept — run this again to continue.`);
+                    }
+                    if (result.generationSwapped === false) {
+                        console.log(`   The new index was NOT switched in, so your existing index is untouched ` +
+                            `and still answering queries.`);
+                    }
+                    if (result.missingVectors > 0) {
+                        console.log(`   Still without a vector: ${result.missingVectors}`);
+                    }
+                    if (result.failed > 0 && result.missingVectors === 0) {
+                        console.log(`   Could not be regenerated: ${result.failed} ` +
+                            `(these still hold their previous embedding)`);
+                    }
+                    for (const [outcome, count] of Object.entries(result.outcomes)) {
+                        if (outcome !== 'stored' && count > 0)
+                            console.log(`     ${outcome}: ${count}`);
+                    }
                 }
-                for (const [outcome, count] of Object.entries(result.outcomes)) {
-                    if (outcome !== 'stored' && count > 0)
-                        console.log(`     ${outcome}: ${count}`);
+                else if (!result.pendingReindexCleared) {
+                    console.log(`   Note: ${result.missingVectorsDatabaseWide} memories in other namespaces still ` +
+                        `have no vector, so the reindex-needed flag stays set.`);
                 }
             }
-            else if (!result.pendingReindexCleared) {
-                console.log(`✅ Reindex complete:`);
-                console.log(`   Processed: ${result.processed}`);
-                console.log(`   Embedded:  ${result.embedded}`);
-                console.log(`   Skipped:   ${result.skipped}`);
-                console.log(`   Note: ${result.missingVectorsDatabaseWide} memories in other namespaces still ` +
-                    `have no vector, so the reindex-needed flag stays set.`);
-            }
-            else {
-                console.log(`✅ Reindex complete:`);
-                console.log(`   Processed: ${result.processed}`);
-                console.log(`   Embedded:  ${result.embedded}`);
-                console.log(`   Skipped:   ${result.skipped}`);
-            }
             if (incomplete)
                 process.exitCode = 1;
         });
     }
     catch (err) {
         if (err instanceof Error) {
-            console.error(`❌ Reindex failed: ${err.message}`);
+            if (opts.json)
+                console.log(JSON.stringify({ refused: true, reason: err.message, indexTouched: false }));
+            else
+                console.error(`❌ Reindex failed: ${err.message}`);
             process.exit(1);
         }
         throw err;