aiden-runtime 4.8.1 → 4.9.1

package/dist/cli/v4/commands/memory.js

@@ -0,0 +1,707 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/memory.ts — v4.9.0 Slice 9.
+ *
+ * User-facing CLI for the existing `MemoryManager` + `MemoryGuard`. Does
+ * NOT introduce a new memory engine; just exposes what's already there
+ * with substrate-aware spans, atomic backups, and a `--json` surface.
+ *
+ *   aiden memory                                 alias for `list`
+ *   aiden memory list                            both files + char counts
+ *   aiden memory show <memory|user>              cat with line numbers
+ *   aiden memory add <memory|user> "<text>"      append entry
+ *   aiden memory remove <memory|user> --match "<substr>"  remove first match
+ *   aiden memory backup                          snapshot to memory-backups/<ts>/
+ *   aiden memory restore <timestamp>             restore from snapshot
+ *   aiden memory edit <memory|user>              print path (user opens in editor)
+ *   aiden memory diff                            current vs most-recent backup
+ *
+ * Flags: `--json` (machine-parseable) ; `--yes` (skip confirms).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMemorySubcommand = runMemorySubcommand;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const paths_1 = require("../../../core/v4/paths");
+const memoryManager_1 = require("../../../core/v4/memoryManager");
+const memoryGuard_1 = require("../../../moat/memoryGuard");
+// v4.9.0 Slice 11 — namespace registry + project root detection.
+const namespaceRegistry_1 = require("../../../core/v4/memory/namespaceRegistry");
+const projectRoot_1 = require("../../../core/v4/memory/projectRoot");
+const identity_1 = require("../../../core/v4/identity");
+const spanHelpers_1 = require("../../../core/v4/daemon/spans/spanHelpers");
+const bootstrap_1 = require("../../../core/v4/daemon/bootstrap");
+const noopOut = (s) => { process.stdout.write(s); };
+const noopErr = (s) => { process.stderr.write(s); };
+/**
+ * v4.9.0 Slice 11 — validate against the dynamic namespace registry
+ * rather than the hard-coded `'memory' | 'user'` pair. Return type
+ * widened to `string` so the caller can pass any registered name
+ * through MemoryManager / MemoryGuard (whose method signatures were
+ * widened in the same slice).
+ */
+function parseFile(raw) {
+    if (!raw)
+        return null;
+    return (0, namespaceRegistry_1.hasNamespace)(raw) ? raw : null;
+}
+function limitFor(f) {
+    if ((0, namespaceRegistry_1.hasNamespace)(f))
+        return (0, namespaceRegistry_1.getNamespace)(f).charLimit;
+    // Defensive fallback — should never hit in practice.
+    return f === 'user' ? memoryManager_1.USER_CHAR_LIMIT : memoryManager_1.MEMORY_CHAR_LIMIT;
+}
+/** Build a minimal ExecutionContext for a one-shot CLI invocation. */
+function buildCliCtx(opName) {
+    return {
+        daemonId: (0, bootstrap_1.getCurrentDaemonId)() ?? 'dmn_cli_oneshot00000000000000000000',
+        incarnationId: (0, bootstrap_1.getCurrentIncarnationId)() ?? 'inc_cli_oneshot00000000000000000000',
+        runId: (0, identity_1.newRunId)(),
+        traceId: (0, identity_1.newTraceId)(),
+        spanId: (0, identity_1.newSpanId)(),
+        source: 'cli',
+        attempt: 1,
+        baggage: { op: opName },
+    };
+}
+/** Wrap a memory mutation in a span; return the span_id (`mem_...` synonym).
+ *  v4.9.0 Slice 11 — `file` widened to `string` to accept any namespace. */
+async function withMemorySpan(ctx, opName, file, fn) {
+    const memoryId = (0, identity_1.newMemoryId)();
+    const db = (0, bootstrap_1.getCurrentDaemonDb)();
+    if (!db) {
+        // Daemon not booted (common for one-shot CLI). Skip the span and
+        // still return the mem_ id so the response shape is stable.
+        const value = await fn(memoryId);
+        return { memoryId, value };
+    }
+    const value = await (0, identity_1.runWithContext)(ctx, () => (0, spanHelpers_1.withSpan)(db, { kind: 'memory', name: `memory_${opName}`, attrs: { file, memory_id: memoryId } }, async () => fn(memoryId)));
+    return { memoryId, value };
+}
+/** Entry — `aiden memory <action> [args...]`. Returns desired process exit. */
+async function runMemorySubcommand(action, args, opts = {}) {
+    const out = opts.writeOut ?? noopOut;
+    const err = opts.writeErr ?? noopErr;
+    const json = args.includes('--json');
+    const yes = args.includes('--yes');
+    // Strip flags from positional args.
+    const positional = args.filter((a) => !a.startsWith('--'));
+    const paths = (0, paths_1.resolveAidenPaths)(opts.rootDir ? { rootOverride: opts.rootDir } : {});
+    // v4.9.0 Slice 11 — detect project root from cwd so the `project`
+    // namespace can resolve its file path. `null` is fine — the
+    // namespace's resolver throws on access, the CLI catches + surfaces
+    // a helpful message instead of routing the error to the user.
+    const projectRoot = (0, projectRoot_1.findProjectRoot)(process.cwd());
+    const mgr = new memoryManager_1.MemoryManager({ paths, projectRoot });
+    const guard = new memoryGuard_1.MemoryGuard(mgr);
+    const effective = action || 'list';
+    switch (effective) {
+        case 'list': return cmdList(mgr, paths, out, json);
+        case 'show': return cmdShow(positional[0], paths, out, err, json);
+        case 'add': return cmdAdd(positional[0], positional[1], guard, mgr, paths, out, err, json);
+        case 'remove': return cmdRemove(positional[0], args, guard, out, err, json);
+        case 'edit': return cmdEdit(positional[0], paths, out, err);
+        case 'backup': return cmdBackup(paths, out, err, json);
+        case 'restore': return cmdRestore(positional[0], paths, out, err, json, yes);
+        case 'diff': return cmdDiff(paths, out, err);
+        // v4.9.0 Slice 10 — post-turn reviewer surface.
+        case 'namespaces': return cmdNamespaces(paths, projectRoot, out, json);
+        case 'pending': return cmdPending(paths, out, json);
+        case 'approve': return cmdApprove(positional[0], args, paths, guard, mgr, out, err, json);
+        case 'reject': return cmdReject(positional[0], args, paths, out, err, json);
+        case 'review': return cmdReview(args, paths, opts, out, err, json);
+        case '--help':
+        case 'help': return cmdHelp(out);
+        default: {
+            err(`Unknown memory action: ${effective}\n`);
+            const { closestAction } = await Promise.resolve().then(() => __importStar(require('../util/closestAction')));
+            const m = closestAction(effective, ['list', 'show', 'add', 'remove', 'edit', 'backup', 'restore', 'diff', 'namespaces', 'pending', 'approve', 'reject', 'review']);
+            if (m)
+                err(`Did you mean: ${m}?\n\n`);
+            cmdHelp(err);
+            return 2;
+        }
+    }
+}
+function cmdHelp(write) {
+    write('Usage: aiden memory <action> [args...] [--json] [--yes]\n\n' +
+        'Manage Aiden\'s MEMORY.md (~2200 chars) and USER.md (~1375 chars).\n\n' +
+        'Actions:\n' +
+        '  list                                 Show both files with char counts (default).\n' +
+        '  show <memory|user>                   Cat the file with line numbers.\n' +
+        '  add <memory|user> "<text>"           Append an entry (MemoryGuard verified).\n' +
+        '  remove <memory|user> --match "<s>"   Remove the unique entry containing <s>.\n' +
+        '  edit <memory|user>                   Print path so you can open in $EDITOR.\n' +
+        '  backup                               Snapshot both files to memory-backups/<ts>/.\n' +
+        '  restore <timestamp>                  Restore both files from a snapshot.\n' +
+        '  diff                                 Diff current state against latest backup.\n' +
+        '  namespaces                           List registered memory namespaces.\n' +
+        '  pending                              List candidates from `## Pending review` blocks.\n' +
+        '  approve <mem_id> | --all             Promote a pending candidate to a live entry.\n' +
+        '  reject <mem_id> | --all              Discard a pending candidate (logged).\n' +
+        '  review --now | --status              Run / inspect the post-turn memory reviewer.\n');
+    return 0;
+}
+async function cmdList(mgr, paths, out, json) {
+    // v4.9.0 Slice 11 — iterate every registered namespace via the
+    // snapshot's `files` map. Namespaces requiring a project root (e.g.
+    // `project`) that aren't reachable from cwd are silently absent —
+    // matches `loadSnapshot` behaviour.
+    const snap = await mgr.loadSnapshot();
+    const files = snap.files ?? {};
+    if (json) {
+        const payload = {};
+        for (const ns of (0, namespaceRegistry_1.listNamespaces)()) {
+            const f = files[ns.name];
+            if (!f)
+                continue;
+            payload[ns.name] = { path: f.path, chars: f.charCount, limit: f.charLimit, entries: splitEntries(f.content) };
+        }
+        out(JSON.stringify(payload, null, 2) + '\n');
+        return 0;
+    }
+    // Human format: one summary line per available namespace. Slice 9
+    // formatted as "memory: ...", "user:   ..." with the value column
+    // at offset 8. Match that, with min 1 space for longer names.
+    for (const ns of (0, namespaceRegistry_1.listNamespaces)()) {
+        const f = files[ns.name];
+        if (!f)
+            continue;
+        const pad = ' '.repeat(Math.max(1, 8 - (ns.name.length + 1)));
+        out(`${ns.name}:${pad}${f.charCount} / ${f.charLimit} chars  (${f.path})\n`);
+    }
+    for (const ns of (0, namespaceRegistry_1.listNamespaces)()) {
+        const f = files[ns.name];
+        if (!f)
+            continue;
+        const entries = splitEntries(f.content);
+        if (entries.length > 0) {
+            out(`\n--- ${ns.name} ---\n`);
+            entries.forEach((e, i) => out(`  ${i + 1}. ${e}\n`));
+        }
+    }
+    return 0;
+}
+async function cmdNamespaces(paths, projectRoot, out, json) {
+    const rows = (0, namespaceRegistry_1.listNamespaces)().map((ns) => {
+        let resolvedPath = null;
+        let available = true;
+        let reason;
+        try {
+            resolvedPath = ns.resolve(paths, projectRoot);
+        }
+        catch (e) {
+            available = false;
+            reason = e instanceof Error ? e.message : String(e);
+        }
+        return {
+            name: ns.name, label: ns.label, description: ns.description,
+            charLimit: ns.charLimit, requiresProject: !!ns.requiresProject,
+            injectIntoPrompt: ns.injectIntoPrompt, available, path: resolvedPath, reason,
+        };
+    });
+    if (json) {
+        out(JSON.stringify({ projectRoot, namespaces: rows }, null, 2) + '\n');
+        return 0;
+    }
+    out(`project root: ${projectRoot ?? '(none detected)'}\n\n`);
+    for (const r of rows) {
+        const status = r.available ? `ok   path=${r.path}` : `requires project root — ${r.reason}`;
+        out(`  ${r.name.padEnd(8)} (${r.charLimit} chars)  ${status}\n    ${r.description}\n`);
+    }
+    return 0;
+}
+async function cmdShow(fileRaw, paths, out, err, json) {
+    const file = parseFile(fileRaw);
+    if (!file) {
+        err('show: pass `memory` or `user`\n');
+        return 2;
+    }
+    // v4.9.0 Slice 11 — resolve via registry (supports project namespace).
+    let target;
+    try {
+        target = (0, namespaceRegistry_1.getNamespace)(file).resolve(paths, (0, projectRoot_1.findProjectRoot)(process.cwd()));
+    }
+    catch (e) {
+        err(`${file}: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    let text = '';
+    try {
+        text = await node_fs_1.promises.readFile(target, 'utf8');
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    if (json) {
+        out(JSON.stringify({ file, path: target, content: text }, null, 2) + '\n');
+        return 0;
+    }
+    out(`# ${target}\n`);
+    text.split('\n').forEach((line, i) => out(`${String(i + 1).padStart(4, ' ')} | ${line}\n`));
+    return 0;
+}
+async function cmdAdd(fileRaw, content, guard, mgr, paths, out, err, json) {
+    const file = parseFile(fileRaw);
+    if (!file) {
+        err('add: pass `memory` or `user`\n');
+        return 2;
+    }
+    if (!content) {
+        err('add: missing entry text\n');
+        return 2;
+    }
+    const ctx = buildCliCtx('memory_add');
+    // Ensure parent dir exists (first-run convenience).
+    // v4.9.0 Slice 11 — ensure parent dir exists via registry-resolved path.
+    let nsPath;
+    try {
+        nsPath = (0, namespaceRegistry_1.getNamespace)(file).resolve(paths, (0, projectRoot_1.findProjectRoot)(process.cwd()));
+    }
+    catch (e) {
+        err(`${file}: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(nsPath), { recursive: true });
+    const { memoryId, value: result } = await withMemorySpan(ctx, 'add', file, async () => guard.guardedAdd(file, content));
+    if (!result.ok || !result.verified) {
+        if (json) {
+            out(JSON.stringify({ ok: false, reason: result.reason, mem_id: memoryId }) + '\n');
+        }
+        else {
+            err(`add failed: ${result.reason ?? 'unknown'}\n`);
+        }
+        return 1;
+    }
+    const snap = await mgr.loadSnapshot();
+    // v4.9.0 Slice 11 — read post-write length from the generalized
+    // files map (`memory`/`user` keys still populated for back-compat).
+    const len = (snap.files?.[file]?.content
+        ?? (file === 'user' ? snap.userMd : snap.memoryMd) ?? '').length;
+    if (json) {
+        out(JSON.stringify({ ok: true, file, mem_id: memoryId, chars: len, limit: limitFor(file) }) + '\n');
+    }
+    else {
+        out(`added to ${file} (now ${len} / ${limitFor(file)} chars)  mem_id=${memoryId}\n`);
+    }
+    return 0;
+}
+async function cmdRemove(fileRaw, args, guard, out, err, json) {
+    const file = parseFile(fileRaw);
+    if (!file) {
+        err('remove: pass `memory` or `user`\n');
+        return 2;
+    }
+    const matchIdx = args.findIndex((a) => a === '--match');
+    if (matchIdx < 0 || matchIdx + 1 >= args.length) {
+        err('remove: pass --match "<substring>"\n');
+        return 2;
+    }
+    const target = args[matchIdx + 1];
+    const ctx = buildCliCtx('memory_remove');
+    const { memoryId, value: result } = await withMemorySpan(ctx, 'remove', file, async () => guard.guardedRemove(file, target));
+    if (!result.ok || !result.verified) {
+        if (json) {
+            out(JSON.stringify({ ok: false, reason: result.reason, mem_id: memoryId }) + '\n');
+        }
+        else {
+            err(`remove failed: ${result.reason ?? 'unknown'}\n`);
+        }
+        return 1;
+    }
+    if (json) {
+        out(JSON.stringify({ ok: true, file, mem_id: memoryId, match: target }) + '\n');
+    }
+    else {
+        out(`removed entry containing "${target}" from ${file}  mem_id=${memoryId}\n`);
+    }
+    return 0;
+}
+async function cmdEdit(fileRaw, paths, out, err) {
+    const file = parseFile(fileRaw);
+    if (!file) {
+        err('edit: pass `memory` or `user`\n');
+        return 2;
+    }
+    // v4.9.0 Slice 11 — resolve via registry (supports project namespace).
+    let target;
+    try {
+        target = (0, namespaceRegistry_1.getNamespace)(file).resolve(paths, (0, projectRoot_1.findProjectRoot)(process.cwd()));
+    }
+    catch (e) {
+        err(`${file}: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(target), { recursive: true });
+    try {
+        await node_fs_1.promises.access(target);
+    }
+    catch {
+        await node_fs_1.promises.writeFile(target, '', 'utf8');
+    }
+    out(`${target}\n`);
+    return 0;
+}
+function sha256(s) {
+    return (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+}
+function ts() {
+    const d = new Date();
+    const pad = (n, w = 2) => String(n).padStart(w, '0');
+    return `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}-${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}`;
+}
+async function cmdBackup(paths, out, _err, json) {
+    const ctx = buildCliCtx('memory_backup');
+    const stamp = ts();
+    const dir = node_path_1.default.join(paths.memoryBackupsDir, stamp);
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    // v4.9.0 Slice 11 — snapshot every reachable namespace.
+    const projectRoot = (0, projectRoot_1.findProjectRoot)(process.cwd());
+    const snapshots = [];
+    const { memoryId } = await withMemorySpan(ctx, 'backup', 'memory', async () => {
+        for (const ns of (0, namespaceRegistry_1.listNamespaces)()) {
+            let srcPath;
+            try {
+                srcPath = ns.resolve(paths, projectRoot);
+            }
+            catch {
+                continue; /* requiresProject + no root → skip */
+            }
+            const text = await node_fs_1.promises.readFile(srcPath, 'utf8').catch(() => '');
+            const outName = `${ns.name}.md`;
+            await node_fs_1.promises.writeFile(node_path_1.default.join(dir, outName), text, 'utf8');
+            snapshots.push({ name: outName, bytes: Buffer.byteLength(text, 'utf8'), sha256: sha256(text) });
+        }
+        return null;
+    });
+    const manifest = {
+        timestamp: stamp,
+        daemonId: (0, bootstrap_1.getCurrentDaemonId)(),
+        incarnationId: (0, bootstrap_1.getCurrentIncarnationId)(),
+        spanId: memoryId,
+        files: snapshots,
+    };
+    await node_fs_1.promises.writeFile(node_path_1.default.join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
+    if (json) {
+        out(JSON.stringify({ ok: true, dir, manifest }, null, 2) + '\n');
+    }
+    else {
+        out(`backup: ${dir}\n`);
+        for (const f of manifest.files)
+            out(`  ${f.name.padEnd(12)} ${f.bytes} B\n`);
+        out(`  mem_id=${memoryId}\n`);
+    }
+    return 0;
+}
+async function cmdRestore(stampRaw, paths, out, err, json, _yes) {
+    if (!stampRaw) {
+        err('restore: pass <timestamp> (use `aiden memory backup` first, then `ls memory-backups/`)\n');
+        return 2;
+    }
+    const dir = node_path_1.default.join(paths.memoryBackupsDir, stampRaw);
+    try {
+        await node_fs_1.promises.access(dir);
+    }
+    catch {
+        err(`restore: backup not found: ${dir}\n`);
+        return 1;
+    }
+    const ctx = buildCliCtx('memory_restore');
+    // v4.9.0 Slice 11 — restore every namespace file that exists in the
+    // backup. Namespace files missing from the backup are skipped (not
+    // an error — older snapshots may pre-date the namespace).
+    const projectRoot = (0, projectRoot_1.findProjectRoot)(process.cwd());
+    const restored = [];
+    const { memoryId } = await withMemorySpan(ctx, 'restore', 'memory', async () => {
+        for (const ns of (0, namespaceRegistry_1.listNamespaces)()) {
+            let destPath;
+            try {
+                destPath = ns.resolve(paths, projectRoot);
+            }
+            catch {
+                continue; /* requiresProject + no root → skip */
+            }
+            const src = node_path_1.default.join(dir, `${ns.name}.md`);
+            const text = await node_fs_1.promises.readFile(src, 'utf8').catch(() => null);
+            if (text === null)
+                continue;
+            await node_fs_1.promises.mkdir(node_path_1.default.dirname(destPath), { recursive: true });
+            await node_fs_1.promises.writeFile(destPath, text, 'utf8');
+            restored.push({ name: ns.name, chars: text.length });
+        }
+        return null;
+    });
+    if (json) {
+        out(JSON.stringify({ ok: true, restored_from: dir, restored, mem_id: memoryId }) + '\n');
+    }
+    else {
+        out(`restored from ${dir}\n`);
+        for (const r of restored)
+            out(`  ${r.name.padEnd(10)} ${r.chars} chars\n`);
+        out(`  mem_id=${memoryId}\n`);
+    }
+    return 0;
+}
+async function cmdDiff(paths, out, err) {
+    let entries;
+    try {
+        entries = await node_fs_1.promises.readdir(paths.memoryBackupsDir);
+    }
+    catch {
+        err('diff: no backups exist yet (run `aiden memory backup` first)\n');
+        return 1;
+    }
+    const sorted = entries.filter((e) => /^\d{8}-\d{6}$/.test(e)).sort();
+    if (sorted.length === 0) {
+        err('diff: no backups found\n');
+        return 1;
+    }
+    const latest = sorted[sorted.length - 1];
+    const dir = node_path_1.default.join(paths.memoryBackupsDir, latest);
+    const memBefore = await node_fs_1.promises.readFile(node_path_1.default.join(dir, 'memory.md'), 'utf8').catch(() => '');
+    const usrBefore = await node_fs_1.promises.readFile(node_path_1.default.join(dir, 'user.md'), 'utf8').catch(() => '');
+    const memNow = await node_fs_1.promises.readFile(paths.memoryMd, 'utf8').catch(() => '');
+    const usrNow = await node_fs_1.promises.readFile(paths.userMd, 'utf8').catch(() => '');
+    out(`diff vs backup ${latest}\n`);
+    out(diffSummary('memory.md', memBefore, memNow));
+    out(diffSummary('user.md', usrBefore, usrNow));
+    return 0;
+}
+function diffSummary(label, before, after) {
+    if (before === after)
+        return `  ${label}: unchanged\n`;
+    const b = splitEntries(before), a = splitEntries(after);
+    const bs = new Set(b), as = new Set(a);
+    const added = a.filter((e) => !bs.has(e));
+    const removed = b.filter((e) => !as.has(e));
+    let s = `  ${label}: ${added.length} added, ${removed.length} removed\n`;
+    for (const e of added)
+        s += `    + ${e}\n`;
+    for (const e of removed)
+        s += `    - ${e}\n`;
+    return s;
+}
+function splitEntries(raw) {
+    if (!raw.trim())
+        return [];
+    return raw.split(memoryManager_1.ENTRY_SEPARATOR).map((e) => e.trim()).filter((e) => e.length > 0);
+}
+// ── v4.9.0 Slice 10 — post-turn reviewer surface ────────────────────────
+const reviewer_1 = require("../../../core/v4/memory/reviewer");
+const pendingStore_1 = require("../../../core/v4/memory/reviewer/pendingStore");
+async function cmdPending(paths, out, json) {
+    const pending = await (0, pendingStore_1.listAllPending)(paths.memoryMd, paths.userMd);
+    if (json) {
+        out(JSON.stringify({ pending }, null, 2) + '\n');
+        return 0;
+    }
+    if (pending.length === 0) {
+        out('no pending candidates\n');
+        return 0;
+    }
+    out(`${pending.length} pending candidate(s):\n`);
+    for (const c of pending) {
+        out(`  ${c.memId}  [${c.file}]  ${c.text}\n    ↳ ${c.rationale}  (proposed ${c.proposedAt})\n`);
+    }
+    return 0;
+}
+async function cmdApprove(memIdRaw, args, paths, guard, mgr, out, err, json) {
+    const all = args.includes('--all');
+    const pending = await (0, pendingStore_1.listAllPending)(paths.memoryMd, paths.userMd);
+    const targets = all
+        ? pending
+        : (memIdRaw ? pending.filter((c) => c.memId === memIdRaw) : []);
+    if (targets.length === 0) {
+        if (json) {
+            out(JSON.stringify({ ok: false, reason: 'no_match' }) + '\n');
+        }
+        else {
+            err('approve: no pending candidate matched (use `--all` for batch, or pass a mem_id)\n');
+        }
+        return 1;
+    }
+    let approved = 0;
+    void mgr;
+    for (const c of targets) {
+        const ctx = buildCliCtx('memory_approve');
+        const filePath = c.file === 'user' ? paths.userMd : paths.memoryMd;
+        // v4.9.0 Slice 10 — DROP the pending candidate row BEFORE calling
+        // guardedAdd. Otherwise MemoryManager.add's substring-dedup sees
+        // the candidate text inside the pending block and short-circuits
+        // to `deduped: true` without appending a live entry.
+        await (0, pendingStore_1.dropCandidate)(filePath, c.memId);
+        await withMemorySpan(ctx, 'approve', c.file, async () => guard.guardedAdd(c.file, c.text));
+        approved += 1;
+    }
+    if (json) {
+        out(JSON.stringify({ ok: true, approved }) + '\n');
+    }
+    else {
+        out(`approved ${approved} candidate(s)\n`);
+    }
+    return 0;
+}
+async function cmdReject(memIdRaw, args, paths, out, err, json) {
+    const all = args.includes('--all');
+    const pending = await (0, pendingStore_1.listAllPending)(paths.memoryMd, paths.userMd);
+    const targets = all ? pending : (memIdRaw ? pending.filter((c) => c.memId === memIdRaw) : []);
+    if (targets.length === 0) {
+        if (json) {
+            out(JSON.stringify({ ok: false, reason: 'no_match' }) + '\n');
+        }
+        else {
+            err('reject: no pending candidate matched\n');
+        }
+        return 1;
+    }
+    let rejected = 0;
+    for (const c of targets) {
+        const ctx = buildCliCtx('memory_reject');
+        await withMemorySpan(ctx, 'reject', c.file, async () => {
+            await (0, pendingStore_1.dropCandidate)(c.file === 'user' ? paths.userMd : paths.memoryMd, c.memId);
+            return null;
+        });
+        rejected += 1;
+    }
+    if (json) {
+        out(JSON.stringify({ ok: true, rejected }) + '\n');
+    }
+    else {
+        out(`rejected ${rejected} candidate(s)\n`);
+    }
+    return 0;
+}
+async function cmdReview(args, paths, opts, out, err, json) {
+    const cfg = {
+        enabled: opts.reviewerConfig?.enabled ?? true,
+        mode: opts.reviewerConfig?.mode ?? 'on_quit',
+        timeoutMs: opts.reviewerConfig?.timeoutMs ?? 30000,
+        maxCandidates: opts.reviewerConfig?.maxCandidates ?? 5,
+    };
+    if (args.includes('--status')) {
+        if (json) {
+            out(JSON.stringify({ enabled: cfg.enabled, mode: cfg.mode, last_review: null, pending: (await (0, pendingStore_1.listAllPending)(paths.memoryMd, paths.userMd)).length }, null, 2) + '\n');
+        }
+        else {
+            const pendingCount = (await (0, pendingStore_1.listAllPending)(paths.memoryMd, paths.userMd)).length;
+            out(`review enabled: ${cfg.enabled}, mode: ${cfg.mode}, last review: never, pending: ${pendingCount}\n`);
+        }
+        return 0;
+    }
+    if (!args.includes('--now')) {
+        err('review: pass --now to trigger a pass, or --status to inspect config\n');
+        return 2;
+    }
+    if (!cfg.enabled || cfg.mode === 'off') {
+        if (json) {
+            out(JSON.stringify({ outcome: 'disabled', reason: cfg.mode === 'off' ? 'mode_off' : 'config_disabled' }) + '\n');
+        }
+        else {
+            out('review disabled (config: memory.review.enabled=false or mode=off)\n');
+        }
+        return 0;
+    }
+    if (!opts.reviewerCallLLM) {
+        if (json) {
+            out(JSON.stringify({ outcome: 'no_llm_configured' }) + '\n');
+        }
+        else {
+            err('review --now: no LLM callback wired (the CLI binding must inject reviewerCallLLM)\n');
+        }
+        return 1;
+    }
+    const recentTurns = opts.reviewerRecentTurns
+        ? await opts.reviewerRecentTurns()
+        : [];
+    const liveMemoryRaw = await Promise.resolve().then(() => __importStar(require('node:fs'))).then((m) => m.promises.readFile(paths.memoryMd, 'utf8').catch(() => ''));
+    const liveUserRaw = await Promise.resolve().then(() => __importStar(require('node:fs'))).then((m) => m.promises.readFile(paths.userMd, 'utf8').catch(() => ''));
+    // Wrap the review in a memory span so doctor / spans table track it.
+    const ctx = buildCliCtx('memory_review');
+    let outcome = null;
+    await withMemorySpan(ctx, 'review', 'memory', async () => {
+        outcome = await (0, reviewer_1.runReview)({
+            recentTurns, liveMemoryRaw, liveUserRaw,
+            memoryPath: paths.memoryMd, userPath: paths.userMd,
+            // v4.9.0 Slice 11 — pass paths + projectRoot so the reviewer
+            // can route `project`-namespace candidates to the right file
+            // when a project root is detected.
+            paths, projectRoot: (0, projectRoot_1.findProjectRoot)(process.cwd()),
+            callLLM: opts.reviewerCallLLM,
+            maxCandidates: cfg.maxCandidates,
+            timeoutMs: cfg.timeoutMs,
+            log: (level, msg) => {
+                if (level === 'error')
+                    err(msg + '\n');
+                else
+                    out(msg + '\n');
+            },
+        });
+        return outcome;
+    });
+    if (json) {
+        out(JSON.stringify(outcome, null, 2) + '\n');
+    }
+    else {
+        const o = outcome;
+        if (o.outcome === 'ok') {
+            out(`review ok: proposed=${o.candidatesProposed.length} duration=${o.durationMs}ms\n`);
+            for (const c of o.candidatesProposed) {
+                out(`  ${c.memId}  [${c.file}]  ${c.text}\n`);
+            }
+        }
+        else if (o.outcome === 'timeout') {
+            out(`review timed out after ${o.durationMs}ms (no candidates produced — user unaffected)\n`);
+        }
+        else if (o.outcome === 'error') {
+            out(`review error (fail-open): ${o.error} (no candidates produced)\n`);
+        }
+        else {
+            out(`review disabled: ${o.reason ?? ''}\n`);
+        }
+    }
+    return 0;
+}