claude-mem-lite 6.11.0 → 6.12.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.11.0",
+      "version": "6.12.0",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.11.0",
+  "version": "6.12.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/README.md

@@ -405,6 +405,7 @@ surface — reach them through the CLI column in the second table.
 /mem <query>               # Shorthand for search
 /lesson <text>             # Save a non-obvious lesson to the events table (v2.31.0)
 /bug <text>                # Log a known bug + repro steps to the events table (v2.31.0)
+/verify                    # Check memories against the current code; correct stale ones after you approve
 ```
 
 ### Efficient Search Workflow

package/README.zh-CN.md

@@ -341,6 +341,7 @@ README 和 `docs/ARCHITECTURE.md` 都钉在它上面。）
 /mem <query>               # search 的简写
 /lesson <text>             # 保存非显而易见的经验到 events 表（v2.31.0）
 /bug <text>                # 记录已知 bug + 复现步骤到 events 表（v2.31.0）
+/verify                    # 对照当前代码核查记忆；你确认后才改正过期的记忆
 ```
 
 ### 高效搜索工作流

package/cli/common.mjs

@@ -399,6 +399,13 @@ export const KNOWN_CLI_FLAGS = new Set([
   // warn-on-every-unknown-flag flip turned the omission into a false warning on a
   // documented, working command.
   'prompts-limit',
+  // `verify-apply --apply --digest <d>` / `--undo <backup>` — read as flags.apply / .digest / .undo in
+  // cli/verify-apply.mjs. Missing here, a working apply printed "Unknown flag --apply — ignored,
+  // it had no effect" beside its own read-back. Pinned by tests/verify-apply-cli.test.mjs.
+  'apply',
+  'digest',
+  'print-project',
+  'undo',
   // Entries here MUST be read by a `claude-mem-lite` subcommand. A flag that no
   // command reads is worse than an absent one: it converts the "ignored, it had no
   // effect" warning into silence, so the user's dropped flag reads as accepted.

package/cli/verify-apply.mjs

@@ -0,0 +1,197 @@
+// cli/verify-apply.mjs — `claude-mem-lite verify-apply <proposals.json> [--project P]`
+// (dry run), `... --apply --digest <d>`, and `claude-mem-lite verify-apply --undo <backup.json>`.
+//
+// The write step of /verify (commands/verify.md). The agent proposes; this command is the only
+// thing that writes. It defaults to a dry run that prints the new text itself and a digest, and
+// --apply refuses unless it is handed that digest back: what the user approved is what lands,
+// and a proposals file or a row that changed in between is refused rather than applied. All
+// policy lives in lib/verify-apply-core.mjs; this file is I/O, formatting and exit codes.
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { DB_DIR } from '../lib/data-paths.mjs';
+import { atomicWriteFileSync } from '../lib/atomic-write.mjs';
+import { inferProject } from '../utils.mjs';
+import { resolveProject } from '../project-utils.mjs';
+import {
+  parseProposals,
+  planVerifyApply,
+  planDigest,
+  priorVerifyApplies,
+  runVerifyApply,
+  undoVerifyBackup,
+  markUndone,
+} from '../lib/verify-apply-core.mjs';
+import { parseArgs, out, fail, rejectBareStringFlags } from './common.mjs';
+
+const USAGE =
+  '[mem] Usage: claude-mem-lite verify-apply <proposals.json> [--project P]          (dry run)\n' +
+  '       claude-mem-lite verify-apply <proposals.json> [--project P] --apply --digest <d>\n' +
+  '       claude-mem-lite verify-apply --undo <backup.json>';
+
+const SNIPPET_CONTEXT = 60;
+const BACKUP_DIR = join(DB_DIR, 'backups');
+// The commands this prints must run as printed. `claude-mem-lite` is on PATH only after an
+// optional global npm install (which may also be a different, stale code home), so name the
+// node binary and THIS cli.mjs — the one that produced the plan.
+/** A path as one shell word: as-is when it is plain, single-quoted otherwise. */
+const shellWord = (s) => (/^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`);
+const SELF = process.argv[1] ? `node ${shellWord(process.argv[1])}` : 'claude-mem-lite';
+
+function readJson(path, what) {
+  try {
+    return { value: JSON.parse(readFileSync(path, 'utf8')) };
+  } catch (e) {
+    return { error: `[mem] Cannot read ${what} ${path}: ${e.message}` };
+  }
+}
+
+/**
+ * The changed region of a field, with context. The changed part is printed IN FULL, never
+ * clipped: the digest covers the whole text, so any cap here would let the user approve text
+ * they were never shown (re-review of dcc8f72, P2-2). Only unchanged context is elided.
+ */
+function snippet(before, after) {
+  const a = before === null || before === undefined ? '' : String(before);
+  const b = String(after);
+  if (a === b) return ['    (unchanged)'];
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const from = Math.max(0, start - SNIPPET_CONTEXT);
+  const lead = from > 0 ? '…' : '';
+  const tail = (s, end) => (end + SNIPPET_CONTEXT < s.length ? '…' : '');
+  return [
+    `    - ${lead}${a.slice(from, Math.min(a.length, endA + SNIPPET_CONTEXT))}${tail(a, endA)}`,
+    `    + ${lead}${b.slice(from, Math.min(b.length, endB + SNIPPET_CONTEXT))}${tail(b, endB)}`,
+  ];
+}
+
+function describe(p) {
+  const head = `  #${p.id} [${p.verdict}] ${p.action} — evidence: ${p.evidence}`;
+  if (p.action === 'retire') return [head, '    retired with no replacement (kept as history)'];
+  const fields =
+    p.action === 'edit'
+      ? Object.entries(p.set)
+      : ['title', 'narrative', 'lesson_learned', 'importance', 'facts', 'concepts']
+          .filter((k) => p[k] !== undefined)
+          .map((k) => [k, p[k]]);
+  const lines = [head];
+  if (p.action === 'replace') lines.push('    new memory supersedes this one; unlisted fields are copied');
+  for (const [k, v] of fields) lines.push(`   ${k}:`, ...snippet(p.before[k], v));
+  return lines;
+}
+
+function undo(db, path) {
+  const { value, error } = readJson(path, 'backup');
+  if (error) return fail(error);
+  const { errors, restored } = undoVerifyBackup(db, value);
+  if (restored.length === 0 && errors.length)
+    return fail(`[mem] Undo refused, nothing written:\n  ${errors.join('\n  ')}`);
+  for (const r of restored) {
+    out(
+      `  #${r.id} restored${r.replacementRetired ? ` (replacement #${r.replacementRetired} retired)` : ''}`,
+    );
+  }
+  if (errors.length) return fail(`[mem] Undo read-back found problems:\n  ${errors.join('\n  ')}`);
+  out(`[mem] Undo complete: ${restored.length} row(s) restored.`);
+  // The restore is committed; marking the file only stops a second run early. If the mark
+  // cannot be written, a second undo is still refused (the rows no longer match the apply's
+  // record), so this is a warning, not a failure of the undo that already happened.
+  try {
+    atomicWriteFileSync(path, JSON.stringify(markUndone(value), null, 1));
+  } catch (e) {
+    process.stderr.write(
+      `[mem] Warning: undo is done, but ${path} could not be marked as undone: ${e.message}\n`,
+    );
+  }
+}
+
+export function cmdVerifyApply(db, args) {
+  const { positional, flags } = parseArgs(args);
+  if (rejectBareStringFlags(flags, ['project', 'undo', 'digest'])) return;
+  // The project verify-apply targets when --project is omitted, printed so /verify can export
+  // exactly that project (export's --project matching is fuzzy; this is not).
+  if (flags['print-project'] === true) return out(inferProject());
+  // Boolean means boolean: `--apply=false` / `--apply no` must not apply.
+  if (flags.apply !== undefined && flags.apply !== true)
+    return fail(`[mem] --apply takes no value.\n${USAGE}`);
+
+  if (flags.undo !== undefined) {
+    if (positional.length || flags.apply || flags.digest) return fail(USAGE);
+    return undo(db, flags.undo);
+  }
+
+  const file = positional[0];
+  if (!file || positional.length > 1) return fail(USAGE);
+  const { value, error } = readJson(file, 'proposals');
+  if (error) return fail(error);
+
+  const parsed = parseProposals(value);
+  if (parsed.errors.length)
+    return fail(`[mem] Invalid proposals, nothing written:\n  ${parsed.errors.join('\n  ')}`);
+
+  const project = flags.project ? resolveProject(db, flags.project, { mode: 'write' }) : inferProject();
+  const { plan, errors } = planVerifyApply(db, parsed.entries, { project });
+  if (errors.length) return fail(`[mem] Refused, nothing written:\n  ${errors.join('\n  ')}`);
+  const digest = planDigest(
+    plan,
+    project,
+    priorVerifyApplies(
+      BACKUP_DIR,
+      plan.map((p) => p.id),
+    ),
+  );
+
+  if (!flags.apply) {
+    out(`[mem] verify-apply plan — project ${project}, ${plan.length} change(s):`);
+    for (const p of plan) for (const line of describe(p)) out(line);
+    out(`[mem] Plan digest: ${digest}`);
+    out('[mem] Dry run — nothing written. After the user approves exactly this plan, run:');
+    out(
+      `  ${SELF} verify-apply ${shellWord(file)} --project ${shellWord(project)} --apply --digest ${digest}`,
+    );
+    return;
+  }
+
+  if (!flags.digest) {
+    return fail('[mem] --apply requires --digest <d> from the dry run the user approved. Nothing written.');
+  }
+  if (flags.digest !== digest) {
+    return fail(
+      '[mem] Plan digest mismatch: the proposals file or the memories changed since the dry run. ' +
+        'Nothing written — re-run the dry run and get the new plan approved.',
+    );
+  }
+
+  let run;
+  try {
+    run = runVerifyApply(db, plan, { backupDir: BACKUP_DIR });
+  } catch (e) {
+    // One failure happens AFTER the commit: the undo record could not be written. The changes
+    // are in the database then, and saying "nothing written" would be false.
+    if (e.message.startsWith('applied, but')) {
+      return fail(
+        `[mem] APPLIED — the changes are in the database, but ${e.message.slice('applied, but '.length)}`,
+      );
+    }
+    return fail(`[mem] ${e.message}`);
+  }
+  for (const c of run.checks) {
+    out(
+      `  #${c.id} ${c.action}${c.newId ? ` → #${c.newId}` : ''}: ${c.ok ? 'ok' : `MISMATCH (${c.problems.join('; ')})`}`,
+    );
+  }
+  out(`[mem] Backup: ${run.backupPath}`);
+  out(
+    `[mem] To undo (only while these rows are untouched): ${SELF} verify-apply --undo ${shellWord(run.backupPath)}`,
+  );
+  if (run.checks.some((c) => !c.ok)) {
+    fail('[mem] Applied, but read-back found mismatches — show the MISMATCH lines above to the user.');
+  }
+}

package/cli.mjs

@@ -14,6 +14,7 @@ const CLI_COMMANDS = new Set([
   'update',
   'export',
   'restore',
+  'verify-apply',
   'compress',
   'maintain',
   'optimize',

package/commands/verify.md

@@ -0,0 +1,156 @@
+---
+name: verify
+description: "Use when: the user explicitly asks to verify, audit or correct their stored memories against the current code (e.g. \"check my memories for stale ones\", /verify). You check each memory with read-only repo tools and propose corrections; nothing is written until the user approves the exact plan. Not for routine recall or saving."
+---
+
+# /verify — check memories against the code, then correct the stale ones
+
+Memories go stale: a bug recorded as open gets fixed, a measurement gets retracted, a
+mechanism is replaced. Measured on 118 live memories across 7 repos, ~10% were STALE and
+~14% PARTIAL, and most went stale within a day of being saved. No automatic pass catches
+this — cheap single-shot models misjudged it (precision 0.36) and model-written corrections
+were false in 28 of 72 cases. What works is YOU reading the code: you propose, the user
+approves the exact plan, and `verify-apply` is the only thing that writes.
+
+(If another plugin also defines `/verify`, this one is `/claude-mem-lite:verify`.)
+
+## Arguments
+
+- `--from <YYYY-MM-DD>`: only memories saved on or after this date (default: all live).
+- `--ids 12,34`: only these memories.
+- `--project <name>`: a project other than the current one.
+
+## Step 1 — Select
+
+Get the exact project name first. For the current project (the usual case), run from the
+project's directory:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply --print-project
+```
+
+It prints the canonical name (e.g. `dev--my-app`) that verify-apply itself will target. For
+another project, use the name the user gave only if it already has the `parent--name` shape;
+otherwise ask. Always pass that exact name — `export --project` matches loosely and can pick a
+neighbouring project from a short name.
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" export --project <project> [--from <date>] > <scratch>/memories.json
+```
+
+Every row carries `id`, `project`, `type`, `title`, `narrative`, `facts`, `lesson_learned`,
+`files_modified`, `created_at`. Check that every row's `project` is the name you passed. With
+`--ids`, filter the file to those ids. The repository to check them against is the current
+directory for the current project; for another project, ask the user where it lives.
+`files_modified` holds both absolute and repo-relative paths. Tell the user how many memories
+you are about to check.
+
+## Step 2 — Verify (read-only)
+
+For EACH memory, answer: *if this memory were shown to an agent working in this repo today,
+would anything it asserts mislead that agent?*
+
+1. List its concrete, checkable claims: identifiers, file paths, `file:line` references,
+   constants, counts, behaviours, "X is still broken", "Y was measured at Z".
+2. Check each against the current tree (Grep, Read) and, where useful, the history since
+   `created_at` (`git log --since=<created_at> -- <files>`, `git log -S<token>`, `git show`).
+3. Pick one verdict:
+   - **VALID** — every checkable claim still holds.
+   - **STALE** — at least one specific claim is contradicted by the tree or history: a
+     renamed/removed symbol, a changed value or default, a changed behaviour, a bug presented
+     as open that has since been fixed, a count that moved, a measurement later retracted.
+   - **PARTIAL** — the main point holds; a secondary detail (a line number, a count, a minor
+     mechanism) is out of date.
+   - **UNVERIFIABLE** / **NO_CODE_CLAIM** — leave these alone.
+
+Rules that the measurement showed matter:
+- A file having changed is NOT a contradiction. You need a line, a diff hunk, a commit, or a
+  command's output that contradicts a specific claim.
+- Output you did not see is not a contradiction. A grep that printed nothing, or output cut
+  off by `head` or a size limit, proves nothing — re-run it untruncated before calling a claim
+  stale.
+- A number only a test run could confirm (a test count, a coverage figure) is a dated
+  measurement: stale only if a later commit or document reports a different value, not
+  because you cannot re-run it here.
+- A record of what happened (what was measured then, what a review found) stays true as
+  history. It is stale only if it would mislead about the PRESENT.
+- A note that already records its own fix is not stale because the fix commit landed later.
+- Do not write, stash, check out or run tests while verifying.
+
+More than ~25 memories: split them into batches and give each batch to a read-only subagent
+with the rubric above; have each subagent write its results to a file with a bash heredoc and
+reply with only the path. Treat a subagent's verdict as a lead: before proposing anything,
+re-open every cited `file:line`, commit or command yourself.
+
+## Step 3 — Draft proposals (STALE and PARTIAL only)
+
+If every memory is VALID (or UNVERIFIABLE / NO_CODE_CLAIM), stop here: report the counts to
+the user and say nothing needs changing. Do not run Step 4 with an empty proposals file.
+
+Write `<scratch>/proposals.json` — a JSON array, one entry per memory to change:
+
+```json
+[
+  { "id": 52, "action": "replace", "verdict": "STALE",
+    "title": "...", "narrative": "...", "lesson_learned": "...",
+    "evidence": "7bc8ba9; hook-optimize.mjs:1371-1383" },
+  { "id": 64, "action": "edit", "verdict": "PARTIAL",
+    "set": { "narrative": "..." }, "evidence": "hook-llm.mjs:1359-1361" },
+  { "id": 201, "action": "retire", "verdict": "STALE", "evidence": "600c744" }
+]
+```
+
+- **edit** — the stale part is one detail in `title`, `narrative`, `lesson_learned`,
+  `importance` or `concepts`. Copy the original text into `set` and change only the stale words.
+- **replace** — the memory's claim is wrong but its lesson is still worth keeping, OR the
+  stale detail sits in `facts` (edit cannot change `facts`). Write the corrected memory; give
+  `facts` (an empty string drops them) or `concepts` when those are what is stale. Omitted
+  fields are copied from the original, which stays as history.
+- **retire** — nothing in it is worth keeping (e.g. a mid-debug note about a failure fixed
+  minutes later).
+- `evidence` is required: the commit, the `file:line`, or the command and its output (for
+  something outside the repo, e.g. a tool version) that shows the memory is out of date.
+- `lesson_learned` is at most 500 characters. Keep the memory's language.
+
+## Step 4 — Show the plan and get approval
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply <scratch>/proposals.json --project <project>
+```
+
+This is a dry run: it validates every entry against the database, writes nothing, prints each
+change as `-` old / `+` new text (the changed text in full), and ends with a **plan digest**
+and the exact apply command.
+Show the user that output as it is (do not summarise the changes away), plus your counts of
+VALID / STALE / PARTIAL, and ask for approval. If the dry run refuses an entry, fix the
+proposal — never work around it with `update`, `save` or `delete`. If you change the proposals
+after the user saw them, run the dry run again and show the new plan: the digest changes, and
+the old one will be refused.
+
+## Step 5 — Apply, only after the user approves that plan
+
+Run exactly the command the dry run printed:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply <scratch>/proposals.json --project <project> --apply --digest <digest>
+```
+
+It refuses if the proposals or the memories changed since the dry run. Otherwise it backs up
+every target row, applies all entries in one transaction (all or nothing), reads each row back
+and prints `ok` or `MISMATCH`, then prints the backup path and the undo command. Report the
+result and the undo command to the user. Reading the exit status:
+- exit 0 — applied, every row read back `ok`.
+- exit 1 with `MISMATCH` lines — applied, but a row did not read back as planned. Show those
+  lines; do not re-run the apply.
+- exit 1 with a message starting `APPLIED` — the changes are in the database, but no undo
+  record could be written. Say exactly that.
+- any other exit 1 — nothing was written. Say why.
+
+Undo (`verify-apply --undo <backup>`) only works while the changed rows' content and state are
+as the apply left them (usage counters such as access counts do not count): it refuses once any
+of them changes again — an edit, a supersede, or a routine background pass (importance decay,
+alias or concept backfill) — and it runs at most once. It then prints `Undo complete`; a `Warning: … could not be marked as undone` line means
+the undo still happened. After an undo, the earlier apply command is refused: applying the
+same changes again needs a new dry run and the user's approval of its new digest. That refusal
+rests on the backup file: once it is deleted, the earlier command would match again, so never
+re-run an apply command from an earlier approval.

package/hook-optimize.mjs

@@ -101,7 +101,7 @@ export function findReenrichCandidates(db, limit = 10, { scope = 'narrow', proje
     // injects lesson-bearing rows — classifying those first is what makes the
     // lever usable before the backlog is fully drained.
     const stmt = db.prepare(`
-      SELECT id, title, narrative, type, lesson_learned, importance, project
+      SELECT id, title, narrative, type, lesson_learned, importance, project, text, optimized_at
       FROM observations
       WHERE ${liveObsFilterSql('')}
         AND scope IS NULL
@@ -124,7 +124,7 @@ export function findReenrichCandidates(db, limit = 10, { scope = 'narrow', proje
     // deliberately NOT gated on optimized_at, so a lesson-less row can still be
     // picked up by wide scope for lesson enrichment afterward.
     const stmt = db.prepare(`
-      SELECT id, title, narrative, type, subtitle, concepts, facts, text, search_aliases, importance, project
+      SELECT id, title, narrative, type, subtitle, concepts, facts, text, search_aliases, importance, project, optimized_at
       FROM observations
       WHERE ${liveObsFilterSql('')}
         AND (search_aliases IS NULL OR search_aliases = '')
@@ -157,7 +157,7 @@ export function findReenrichCandidates(db, limit = 10, { scope = 'narrow', proje
     // strand exactly those rows — the R10 P2-2 shape, where one pass's bookkeeping
     // evicts a row from a backfill it never visited.
     const stmt = db.prepare(`
-      SELECT id, title, narrative, type, subtitle, concepts, facts, text, importance, project
+      SELECT id, title, narrative, type, subtitle, concepts, facts, text, importance, project, optimized_at
       FROM observations
       WHERE ${liveObsFilterSql('')}
         AND (concepts IS NULL OR concepts = '')
@@ -302,10 +302,16 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
         }
         // `AND scope IS NULL` is the fill-only-empty guard: a save-enrich worker or
         // an episode upgrade can land between candidate selection and this write,
-        // and a classifier round-trip is long enough for that to be real.
+        // and a classifier round-trip is long enough for that to be real. The live guard
+        // and `text IS ? AND optimized_at IS ?` are the aliases branch's, for its reasons:
+        // the classification was made from the text read before the call, so it may land
+        // only on a live row still holding that text (a /verify approval changes both).
         const res = db
-          .prepare('UPDATE observations SET scope = ? WHERE id = ? AND scope IS NULL')
-          .run(scopeValue, cand.id);
+          .prepare(
+            `UPDATE observations SET scope = ?
+             WHERE id = ? AND scope IS NULL AND ${liveObsFilterSql('')} AND text IS ? AND optimized_at IS ?`,
+          )
+          .run(scopeValue, cand.id, cand.text, cand.optimized_at);
         if (res.changes === 0) {
           skipped++;
           continue;
@@ -354,12 +360,25 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
         // D#6. This was the one branch of the four without it. `changes === 0` is a SKIP,
         // not a success: it must not count as processed. (It also used to guard a vector
         // rebuild on a dead row; that rebuild is gone, the liveness reason is not.)
+        // `text IS ? AND optimized_at IS ?`: the new text is the text read BEFORE the call plus
+        // the aliases, so it may only land on a row still holding that text. A /verify approval
+        // during the call rebuilds text and stamps optimized_at; without the compare the stale
+        // text came back and the corrected row matched searches for the claim it had just
+        // dropped (pre-ship review of 9786874, P2-2). A skip here is retried next cycle,
+        // against the row as it is then.
         const res = db
           .prepare(
             `UPDATE observations SET search_aliases = ?, text = ?, scope = COALESCE(?, scope)
-             WHERE id = ? AND ${liveObsFilterSql('')}`,
+             WHERE id = ? AND ${liveObsFilterSql('')} AND text IS ? AND optimized_at IS ?`,
           )
-          .run(safe.search_aliases, safe.text, normalizeScope(parsed.scope), cand.id);
+          .run(
+            safe.search_aliases,
+            safe.text,
+            normalizeScope(parsed.scope),
+            cand.id,
+            cand.text,
+            cand.optimized_at,
+          );
         if (res.changes === 0) {
           skipped++;
           continue;
@@ -395,7 +414,12 @@ facts: 1-4 specific, checkable statements the narrative actually asserts. Omit r
           skipped++;
           continue;
         }
-        const factArr = pickStrings(parsed && parsed.facts);
+        // Model facts only on a row no pass has stamped. `facts` is displayed as the memory's
+        // own claims, and a stamped row is either one the general re-enrich pass already wrote
+        // facts for, or one a user approved through /verify — where this pass replaced the
+        // approved facts with model text (pre-ship review of 9786874, P1-1). Concepts are
+        // search keywords and still fill.
+        const factArr = cand.optimized_at === null ? pickStrings(parsed && parsed.facts) : [];
         const conceptsOnly = conceptArr.slice(0, 10).join(' ');
         const factsOnly = factArr.slice(0, 10).join(' ');
         const appendedText = [
@@ -416,12 +440,15 @@ facts: 1-4 specific, checkable statements the narrative actually asserts. Omit r
         // concurrent hook to supersede or compress the row (R10 P3-3) or for save-enrich
         // to fill it. `facts` rides along with preserve-on-empty for the same reason the
         // general pass preserves it — a partial answer must not wipe a filled column.
+        // `text IS ? AND optimized_at IS ?` for the reason the alias branch gives, and one
+        // more: it is what makes the facts decision above still true at write time.
         const res = db
           .prepare(
             `UPDATE observations SET concepts = ?, facts = COALESCE(NULLIF(?, ''), facts), text = ?
-             WHERE id = ? AND (concepts IS NULL OR concepts = '') AND ${liveObsFilterSql('')}`,
+             WHERE id = ? AND (concepts IS NULL OR concepts = '') AND ${liveObsFilterSql('')}
+               AND text IS ? AND optimized_at IS ?`,
           )
-          .run(safe.concepts, safe.facts, safe.text, cand.id);
+          .run(safe.concepts, safe.facts, safe.text, cand.id, cand.text, cand.optimized_at);
         if (res.changes === 0) {
           skipped++;
           continue;
@@ -468,7 +495,7 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
         const res = db
           .prepare(
             `UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}, optimized_at = ?
-             WHERE id = ? AND ${liveObsFilterSql('')}`,
+             WHERE id = ? AND ${liveObsFilterSql('')} AND optimized_at IS NULL`,
           )
           .run(Date.now(), cand.id);
         if (res.changes === 0) {
@@ -552,13 +579,19 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
       // scopes branch already guards with `AND scope IS NULL`; this is the same idea.
       // 0 changes is a skip, not a success: it must not count as processed and must not
       // rebuild a vector for a row that is no longer live.
+      // `optimized_at IS NULL` is the same idea for the pool's OTHER predicate: narrow and wide
+      // select only unstamped rows, and a /verify approval stamps the row it approves. Without
+      // the re-check an edit approved during the call was overwritten — narrow wrote model
+      // text over it, wide wrote back the pre-edit narrative it read before the call
+      // (tests/verify-reenrich-race.test.mjs). It also stops two overlapping runs rewriting a
+      // row twice.
       const res = db
         .prepare(
           `
         UPDATE observations SET type=?, title=?, narrative=?, concepts=?, facts=?,
           text=?, importance=?, lesson_learned=?, search_aliases=?, minhash_sig=?, optimized_at=?,
           scope=COALESCE(?, scope)
-        WHERE id = ? AND ${liveObsFilterSql('')}
+        WHERE id = ? AND ${liveObsFilterSql('')} AND optimized_at IS NULL
       `,
         )
         .run(
@@ -1248,6 +1281,20 @@ Return ONLY valid JSON:
         .prepare(`SELECT 1 FROM observations WHERE id = ? AND ${liveObsFilterSql('')}`)
         .get(keeper.id);
       if (!keeperLive) return false;
+      // findMergeCandidates selects only live rows with optimized_at NULL. A member stamped
+      // since then was edited through /verify (or rewritten by another pass) during the model
+      // call; a member no longer live was retired or replaced (a /verify retire or replace
+      // supersedes the original without stamping it), or superseded by another writer. The
+      // merged text was written from all of them as they were, so folding it in would bring
+      // a withdrawn claim back inside the keeper (tests/verify-reenrich-race.test.mjs).
+      // Abort the whole cluster rather than merge part.
+      const clusterIds = cluster.map((o) => o.id);
+      const unchanged = db
+        .prepare(
+          `SELECT COUNT(*) AS n FROM observations WHERE id IN (${clusterIds.map(() => '?').join(',')}) AND optimized_at IS NULL AND ${liveObsFilterSql('')}`,
+        )
+        .get(...clusterIds).n;
+      if (unchanged !== clusterIds.length) return false;
 
       // Snapshot the keeper's pre-merge row BEFORE overwriting it, so its original
       // full text survives as a recoverable compressed_into child (mirroring
@@ -1296,7 +1343,11 @@ Return ONLY valid JSON:
       return true;
     })();
     if (!mergeApplied) {
-      debugLog('DEBUG', 'llm-optimize', `cluster-merge aborted: keeper #${keeper.id} no longer live`);
+      debugLog(
+        'DEBUG',
+        'llm-optimize',
+        `cluster-merge aborted: keeper #${keeper.id} no longer live, or a member changed during the call`,
+      );
       return { merged: false };
     }
 
@@ -1331,7 +1382,7 @@ export function findSmartCompressCandidates(db, ageDays = 30, { project } = {})
   const cutoff = Date.now() - ageDays * DAY_MS;
   const projectClause = project ? 'AND project = ?' : '';
   const stmt = db.prepare(`
-    SELECT id, title, narrative, lesson_learned, project, type, created_at_epoch
+    SELECT id, title, narrative, lesson_learned, project, type, created_at_epoch, optimized_at
     FROM observations
     -- liveObsFilterSql, not compressed_into alone (audit 2026-09-02 P0-3): auto-dedup losers
     -- carry superseded_at with compressed_into=0 and match this predicate exactly (imp=1,
@@ -1488,6 +1539,25 @@ export async function executeSmartCompressCluster(db, observations, project) {
     const medianEpoch = epochs[Math.floor(epochs.length / 2)];
 
     const summaryId = db.transaction(() => {
+      // The summary was written from the members as they were BEFORE the Sonnet call. A member
+      // whose stamp changed since was edited through /verify (or rewritten by another pass);
+      // a member no longer live was retired or replaced (neither stamps the original) or
+      // superseded by another writer. A summary of their earlier text would put the withdrawn
+      // claim back as a live row and hide the rest behind it (pre-ship review of 9786874,
+      // P2-1; delta review of the first repair). Abort the whole cluster, as cluster-merge does.
+      // Callers pass rows as findSmartCompressCandidates selects them, optimized_at included:
+      // a row without the column reads as unstamped, so a stamped member would abort (safe).
+      const nowRow = db.prepare(
+        `SELECT optimized_at FROM observations WHERE id = ? AND ${liveObsFilterSql('')}`,
+      );
+      if (
+        observations.some((o) => {
+          const cur = nowRow.get(o.id);
+          return !cur || (cur.optimized_at ?? null) !== (o.optimized_at ?? null);
+        })
+      ) {
+        return null;
+      }
       const sessionId = `compress-${project}`;
       const now = new Date();
       db.prepare(
@@ -1551,7 +1621,8 @@ export async function executeSmartCompressCluster(db, observations, project) {
       // Live guard (audit 2026-09-02 P0-3): the candidate SELECT is separated from this write
       // by a Sonnet round-trip, so a member may already be compressed into another summary or
       // tombstoned. Re-pointing it here would silently remove a row from that summary's child
-      // set. Members that lost liveness stay where they are; the summary still lands.
+      // set. The check at the top of this transaction now aborts in that case; the guard stays
+      // so this UPDATE can never re-point a dead row on its own.
       db.prepare(
         `UPDATE observations SET compressed_into = ? WHERE id IN (${ph}) AND ${liveObsFilterSql('')}`,
       ).run(sId, ...obsIds);
@@ -1559,6 +1630,10 @@ export async function executeSmartCompressCluster(db, observations, project) {
       return sId;
     })();
 
+    if (summaryId === null) {
+      debugLog('DEBUG', 'llm-optimize', 'smart-compress aborted: a member changed during the call');
+      return { compressed: false };
+    }
     debugLog(
       'DEBUG',
       'llm-optimize',

package/install.mjs

@@ -3053,9 +3053,10 @@ function cleanup() {
   // Reap leaked test-fixture sandboxes from temp (mem-e2e-* / mem-audit-* / cite-*
   // etc.) left by interrupted vitest runs — the §8.V4 disposal gap the audit found
   // (~795MB). 24h age here (vs 1h in the test reaper) is conservative for a manual
-  // cleanup. Scans os.tmpdir() and the Claude Code temp root, depth-1, mem-prefixes
+  // cleanup. Scans os.tmpdir(), the Claude Code temp root and ~/.cache/tmp (where
+  // `npm test` points TMPDIR, off the RAM-backed /tmp), depth-1, mem-prefixes
   // only — never touches other tools' temp dirs.
-  const fixtureRoots = [tmpdir(), join(homedir(), '.claude', 'tmp')];
+  const fixtureRoots = [tmpdir(), join(homedir(), '.claude', 'tmp'), join(homedir(), '.cache', 'tmp')];
   const swept = sweepStaleTestFixtures({ dirs: fixtureRoots, ageMs: 24 * 60 * 60 * 1000, dryRun });
   for (const p of swept.names) ok(`${dryRun ? 'Would remove' : 'Removed'}: ${p}`);
   removed += swept.removed;