@mingxy/cerebro-claude-code 0.3.3

package/hooks/dream.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+// OMEM dream trigger — detached worker, spawned by flush-detached.mjs / session-start.mjs
+// Runs independently after Claude Code terminates. Owns the full dream lifecycle:
+//   lock → judge "enough material" → collect food → POST /v1/dreams → poll → write output
+//
+// State file protocol (~/.cache/cerebro/dream/state.json, tmp+rename atomic write):
+//   { phase: "run"|"fail"|"done", job_id, started_at, updated_at,
+//     last_dream_at, consumed, error?, stats? }
+// Output: ~/.cache/cerebro/dream/output/<job_id>.json (full DreamResult)
+// Lock:   ~/.cache/cerebro/dream/trigger.lock (O_EXCL, TTL 15min > 600s server budget)
+//
+// Memory food = CC local memory dir (one md per memory, frontmatter verbatim).
+// Sessions food = mechanical extraction from transcripts (user/assistant text only,
+// tool_use/tool_result/system stripped), per-session cap, oldest dropped first when
+// over the 512KB / 50-session server budget (P1-2).
+import { existsSync, mkdirSync, readFileSync, writeFileSync, openSync, closeSync, unlinkSync, readdirSync, statSync, renameSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { config, logDebug, logError } from "./common.mjs";
+
+const HOME = homedir();
+const DREAM_DIR = process.env.OMEM_DREAM_DIR || join(HOME, ".cache", "cerebro", "dream");
+const OUT_DIR = join(DREAM_DIR, "output");
+const STATE = join(DREAM_DIR, "state.json");
+const LOCK = join(DREAM_DIR, "trigger.lock");
+// ponytail: hardcodes the home-project memory dir as the dream subject; DREAM_MEMORY_DIR
+// escapes hatch for other projects if per-project dreams ever matter
+const MEMORY_DIR = process.env.OMEM_DREAM_MEMORY_DIR || join(HOME, ".claude", "projects", "-home-dongx", "memory");
+const PROJECTS_DIR = join(HOME, ".claude", "projects");
+
+// Rhythm: dream when last dream ≥6h ago AND ≥2 new sessions since; 24h fallback.
+const MIN_INTERVAL_MS = 6 * 3600 * 1000;
+const FALLBACK_MS = 24 * 3600 * 1000;
+const MIN_NEW_SESSIONS = 2;
+const MAX_SESSIONS = 50;              // server hard limit (validate_request)
+const MAX_PAYLOAD = 512 * 1024;       // server hard limit (P1-2)
+const PER_SESSION_CAP = 16 * 1024;    // per-transcript extraction budget
+const LOCK_TTL_MS = 15 * 60 * 1000;   // > 600s server job budget
+const POLL_INTERVAL_MS = 2000;
+const POLL_BUDGET_MS = 660 * 1000;    // > 600s server timeout (ADR-3)
+
+// ─── state helpers (tmp+rename atomic) ───────────────────────────────────────
+export function readState() {
+  try { return JSON.parse(readFileSync(STATE, "utf8")); } catch { return null; }
+}
+function writeState(obj) {
+  mkdirSync(DREAM_DIR, { recursive: true });
+  const tmp = STATE + ".tmp";
+  writeFileSync(tmp, JSON.stringify(obj));
+  renameSync(tmp, STATE);
+}
+
+// ─── trigger lock (O_EXCL; cross-session on shared fs; TOCTOU-proof) ─────────
+function acquireLock() {
+  mkdirSync(DREAM_DIR, { recursive: true });
+  try { closeSync(openSync(LOCK, "wx")); return true; } // we hold it
+  catch {
+    try {
+      const age = Date.now() - statSync(LOCK).mtimeMs;
+      if (age > LOCK_TTL_MS) { unlinkSync(LOCK); try { closeSync(openSync(LOCK, "wx")); return true; } catch {} }
+    } catch {}
+    return false;
+  }
+}
+function releaseLock() { try { unlinkSync(LOCK); } catch {} }
+
+// ─── food: memory dir (verbatim md with frontmatter) ─────────────────────────
+function collectMemory() {
+  const parts = [];
+  for (const f of readdirSync(MEMORY_DIR).filter((x) => x.endsWith(".md")).sort()) {
+    try { parts.push(readFileSync(join(MEMORY_DIR, f), "utf8")); } catch {}
+  }
+  return parts.join("\n\n");
+}
+
+// ─── food: sessions (mechanical extraction, no LLM in hooks) ─────────────────
+function listTranscripts(sinceMs) {
+  const out = [];
+  for (const proj of readdirSync(PROJECTS_DIR)) {
+    const dir = join(PROJECTS_DIR, proj);
+    let st; try { st = statSync(dir); } catch { continue; }
+    if (!st.isDirectory()) continue;
+    for (const f of readdirSync(dir)) {
+      if (!f.endsWith(".jsonl")) continue;
+      const p = join(dir, f);
+      let s; try { s = statSync(p); } catch { continue; }
+      out.push({ path: p, mtime: s.mtimeMs });
+    }
+  }
+  return out.sort((a, b) => b.mtime - a.mtime); // newest first
+}
+
+function extractTranscript(path) {
+  const lines = readFileSync(path, "utf8").split("\n");
+  const texts = [];
+  let budget = PER_SESSION_CAP;
+  for (const line of lines) {
+    if (budget <= 0) break;
+    let j; try { j = JSON.parse(line); } catch { continue; }
+    if (j.type !== "user" && j.type !== "assistant") continue;
+    const c = j.message?.content;
+    let t = "";
+    if (typeof c === "string") t = c;
+    else if (Array.isArray(c)) for (const blk of c) { if (blk.type === "text") t += blk.text + "\n"; }
+    t = t.trim();
+    if (!t || t.startsWith("<")) continue; // skip hook injections / tool wrappers
+    t = t.slice(0, budget);
+    budget -= t.length;
+    texts.push(t);
+  }
+  return texts.join("\n---\n");
+}
+
+// ─── rhythm judge ────────────────────────────────────────────────────────────
+export function judgeMaterial(state) {
+  const last = state?.last_dream_at ? Date.parse(state.last_dream_at) : 0;
+  const sinceMs = last || 0;
+  const newer = listTranscripts(sinceMs).filter((t) => t.mtime > sinceMs && t.mtime > last);
+  const age = Date.now() - last;
+  const enoughTime = age >= MIN_INTERVAL_MS;
+  const fallback = last > 0 && age >= FALLBACK_MS;
+  return { ok: newer.length >= MIN_NEW_SESSIONS && (enoughTime || !last) || fallback, since: last ? new Date(last).toISOString() : null, count: newer.length };
+}
+
+// ─── detached main: trigger + poll + persist ─────────────────────────────────
+export async function runDream() {
+  if (!config.apiKey) return;
+  if (!acquireLock()) { logDebug("dream: lock held, another window is dreaming"); return; }
+  try {
+    const prev = readState();
+    const judge = judgeMaterial(prev);
+    if (!judge.ok) { logDebug(`dream: not enough material (new=${judge.count})`); return; }
+
+    const memory = collectMemory();
+    const trans = listTranscripts(0).filter((t) => !judge.since || t.mtime > Date.parse(judge.since));
+    const sessions = [];
+    let bytes = memory.length;
+    for (const t of trans) { // newest first; drop oldest by simply stopping
+      if (sessions.length >= MAX_SESSIONS) break;
+      const s = extractTranscript(t.path);
+      if (bytes + s.length > MAX_PAYLOAD) break;
+      bytes += s.length;
+      sessions.push(s);
+    }
+    if (!sessions.length) { logDebug("dream: no session food extracted"); return; }
+
+    const started = new Date().toISOString();
+    writeState({ phase: "run", job_id: null, started_at: started, updated_at: started, last_dream_at: prev?.last_dream_at || null, consumed: false });
+
+    let resp;
+    try {
+      resp = await fetch(`${config.apiUrl}/v1/dreams`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-API-Key": config.apiKey },
+        body: JSON.stringify({ memory, sessions, since: judge.since }),
+        signal: AbortSignal.timeout(30_000),
+      });
+    } catch (e) {
+      writeState({ phase: "fail", error: `POST: ${e?.message || e}`, updated_at: new Date().toISOString(), last_dream_at: prev?.last_dream_at || null, consumed: true });
+      logError(`dream: POST failed ${e?.message || e}`);
+      return;
+    }
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      writeState({ phase: "fail", error: `POST http=${resp.status} ${body.slice(0, 200)}`, updated_at: new Date().toISOString(), last_dream_at: prev?.last_dream_at || null, consumed: true });
+      logError(`dream: POST http=${resp.status}`);
+      return;
+    }
+    const { id } = await resp.json();
+    const now = new Date().toISOString();
+    const st = readState() || {};
+    writeState({ ...st, phase: "run", job_id: id, updated_at: now }); // job_id immediately: orphans are queryable
+    logDebug(`dream: job ${id} accepted`);
+
+    // poll to terminal state (2s × 660s > 600s server budget)
+    const deadline = Date.now() + POLL_BUDGET_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+      let jr;
+      try {
+        const g = await fetch(`${config.apiUrl}/v1/dreams/${id}`, { headers: { "X-API-Key": config.apiKey }, signal: AbortSignal.timeout(10_000) });
+        if (g.status === 404) continue; // server restart lost the job — keep polling til budget, then fail
+        jr = await g.json();
+      } catch { continue; }
+      if (jr.status === "completed" || jr.status === "failed") {
+        const ts = new Date().toISOString();
+        if (jr.status === "completed" && jr.result) {
+          mkdirSync(OUT_DIR, { recursive: true });
+          const outPath = join(OUT_DIR, `${id}.json`);
+          writeFileSync(outPath, JSON.stringify(jr.result));
+          writeState({ phase: "done", job_id: id, started_at: st.started_at, updated_at: ts, last_dream_at: ts, consumed: false, stats: jr.result.stats, output: outPath });
+          logDebug(`dream: completed stats=${JSON.stringify(jr.result.stats)}`);
+        } else {
+          writeState({ phase: "fail", job_id: id, error: jr.error || "job failed", updated_at: ts, last_dream_at: st.started_at, consumed: true });
+          logError(`dream: job failed ${jr.error || ""}`);
+        }
+        return;
+      }
+    }
+    writeState({ phase: "fail", job_id: id, error: "poll budget exhausted", updated_at: new Date().toISOString(), last_dream_at: st.started_at, consumed: true });
+    logError("dream: poll budget exhausted");
+  } finally {
+    releaseLock();
+  }
+}
+
+// ─── report-side helpers (used by session-start.mjs) ─────────────────────────
+// Mark consumed so each new window doesn't re-inject the same report.
+export function writeStateForReport(st) {
+  writeState({ ...st, consumed: true });
+}
+
+// Orphan recovery: single GET, no polling. completed → write output+done, return new state.
+// running/pending → give up (next window retries). Network errors → return null (stale shown grey).
+export async function fetchOrphanResult(st) {
+  if (!st?.job_id || !config.apiKey) return null;
+  try {
+    const g = await fetch(`${config.apiUrl}/v1/dreams/${st.job_id}`, {
+      headers: { "X-API-Key": config.apiKey },
+      signal: AbortSignal.timeout(6000), // single GET, 6s budget — same as recent-timeout precedent
+    });
+    const jr = await g.json();
+    if (jr.status !== "completed" || !jr.result) return null; // running/failed → next window
+    mkdirSync(OUT_DIR, { recursive: true });
+    const outPath = join(OUT_DIR, `${st.job_id}.json`);
+    writeFileSync(outPath, JSON.stringify(jr.result));
+    const ts = new Date().toISOString();
+    const ns = { ...st, phase: "done", updated_at: ts, last_dream_at: ts, consumed: false, stats: jr.result.stats, output: outPath };
+    writeState(ns);
+    return ns;
+  } catch { return null; }
+}
+
+// ─── direct CLI entry (detached worker) ──────────────────────────────────────
+if (process.argv[1] && basename(process.argv[1]) === "dream.mjs") {
+  if (!existsSync(LOCK) && judgeMaterial(readState()).ok) {
+    await runDream();
+  }
+  process.exit(0);
+}

package/hooks/flush-detached.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// 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 { judgeMaterial, readState, runDream } from "./dream.mjs";
+
+const tp = process.env.CEREBRO_TP || "";
+const sid = process.env.CEREBRO_SID || "";
+
+if (!tp || !sid || !config.apiKey) {
+  logError(`detached flush: skipped (tp=${!!tp} sid=${!!sid} key=${!!config.apiKey})`);
+  process.exit(0);
+}
+
+if (!existsSync(tp)) {
+  logError(`detached flush: transcript not found sid=${sid} tp=${tp}`);
+  process.exit(0);
+}
+
+const result = await flushSessionIngest(tp, sid).catch((err) => {
+  logError(`detached flush: exception sid=${sid} err=${err?.message || err}`);
+  return { ok: false, count: 0 };
+});
+
+if (result.ok) {
+  logDebug(`detached flush: ok count=${result.count} sid=${sid}`);
+} else {
+  logError(`detached flush: failed sid=${sid} http=${result.status || "?"} (cursor NOT advanced, will retry next session)`);
+}
+
+// ─── dream trigger: session just ended = new material; judge then run ────────
+// This detached worker already survives CC exit, so it also survives the
+// ≤660s dream poll — no second spawn needed.
+try {
+  const judge = judgeMaterial(readState());
+  if (judge.ok) {
+    logDebug(`dream: material ready (new=${judge.count}), dreaming after flush`);
+    await runDream();
+  }
+} catch (e) {
+  logError(`dream trigger: ${e?.message || e}`);
+}
+
+process.exit(0);

package/hooks/hooks.json

@@ -0,0 +1,83 @@
+{
+  "description": "cerebro — persistent memory hooks for Claude Code",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/session-start.mjs",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/user-prompt-submit.mjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Skill|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/recall-approve.mjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/stop.mjs",
+            "timeout": 25
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/session-end.mjs",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/pre-compact.mjs",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/post-compact.mjs",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/post-compact.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// cerebro PostCompact hook — flush + ingest compact_summary + toast
+// PostCompact 在 CC 完成上下文压缩后触发，stdin 包含 compact_summary。
+import {
+  config, flushSessionIngest, omPost, detectProjectName, detectProjectPath, parseStdinJSON, emit, logWarn, logError, writeCompactResult,
+} 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 summary = input.compact_summary || "";
+
+if (!tp || !sid) {
+  logWarn("post-compact: missing transcript_path/session_id");
+  emit({});
+  process.exit(0);
+}
+
+// 1. Flush 压缩前剩余增量（PreCompact 已 flush 过则 delta=0，无副作用）
+const result = await flushSessionIngest(tp, sid).catch(() => ({ ok: false, count: 0 }));
+if (!result.ok) logError(`post-compact: flush failed for sid=${sid}`);
+
+// 2. Ingest compact_summary 作为 assistant 消息（对标 opencode autocontinueHook）
+let summaryOk = false;
+if (summary.length > 100) {
+  const body = {
+    messages: [{ role: "assistant", content: `[compact_summary] ${summary.slice(0, 8000)}` }],
+    agent_id: process.env.OMEM_AGENT_ID || "claude-code",
+    session_id: sid,
+    source: "compact_summary",
+  };
+  const pn = detectProjectName();
+  const pp = detectProjectPath();
+  if (pn) body.project_name = pn;
+  if (pp) body.project_path = pp;
+  const res = await omPost("/v1/memories/session-ingest", body, 25);
+  summaryOk = res.status >= 200 && res.status < 300;
+}
+
+const totalCount = result.count + (summaryOk ? 1 : 0);
+
+// Write result for SessionStart:compact to pick up and merge into its toast
+writeCompactResult({ ok: result.ok || summaryOk, count: totalCount });
+
+emit({
+  systemMessage: `🧠 Cerebro · Post-compact · ${totalCount} items ingested`,
+});

package/hooks/pre-compact.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// cerebro PreCompact hook — flush delta before compaction
+// PreCompact 不支持 hookSpecificOutput.additionalContext（CC schema 限制）。
+// 仅做 flushSessionIngest，压缩指导由 CLAUDE.md 中的 cerebro-recall 指令覆盖。
+import { config, flushSessionIngest, parseStdinJSON, emit, logWarn, logError } 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 || "";
+
+if (!tp || !sid) {
+  logWarn("pre-compact: missing transcript_path/session_id");
+  emit({});
+  process.exit(0);
+}
+
+const result = await flushSessionIngest(tp, sid).catch(() => ({ ok: false, count: 0 }));
+if (!result.ok) logError(`pre-compact: flush_session_ingest failed for sid=${sid} (will retry at SessionEnd)`);
+
+emit({
+  systemMessage: result.ok
+    ? `🧠 Cerebro · Pre-compact flush · ${result.count} messages ingested`
+    : `🧠 Cerebro · Pre-compact flush failed (will retry at SessionEnd)`,
+});

package/hooks/recall-approve.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// cerebro PreToolUse hook — auto-approve memory-search calls
+// matcher: Skill|Bash (hooks.json). Detects memory-search → permissionDecision=allow.
+import { parseStdinJSON, emit } from "./common.mjs";
+
+const d = parseStdinJSON();
+const toolName = (d.tool_name || "").toLowerCase();
+const toolInput = d.tool_input || {};
+const cmd = toolInput.command || "";
+const name = toolInput.name || "";
+
+let isSearch = false;
+if (toolName.includes("memory-search")) {
+  isSearch = true;
+} else if (toolName === "skill" && name.toLowerCase().includes("memory-search")) {
+  isSearch = true;
+} else if (toolName === "bash" && cmd.includes("memory-search")) {
+  // 无危险 shell 操作符（防止拼接注入）
+  isSearch = !/[;&|`]/.test(cmd) && !cmd.includes("$(");
+}
+
+if (isSearch) {
+  emit({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" } });
+} else {
+  emit({});
+}

package/hooks/session-end.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// cerebro SessionEnd hook — spawn detached flush to survive process exit
+// Claude Code does NOT wait for SessionEnd hooks to complete ("cannot block
+// session termination"). Direct await fetch gets killed → http=0.
+// 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";
+
+if (!config.apiKey) { emit({}); process.exit(0); }
+
+const input = parseStdinJSON();
+const tp = input.transcript_path || "";
+const sid = input.session_id || input.sessionId || "";
+
+logDebug(`session-end: sid=${sid} tp=${tp ? tp.slice(-40) : "EMPTY"}`);
+
+// Spawn detached flush script — survives parent exit
+if (tp && sid) {
+  const flushScript = join(PLUGIN_ROOT, "hooks", "flush-detached.mjs");
+  try {
+    const child = spawn(process.execPath, [flushScript], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, CEREBRO_TP: tp, CEREBRO_SID: sid },
+    });
+    child.unref();
+  } catch {}
+}
+
+refCountDec();
+emit({
+  systemMessage: `🧠 Cerebro · Session flush in background`,
+});

package/hooks/session-start.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// cerebro SessionStart hook — profile + recent injection + recall event + web server
+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,
+} from "./common.mjs";
+import { judgeMaterial, readState, writeStateForReport, fetchOrphanResult } from "./dream.mjs";
+
+// ─── dream report: read local output, mark consumed; never write memory here ──
+// URGENT is ratio-based: dropped >10% of total OR added ≥2 → flag for the
+// session's Claude to surface to the user. The full new archive stays on disk —
+// writing memory files is the session Claude's job, after the user reviews.
+async function dreamReport() {
+  try {
+    let st = readState();
+    if (!st) return "";
+    // orphan: run state older than 15min → one single GET, no polling
+    if (st.phase === "run" && Date.now() - Date.parse(st.updated_at) > 15 * 60 * 1000 && st.job_id) {
+      st = (await fetchOrphanResult(st)) || st;
+    }
+    if (st.phase === "fail") {
+      return `[dream-report] last dream failed: ${st.error || "?"} (${st.updated_at})\n`;
+    }
+    if (st.phase !== "done" || st.consumed || !st.output) return "";
+    const result = JSON.parse(readFileSync(st.output, "utf8"));
+    const s = result.stats || {};
+    const total = s.total || 1;
+    const urgent = (s.dropped || 0) > total * 0.1 || (s.added || 0) >= 2;
+    const lines = [
+      `[dream-report] job ${st.job_id?.slice(0, 8)} · ${st.updated_at}`,
+      `merged ${s.merged || 0} / updated ${s.updated || 0} / added ${s.added || 0} / dropped ${s.dropped || 0} / kept ${total - (s.merged || 0) - (s.updated || 0) - (s.added || 0) - (s.dropped || 0)}`,
+    ];
+    for (const e of result.entries || []) {
+      lines.push(`· ${e.action || "?"} ${e.name || "?"} — ${e.description || ""}`);
+    }
+    if (urgent) lines.push(`⚠ URGENT: significant dream changes above — surface this report to the user NOW.`);
+    lines.push(`New full archive on disk: ${st.output}`);
+    lines.push(`Do NOT auto-overwrite memory files: show the user a diff, let them approve, then write.`);
+    writeStateForReport(st); // consumed=true
+    return lines.join("\n") + "\n";
+  } catch { return ""; }
+}
+
+// ─── dream follow-up: material ready but no window ended recently? start one ──
+// Async spawn, never blocks startup. Complements the SessionEnd trigger.
+function dreamFollowUp() {
+  try {
+    const st = readState();
+    if (st?.phase === "run" || (st?.phase === "done" && !st.consumed)) return; // busy or unreported
+    if (!judgeMaterial(st).ok) return;
+    const child = spawn(process.execPath, [join(PLUGIN_ROOT, "hooks", "dream.mjs")], {
+      detached: true, stdio: "ignore", env: { ...process.env },
+    });
+    child.unref();
+  } catch {}
+}
+
+const input = parseStdinJSON();
+const sid = input.session_id || "";
+const startSource = input.source || ""; // "startup" | "resume" | "clear" | "compact"
+
+// ─── web server 拉起（probe + detached spawn，跨平台）─────────────────────────
+const webPort = process.env.OMEM_LOCAL_PORT || "5212";
+try {
+  const resp = await fetch(`http://127.0.0.1:${webPort}/health`, {
+    signal: AbortSignal.timeout(1000),
+  });
+  if (!resp.ok) throw new Error("not healthy");
+} catch {
+  try {
+    const child = spawn(
+      process.execPath,
+      [join(PLUGIN_ROOT, "scripts", "web-server.mjs")],
+      { detached: true, stdio: "ignore", env: { ...process.env } },
+    );
+    child.unref();
+  } catch {}
+}
+refCountInc();
+
+// ─── API key 检查 ────────────────────────────────────────────────────────────
+if (!config.apiKey) {
+  const msg = `[cerebro] OMEM_API_KEY not set — memory is disabled.
+
+To enable persistent memory, set your API key:
+  export OMEM_API_KEY="your-key"
+
+Get a free key:
+  curl -X POST ${config.apiUrl}/v1/tenants -H "Content-Type: application/json" -d "{}"
+
+Then restart Claude Code.`;
+  emit({ systemMessage: "🧠 Cerebro: API key not set — memory disabled", hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: msg } });
+  process.exit(0);
+}
+
+// ─── 时间标记 ────────────────────────────────────────────────────────────────
+function cerebroTime() {
+  const d = new Date(Date.now() + 8 * 3600 * 1000);
+  const pad = (n) => String(n).padStart(2, "0");
+  const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  return `[CEREBRO-TIME] 当前: ${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())} ${days[d.getUTCDay()]}`;
+}
+
+// ─── buildMemoryInjection（对标 opencode buildMemoryInjection）──────────────────
+const pp = detectProjectPath();
+const ss = injectionConfig.sessionStart || {};
+const injection = await buildMemoryInjection("", pp, {
+  profileEnabled: ss.profileEnabled !== false,
+  recentEnabled: ss.recentActivityEnabled !== false,
+});
+
+// CEREBRO-TIME 注入 Claude 上下文（Claude 需要时间感知）
+let out = injection.text;
+const timeLine = cerebroTime();
+out = out.replace("[CEREBRO-MEMORY]", `[CEREBRO-MEMORY]\n${timeLine}`);
+
+// CEREBRO-STATUS 通过 systemMessage 显示给用户（Q2: toast 替代方案）
+const memCount = injection.projectMemoryCount + injection.searchCount;
+let statusMsg = injection.recentFailed
+  ? `🧠 Cerebro v${PLUGIN_VERSION} · Recent ✗ (timeout) · Profile ${injection.profileCount > 0 ? "✓" : "✗"}`
+  : `🧠 Cerebro v${PLUGIN_VERSION} · Connected · ${memCount} memories · Profile ${injection.profileCount > 0 ? "✓" : "✗"}`;
+
+// After compact, PostCompact toast gets overridden by SessionStart:compact toast.
+// Merge PostCompact ingest result into this toast so user sees it.
+if (startSource === "compact") {
+  const cr = readCompactResult();
+  if (cr) {
+    statusMsg += ` · Post-compact ingest ${cr.ok ? "✓" : "✗"} ${cr.count} items`;
+  }
+}
+
+// ─── POST recall event（让 web sessions 页面看到 CC session + 完整注入内容）─────
+await postRecallEvent({
+  sessionId: sid,
+  recallType: "session_start",
+  queryText: `Session Start · ${injection.projectMemoryCount} memories · ${injection.profileCount > 0 ? "profile" : "no profile"}`,
+  profileInjected: injection.profileCount > 0,
+  keptCount: injection.projectMemoryCount,
+  injectedContent: out,
+  failureReason: injection.recentFailed ? "recent fetch failed/timeout" : "",
+});
+
+// ─── dream：报告注入（本地读，零网络）+ 料够补刀（异步 spawn）───────────────────
+const drep = await dreamReport();
+if (drep) {
+  out = drep + out;
+  statusMsg += " · Dream report ready";
+}
+dreamFollowUp();
+
+emit({
+  systemMessage: statusMsg,
+  hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: out },
+});