@mingxy/cerebro-claude-code 0.3.6 → 0.3.8

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cerebro",
   "description": "Persistent memory for Claude Code — memories survive across sessions, projects, and machines",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "author": {
     "name": "mingxy-cerebro",
     "email": "hi@cerebro.dev"

package/hooks/apply-dream.mjs

@@ -5,6 +5,8 @@
 //   unknown kept name → surfaced as `unknown`, NEVER silently dropped (that is memory evaporation)
 //   dropped → removal candidate, listed for review; applied only with --apply
 //   merged/updated/added → LLM version wins (content is allowed to change there)
+//     except: added onto an existing local file is a conflict (LLM relabeled an
+//     existing memory as new) — skipped and surfaced, never blindly overwrites
 //   stats.total still counts kept entries — the ledger is the server's, not ours to re-derive
 //
 // Read-only review by default (prints the diff); `--apply` writes after user approval.
@@ -88,6 +90,7 @@ let entries = JSON.parse(readFileSync(archivePath, "utf8")).entries || [];
 // ─── merge ────────────────────────────────────────────────────────────────────
 const unknown = [];   // kept names missing from the old archive — LLM renamed, memory at risk
 const empty = [];     // content actions with empty body+description — never written, surfaced
+const conflict = [];  // added but a local file with that name exists — LLM rewrite mislabeled as new
 const report = { keep: 0, write: [], drop: [], dropCount: 0 };
 for (let e of entries) {
   // normalize BEFORE any branch: an LLM-emitted Chinese name that the MEMORY.md
@@ -105,6 +108,11 @@ for (let e of entries) {
     // 60-byte frontmatter shell. merged/updated skip = old content survives;
     // added skip = surfaced below, not silently dropped.
     if (!(e.body || "").trim() && !(e.description || "").trim()) { empty.push(`${e.name} (${act})`); continue; }
+    // added onto an existing local file = the LLM relabeled a rewrite as new
+    // (deepseek tic, cf. the 2026-08-20 archive where 6 existing entries came
+    // back as added with condensed bodies and zero new info). Its content
+    // would trade a hand-written file for a stub — skip, surface, human decides.
+    if (act === "added" && oldFiles.has(e.name)) { conflict.push(e.name); continue; }
     report.write.push(e); // LLM content is authoritative for these actions
   } else {
     unknown.push(`${e.name} (action=${act || "?"})`);
@@ -114,15 +122,17 @@ for (let e of entries) {
 // ─── review output ────────────────────────────────────────────────────────────
 const lines = [
   `apply-dream review · archive ${archivePath}`,
-  `kept ${report.keep} / write ${report.write.length} / drop ${report.dropCount} / unknown ${unknown.length}`,
+  `kept ${report.keep} / write ${report.write.length} / drop ${report.dropCount} / unknown ${unknown.length} / conflict ${conflict.length}`,
 ];
 for (const e of report.write) lines.push(`  ${e.source || e.action}  ${e.name} — ${(e.description || "").slice(0, 60)}`);
 for (const n of report.drop) lines.push(`  drop  ${n}`);
 for (const n of unknown) lines.push(`  ?     ${n}  ← surfaced, not dropped`);
 for (const n of empty) lines.push(`  ~     ${n}  ← empty stub skipped, not written`);
+for (const n of conflict) lines.push(`  !     ${n}  ← added but exists locally, skipped — review manually`);
 if (orphanFiles.length) lines.push(`  (unparsed old files left untouched: ${orphanFiles.length})`);
 console.log(lines.join("\n"));
 if (unknown.length) console.log("\n⚠ URGENT: unknown kept names above — surface to the user BEFORE applying; they may be renames the LLM invented.");
+if (conflict.length) console.log("\n⚠ CONFLICT: added-but-exists above — old file kept, dream content discarded; merge by hand if the dream version carries new info.");
 if (!APPLY) { console.log("\ndry run — pass --apply to write"); process.exit(0); }
 
 // ─── write phase (--apply) ─────────────────────────────────────────────────────

package/hooks/common.mjs

@@ -268,6 +268,34 @@ export function readCompactResult() {
   }
 }
 
+// ─── Pending clear flush (SessionEnd:clear → SessionStart:clear) ────────────
+// /clear swaps session_id, so the old transcript can only be flushed by the
+// NEW session's SessionStart(clear) hook (detached flush can't emit a toast).
+const PENDING_CLEAR_FLUSH_FILE = join(HOME, ".config/cerebro/pending-clear-flush.json");
+
+export function writePendingClearFlush(tp, sid) {
+  try {
+    mkdirSync(dirname(PENDING_CLEAR_FLUSH_FILE), { recursive: true });
+    writeFileSync(PENDING_CLEAR_FLUSH_FILE, JSON.stringify({ tp, sid, ts: Date.now() }));
+  } catch {}
+}
+
+export function readPendingClearFlush() {
+  try {
+    if (!existsSync(PENDING_CLEAR_FLUSH_FILE)) return null;
+    const data = JSON.parse(readFileSync(PENDING_CLEAR_FLUSH_FILE, "utf-8"));
+    // Stale after 60s — user cleared but never resumed in this window
+    if (Date.now() - (data.ts || 0) > 60_000) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export function clearPendingClearFlush() {
+  try { unlinkSync(PENDING_CLEAR_FLUSH_FILE); } catch {}
+}
+
 // ─── Cursor (session ingest dedup) ───────────────────────────────────────────
 const TRACKER_DIR = join(HOME, ".config/cerebro/trackers");
 
@@ -418,7 +446,7 @@ function contentText(content) {
   return "";
 }
 
-export async function flushSessionIngest(transcriptPath, sessionId) {
+export async function flushSessionIngest(transcriptPath, sessionId, timeoutSec = 25) {
   if (!transcriptPath || !existsSync(transcriptPath) || !sessionId || !config.apiKey) return { ok: false, count: 0 };
 
   const cursor = cursorGet(sessionId);
@@ -476,7 +504,7 @@ export async function flushSessionIngest(transcriptPath, sessionId) {
     if (pn) body.project_name = pn;
     if (pp) body.project_path = pp;
 
-    const result = await omPost("/v1/memories/session-ingest", body, 25);
+    const result = await omPost("/v1/memories/session-ingest", body, timeoutSec);
     if (result.status >= 200 && result.status < 300) {
       cursorSet(sessionId, lastUid);
       logDebug(`flush_session_ingest: ok http=${result.status} cursor=${lastUid}`);

package/hooks/flush-detached.mjs

@@ -2,7 +2,7 @@
 // cerebro detached flush — spawned by session-end.mjs to survive process exit
 // Runs independently after Claude Code terminates. No stdin/stdout to Claude.
 import { existsSync } from "node:fs";
-import { config, flushSessionIngest, logDebug, logError } from "./common.mjs";
+import { config, flushSessionIngest, clearPendingClearFlush, logDebug, logError } from "./common.mjs";
 import { judgeMaterial, readState, runDream } from "./dream.mjs";
 
 const tp = process.env.CEREBRO_TP || "";
@@ -25,6 +25,9 @@ const result = await flushSessionIngest(tp, sid).catch((err) => {
 
 if (result.ok) {
   logDebug(`detached flush: ok count=${result.count} sid=${sid}`);
+  // Retrying a SessionStart(clear) handoff — consume it so the next SessionStart
+  // doesn't replay a 0-delta toast from the stale pending file.
+  if (process.env.CEREBRO_CLEAR_PENDING) clearPendingClearFlush();
 } else {
   logError(`detached flush: failed sid=${sid} http=${result.status || "?"} (cursor NOT advanced, will retry next session)`);
 }

package/hooks/session-end.mjs

@@ -5,15 +5,25 @@
 // Fix: spawn detached child process, parent exits immediately.
 import { spawn } from "node:child_process";
 import { join } from "node:path";
-import { config, PLUGIN_ROOT, refCountDec, parseStdinJSON, emit, logDebug } from "./common.mjs";
+import { config, PLUGIN_ROOT, refCountDec, parseStdinJSON, emit, logDebug, writePendingClearFlush } from "./common.mjs";
 
 if (!config.apiKey) { emit({}); process.exit(0); }
 
 const input = parseStdinJSON();
 const tp = input.transcript_path || "";
 const sid = input.session_id || input.sessionId || "";
+const reason = input.reason || "";
 
-logDebug(`session-end: sid=${sid} tp=${tp ? tp.slice(-40) : "EMPTY"}`);
+logDebug(`session-end: sid=${sid} reason=${reason} tp=${tp ? tp.slice(-40) : "EMPTY"}`);
+
+// /clear swaps session_id and fires SessionStart(clear) right after — hand the
+// flush to it so the result lands in that hook's toast (detached flush is mute).
+if (reason === "clear" && tp && sid) {
+  writePendingClearFlush(tp, sid);
+  refCountDec();
+  emit({});
+  process.exit(0);
+}
 
 // Spawn detached flush script — survives parent exit
 if (tp && sid) {

package/hooks/session-start.mjs

@@ -4,7 +4,7 @@ import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { readFileSync } from "node:fs";
 import {
-  config, PLUGIN_ROOT, PLUGIN_VERSION, detectProjectPath, parseStdinJSON, emit, buildMemoryInjection, postRecallEvent, refCountInc, readCompactResult, injectionConfig,
+  config, PLUGIN_ROOT, PLUGIN_VERSION, detectProjectPath, parseStdinJSON, emit, buildMemoryInjection, postRecallEvent, refCountInc, readCompactResult, readPendingClearFlush, clearPendingClearFlush, flushSessionIngest, injectionConfig,
 } from "./common.mjs";
 import { judgeMaterial, readState, writeStateForReport, fetchOrphanResult } from "./dream.mjs";
 
@@ -131,6 +131,29 @@ if (startSource === "compact") {
   }
 }
 
+// After /clear, the OLD session's tail flush runs here (SessionEnd:clear only
+// wrote a handoff file) so its result shows in this toast like stop/compact.
+if (startSource === "clear") {
+  const pending = readPendingClearFlush();
+  if (pending) {
+    const r = await flushSessionIngest(pending.tp, pending.sid, 8).catch(() => ({ ok: false, count: 0 }));
+    if (r.ok) {
+      clearPendingClearFlush();
+      statusMsg += ` · Clear ingest ✓ ${r.count} msgs`;
+    } else {
+      // Out of hook budget — detached retry with full 25s timeout, silent
+      try {
+        const child = spawn(process.execPath, [join(PLUGIN_ROOT, "hooks", "flush-detached.mjs")], {
+          detached: true, stdio: "ignore",
+          env: { ...process.env, CEREBRO_TP: pending.tp, CEREBRO_SID: pending.sid, CEREBRO_CLEAR_PENDING: "1" },
+        });
+        child.unref();
+      } catch {}
+      statusMsg += ` · Clear ingest ↻ background`;
+    }
+  }
+}
+
 // ─── POST recall event（让 web sessions 页面看到 CC session + 完整注入内容）─────
 await postRecallEvent({
   sessionId: sid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro-claude-code",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Persistent memory for Claude Code — memories survive across sessions, projects, and machines",
   "author": {
     "name": "mingxy-cerebro",

package/tests/hooks.test.mjs

@@ -3,6 +3,8 @@ import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 
 const HOOKS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "hooks");
 
@@ -109,3 +111,38 @@ describe("session-end.mjs", () => {
     assert.deepEqual(out, {});
   });
 });
+
+describe("apply-dream.mjs", () => {
+  test("added onto existing local file is a conflict, not an overwrite", async () => {
+    const tmp = mkdtempSync(join(tmpdir(), "apply-dream-"));
+    try {
+      const memDir = join(tmp, "memory");
+      mkdirSync(memDir);
+      const existing = "---\nname: cc-x\ndescription: hand-written\nmetadata:\n  type: feedback\n---\n\nprecise body\n";
+      writeFileSync(join(memDir, "cc-x.md"), existing);
+      writeFileSync(join(memDir, "MEMORY.md"), "- [cc-x](cc-x.md) — hand-written\n");
+      const outDir = join(tmp, "dream", "output");
+      mkdirSync(outDir, { recursive: true });
+      writeFileSync(join(outDir, "20260820.json"), JSON.stringify({ entries: [
+        { name: "cc-x", action: "added", body: "condensed stub rewrite" }, // mislabeled rewrite
+        { name: "cc-new", action: "added", body: "genuinely new" },        // real addition
+      ] }));
+
+      const res = await new Promise((resolve) => {
+        const child = spawn(process.execPath, [join(HOOKS_DIR, "apply-dream.mjs"), "--apply"], {
+          env: { ...process.env, OMEM_DREAM_DIR: join(tmp, "dream"), OMEM_DREAM_MEMORY_DIR: memDir },
+        });
+        let stdout = "";
+        child.stdout.on("data", (d) => (stdout += d));
+        child.on("close", (code) => resolve({ stdout, code }));
+      });
+
+      assert.ok(res.stdout.includes("conflict 1"), `expected one conflict, got: ${res.stdout}`);
+      assert.ok(res.stdout.includes("!     cc-x"), "conflicting name must be listed");
+      assert.equal(readFileSync(join(memDir, "cc-x.md"), "utf8"), existing, "existing file must stay untouched");
+      assert.ok(readFileSync(join(memDir, "cc-new.md"), "utf8").includes("genuinely new"), "genuinely new entry must be written");
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});