@mingxy/cerebro 1.18.16 → 1.18.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.18.16",
+  "version": "1.18.18",
   "description": "Cerebro persistent memory plugin for OpenCode — auto-recall, auto-capture, 9 memory tools with clustering, project-scoped memory isolation",
   "type": "module",
   "main": "src/index.ts",

package/src/client.ts

@@ -298,9 +298,11 @@ export class CerebroClient {
     return this.request("/v2/profile/stats");
   }
 
-  async listRecent(limit = 20): Promise<MemoryDto[]> {
+  async listRecent(limit = 20, projectPath?: string): Promise<MemoryDto[]> {
+    const params = new URLSearchParams({ limit: String(limit), offset: "0", sort: "updated_at", order: "desc" });
+    if (projectPath) params.set("project_path", projectPath);
     const res = await this.request<ListResponse>(
-      `/v1/memories?limit=${limit}&offset=0`,
+      `/v1/memories?${params}`,
     );
     return res?.memories ?? [];
   }

package/src/hooks.ts

@@ -1,26 +1,13 @@
 import type { Model, UserMessage, Part } from "@opencode-ai/sdk";
 import type { CerebroClient, SearchResult } from "./client.js";
 import { type OmemPluginConfig, resolveAgentPolicy } from "./config.js";
-import { detectSaveKeyword, KEYWORD_NUDGE } from "./keywords.js";
 import { logDebug, logInfo, logError as logErr } from "./logger.js";
 import { readFile } from "node:fs/promises";
-import { stripPrivateContent } from "./privacy.js";
 
 const BOUNDARY_SEARCH_RATIO = 0.6;
-const MIN_ITEM_CONTENT_CHARS = 100;
-const MIN_CONTENT_CHARS = 1000;
-const MIN_CONTENT_LENGTH = 50;
 
 const projectNameCache = new Map<string, string>();
 
-function appendToSystem(system: string[], content: string) {
-  if (system.length > 0) {
-    system[system.length - 1] += "\n\n" + content;
-  } else {
-    system.push(content);
-  }
-}
-
 async function detectProjectName(rootPath: string): Promise<string | undefined> {
   const cached = projectNameCache.get(rootPath);
   if (cached !== undefined) {
@@ -175,11 +162,11 @@ function extractUserRequest(content: string): string {
   return text;
 }
 
-const saveKeywordDetectedSessions = new Set<string>();
-const firstMessages = new Map<string, string>();
-const sessionMessages = new Map<string, Array<{ role: string; content: string }>>();
+export const saveKeywordDetectedSessions = new Set<string>();
+export const firstMessages = new Map<string, string>();
+export const sessionMessages = new Map<string, Array<{ role: string; content: string }>>();
 export const profileInjectedSessions = new Map<string, number>();
-const lastProfileBlock = new Map<string, { content: string; count: number }>();
+export const lastProfileBlock = new Map<string, { content: string; count: number }>();
 const lastUserMsgCount = new Map<string, number>();
 const summarizedSessions = new Set<string>();
 
@@ -216,34 +203,6 @@ function truncate(text: string, maxLength: number): string {
   return truncated + "…";
 }
 
-function categorize(results: SearchResult[]): Map<string, SearchResult[]> {
-  const groups = new Map<string, SearchResult[]>();
-  for (const r of results) {
-    const cat = r.memory.category || "General";
-    const label =
-      cat === "preferences"
-        ? "Preferences"
-        : cat === "knowledge"
-          ? "Knowledge"
-          : cat.charAt(0).toUpperCase() + cat.slice(1);
-    if (!groups.has(label)) groups.set(label, []);
-    groups.get(label)!.push(r);
-  }
-  return groups;
-}
-
-function formatMemoryLine(r: SearchResult, maxContentLength: number): string {
-  const age = formatRelativeAge(r.memory.created_at);
-  const tags = r.memory.tags.length > 0 ? ` [${r.memory.tags.join(", ")}]` : "";
-  const idTag = ` [id:${r.memory.id}]`;
-  const relTag = r.memory.relations && r.memory.relations.length > 0
-    ? ` [rel:${r.memory.relations.map((rel) => rel.target_id).join(",")}]`
-    : "";
-  const refineTag = r.refine_relevance?.trim() ? ` [${r.refine_relevance.trim()}]` : "";
-  const content = truncate(r.memory.content, maxContentLength);
-  return `  - (${age}${idTag}${relTag}${refineTag}${tags}) ${content}`;
-}
-
 const FETCH_POLICY = [
   "<cerebro-fetch-policy>",
   "IMPORTANT: Each memory above is a condensed summary. The full version contains critical details that may change your response quality.",
@@ -252,370 +211,172 @@ const FETCH_POLICY = [
   "</cerebro-fetch-policy>",
 ].join("\n");
 
-/**
- * Score-weighted budget allocation: high-score memories get more chars.
- * Falls back to uniform distribution when totalScore === 0 or all scores equal.
- */
-interface ContextBlockResult {
+const INJECTION_MAX_CHARS_FALLBACK = 4000;
+
+interface InjectionResult {
   text: string;
-  injectedMemoryIds: string[];
-  injectedCount: number;
+  profileCount: number;
+  memoryCount: number;
+  projectMemoryCount: number;
 }
 
-function buildContextBlock(
-  results: SearchResult[],
-  budget: number,
-  maxContentLength: number = 500,
-  minItemChars: number = MIN_ITEM_CONTENT_CHARS,
-): ContextBlockResult {
-  const empty: ContextBlockResult = { text: "", injectedMemoryIds: [], injectedCount: 0 };
-  if (results.length === 0) return empty;
-
-  const totalScore = results.reduce((sum, r) => sum + r.score, 0);
-
-  const grouped = categorize(results);
-  const sections: string[] = [];
-
-  for (const [label, items] of grouped) {
-    const lines = items.map((r) => {
-      const itemMaxLen = totalScore > 0
-        ? Math.min(maxContentLength, Math.max(minItemChars, Math.floor((r.score / totalScore) * budget)))
-        : Math.min(maxContentLength, Math.max(minItemChars, Math.floor(budget / results.length)));
-      return formatMemoryLine(r, itemMaxLen);
-    });
-    sections.push(`[${label}]\n${lines.join("\n")}`);
+export async function buildMemoryInjection(
+  client: CerebroClient,
+  projectPath: string | undefined,
+  query: string,
+  config: Partial<OmemPluginConfig>,
+): Promise<InjectionResult> {
+  const maxChars = config.content?.maxContentLength ?? INJECTION_MAX_CHARS_FALLBACK;
+
+  const [profile, projectMemories, searchResults] = await Promise.all([
+    Promise.race([
+      client.getInjection(),
+      new Promise<null>((resolve) => setTimeout(() => resolve(null), 1000)),
+    ]).catch(() => null),
+    Promise.race([
+      client.listRecent(5, projectPath),
+      new Promise<never[]>((resolve) => setTimeout(() => resolve([]), 1000)),
+    ]).catch(() => []),
+    query
+      ? Promise.race([
+          client.searchMemories(query, 10, undefined, undefined, projectPath),
+          new Promise<never[]>((resolve) => setTimeout(() => resolve([]), 1500)),
+        ]).catch(() => [])
+      : Promise.resolve([]),
+  ]);
+
+  const sections: string[] = ["[CEREBRO-MEMORY]", ""];
+
+  if (profile?.content) {
+    sections.push(profile.content);
+    sections.push("");
+  }
+
+  const seenIds = new Set<string>();
+
+  if (projectMemories.length > 0) {
+    sections.push("## Recent Project Activity");
+    for (const m of projectMemories) {
+      seenIds.add(m.id);
+      const age = formatRelativeAge(m.updated_at || m.created_at) || "unknown";
+      const content = truncate(m.content, 200);
+      sections.push(`- (${age}) ${content}`);
+    }
+    sections.push("");
+  }
+
+  const dedupedResults = (searchResults || []).filter((r) => !seenIds.has(r.memory.id));
+  if (dedupedResults.length > 0) {
+    sections.push("## Relevant Memories");
+    for (const r of dedupedResults) {
+      const age = formatRelativeAge(r.memory.created_at) || "unknown";
+      const content = truncate(r.memory.content, 300);
+      sections.push(`- (${age}) ${content}`);
+    }
+    sections.push("");
+  }
+
+  sections.push("[/CEREBRO-MEMORY]");
+
+  let text = sections.join("\n");
+  if (text.length > maxChars) {
+    const cutoff = text.lastIndexOf('\n', maxChars);
+    text = text.slice(0, cutoff > 0 ? cutoff : maxChars) + "\n…\n[/CEREBRO-MEMORY]";
   }
 
   return {
-    text: [
-      "<cerebro-context>",
-      "",
-      ...sections,
-      "</cerebro-context>",
-    ].join("\n"),
-    injectedMemoryIds: results.map((r) => r.memory.id),
-    injectedCount: results.length,
+    text,
+    profileCount: profile?.preference_count ?? 0,
+    memoryCount: dedupedResults?.length ?? 0,
+    projectMemoryCount: projectMemories.length,
   };
 }
 
-export function autoRecallHook(client: CerebroClient, containerTags: string[], tui: any, config: Partial<OmemPluginConfig> = {}, getAgentName?: () => string, directory?: string) {
-  const similarityThreshold = config.recall?.similarityThreshold ?? 0.4;
-  const maxRecallResults = config.recall?.maxRecallResults ?? 10;
-  const fetchMultiplier = config.recall?.fetchMultiplier ?? 3;
-  const topkCapMultiplier = config.recall?.topkCapMultiplier ?? 2;
-  const mmrJaccardThreshold = config.recall?.mmrJaccardThreshold ?? 0.85;
-  const mmrPenaltyFactor = config.recall?.mmrPenaltyFactor ?? 0.5;
-  const phase2Multiplier = config.recall?.phase2Multiplier ?? 2;
-  const llmMaxEval = config.recall?.llmMaxEval ?? 15;
-  const refineStrategy = config.recall?.refineStrategy ?? "balanced";
-  const maxContentLength = Math.max(MIN_CONTENT_LENGTH, config.content?.maxContentLength ?? 500);
-  const maxContentChars = Math.max(MIN_CONTENT_CHARS, config.content?.maxContentChars ?? 30000);
-  const toastDelayMs = config.ui?.toastDelayMs ?? 7000;
+const injectedSessions = new Set<string>();
 
+export function chatMessageRecallHook(
+  client: CerebroClient,
+  _containerTags: string[],
+  tui: any,
+  config: Partial<OmemPluginConfig> = {},
+  getAgentName?: () => string,
+  directory?: string,
+) {
   return async (
-    input: { sessionID?: string; model: Model },
-    output: { system: string[] },
+    input: { sessionID: string; messageID?: string },
+    output: { message: UserMessage; parts: Part[] },
   ) => {
     if (!input.sessionID) return;
+    if (injectedSessions.has(input.sessionID)) return;
 
-    // 5a: agent memory policy check — skip recall entirely for 'none' agents
     const agentId = getAgentName?.() || process.env.OMEM_AGENT_ID || "opencode";
     const policy = resolveAgentPolicy(agentId, config);
-    if (policy === "none") return;
-
-    try {
-      logDebug("autoRecallHook start", { sessionId: input.sessionID, agentId, policy, similarityThreshold, maxRecallResults, fetchMultiplier, topkCapMultiplier, mmrJaccardThreshold, mmrPenaltyFactor, phase2Multiplier, llmMaxEval, refineStrategy });
-      const messages = sessionMessages.get(input.sessionID) ?? [];
-      const userMessages = messages.filter((m) => m.role === "user");
-
-      const prevCount = lastUserMsgCount.get(input.sessionID) ?? 0;
-      if (userMessages.length <= prevCount) {
-        logDebug("autoRecallHook skipped: no new user message", { sessionId: input.sessionID, prevCount, currentCount: userMessages.length });
-        return;
-      }
-      lastUserMsgCount.set(input.sessionID, userMessages.length);
-
-      // --- Profile Fetch (V2 inject API with TTL gate + module-level cache) ---
-      const profileTtlMs = config.profile?.ttlMs ?? 300000; // default 5 minutes
-      const lastInjected = profileInjectedSessions.get(input.sessionID);
-      const profileTtlExpired = !lastInjected || (Date.now() - lastInjected > profileTtlMs);
-
-      let profileBlock = "";
-      let profileCountText = "";
-
-      if (profileTtlExpired) {
-        const maxRetries = 2;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-          try {
-            const injection = await client.getInjection(directory || process.env.OMEM_PROJECT_DIR);
-            if (injection?.content) {
-              profileBlock = injection.content;
-              profileCountText = `${injection.preference_count} preferences`;
-              profileInjectedSessions.set(input.sessionID, Date.now());
-              lastProfileBlock.set(input.sessionID, { content: profileBlock, count: injection.preference_count });
-              logDebug("autoRecallHook profile fetched (V2 injection)", { preferenceCount: injection.preference_count, estimatedTokens: injection.estimated_tokens });
-            }
-            break;
-          } catch (e) {
-            if (attempt < maxRetries) {
-              logDebug("autoRecallHook getInjection retry", { attempt: attempt + 1, error: String(e) });
-            } else {
-              logErr("autoRecallHook getInjection failed after retries", { error: String(e) });
-              showToast(tui, "⚠️ Profile Inject Failed", "Preference injection skipped · will retry next turn", "error", toastDelayMs);
-            }
-          }
-        }
-      } else {
-        // TTL 未过期 — 从缓存恢复 profile 内容
-        const cached = lastProfileBlock.get(input.sessionID);
-        if (cached) {
-          profileBlock = cached.content;
-          profileCountText = `${cached.count} preferences`;
-          logDebug("autoRecallHook profile restored from cache", { preferenceCount: cached.count, contentLen: cached.content.length });
-        }
-      }
-
-      // After compacting, sessionMessages is cleared but firstMessages gets repopulated
-      // by keywordDetectionHook with compact summary — skip recall in this transient state
-      if (userMessages.length === 0) {
-        logDebug("autoRecallHook skipped: no user messages in session (post-compacting?)", { sessionId: input.sessionID });
-        return;
-      }
-
-      const rawQuery = userMessages[userMessages.length - 1]?.content || firstMessages.get(input.sessionID) || "";
-      const query_text = extractUserRequest(rawQuery);
-      if (!query_text) {
-        logDebug("autoRecallHook filtered system injection (profile already injected above)", { rawQueryPrefix: rawQuery.slice(0, 60) });
-        return;
-      }
-      const last_query_text = userMessages.length >= 2 ? userMessages[userMessages.length - 2].content : undefined;
-
-      const projectTags = containerTags.filter(t => t.startsWith("omem_project_"));
-
-      const conversationContext = userMessages.length >= 2
-        ? userMessages.slice(-4, -1).map((m) => {
-          const stripped = stripPrivateContent(m.content);
-          return stripped.length > 200 ? stripped.slice(0, 200) : stripped;
-        })
-        : undefined;
-
-      const shouldRecallRes = await client.shouldRecall(
-        query_text, last_query_text, input.sessionID,
-        similarityThreshold, maxRecallResults,
-        projectTags.length > 0 ? projectTags : undefined,
-        conversationContext && conversationContext.length > 0 ? conversationContext : undefined,
-        {
-          fetch_multiplier: fetchMultiplier,
-          topk_cap_multiplier: topkCapMultiplier,
-          mmr_jaccard_threshold: mmrJaccardThreshold,
-          mmr_penalty_factor: mmrPenaltyFactor,
-          phase2_multiplier: phase2Multiplier,
-          llm_max_eval: llmMaxEval,
-          refine_strategy: refineStrategy,
-        },
-        directory || process.env.OMEM_PROJECT_DIR,
-      );
-
-      if (!shouldRecallRes) {
-        showToast(tui, "🧠 Cerebro Service Unavailable", "Unable to reach memory API · check connection", "error", toastDelayMs);
-        return;
-      }
-      logDebug("autoRecallHook shouldRecall result", { shouldRecall: shouldRecallRes.should_recall, confidence: shouldRecallRes.confidence, memCount: shouldRecallRes.memories?.length ?? 0, discardedCount: shouldRecallRes.discarded?.length ?? 0 });
-
-      const storedMemoryIds = shouldRecallRes.memories?.map((r) => r.memory.id) ?? [];
-      const storedDiscardedIds = shouldRecallRes.discarded?.map((d) => d.memory_id) ?? [];
-      const maxScore = storedMemoryIds.length > 0
-        ? Math.max(...(shouldRecallRes.memories?.map((r) => r.score) ?? [0]))
-        : 0;
-
-      const createEventAndReturn = async (
-        opts: {
-          injectedContent?: string;
-          actualProfileInjected: boolean;
-          actualProfileContent?: string;
-          actualInjectedCount: number;
-          injectedMemoryIds: string[];
-          keptCount: number;
-          discardedCount: number;
-        },
-      ): Promise<string | undefined> => {
-        try {
-          const items = [
-                ...(shouldRecallRes.memories?.map((r) => ({
-                  memory_id: r.memory.id,
-                  score: r.score,
-                  refine_relevance: r.refine_relevance,
-                  refine_reasoning: r.refine_reasoning,
-                  is_kept: opts.injectedMemoryIds.includes(r.memory.id),
-                })) ?? []),
-                ...(shouldRecallRes.discarded?.map((d) => ({
-                  memory_id: d.memory_id,
-                  score: d.score,
-                  refine_relevance: d.refine_relevance,
-                  refine_reasoning: d.refine_reasoning,
-                  is_kept: false,
-                })) ?? []),
-              ];
-          const result = await client.createRecallEvent({
-            session_id: input.sessionID!,
-            recall_type: "auto",
-            query_text,
-            max_score: maxScore,
-            llm_confidence: shouldRecallRes.confidence ?? 0,
-            profile_injected: opts.actualProfileInjected,
-            kept_count: opts.keptCount,
-            discarded_count: opts.discardedCount,
-            injected_count: opts.actualInjectedCount,
-            profile_content: opts.actualProfileContent,
-            injected_content: opts.injectedContent,
-            items: items.length > 0 ? items : undefined,
-          });
-          return result?.event_id;
-        } catch (e) {
-          logErr("autoRecallHook createRecallEvent failed", { error: String(e) });
-          return undefined;
-        }
-      };
-
-      if (!shouldRecallRes.should_recall) {
-        if (profileTtlExpired && profileBlock) {
-          appendToSystem(output.system, profileBlock);
-          logDebug("autoRecallHook profile injected (no-recall path)", { sessionId: input.sessionID, outputSystemLength: output.system.length });
-
-          createEventAndReturn({
-            keptCount: 0,
-            discardedCount: 0,
-            actualProfileInjected: true,
-            actualProfileContent: profileBlock,
-            actualInjectedCount: 0,
-            injectedMemoryIds: [],
-          });
-
-          showToast(tui, "👨 Profile Injected", `${profileCountText} · no recall needed`, "success", toastDelayMs);
-        }
-        return;
-      }
-
-      const results = shouldRecallRes.memories ?? [];
-
-      // --- Token Budget Calculation ---
-      const profileChars = profileBlock ? profileBlock.length : 0;
-      const budgetRemaining = maxContentChars - profileChars;
-      if (budgetRemaining < 0) {
-        logDebug("autoRecallHook budget overflow", { profileChars, maxContentChars, deficit: -budgetRemaining });
-      }
-      logDebug("autoRecallHook budget", { 
-        maxContentChars, profileChars, budgetRemaining,
-        configuredMax: maxContentLength,
-      });
-
-      const ctxResult = buildContextBlock(results, budgetRemaining, maxContentLength, MIN_ITEM_CONTENT_CHARS);
-      if (ctxResult.text) {
-        appendToSystem(output.system, ctxResult.text);
-        appendToSystem(output.system, FETCH_POLICY);
-        logDebug("autoRecallHook block injected to output.system", {
-          sessionId: input.sessionID,
-          blockPreview: ctxResult.text.slice(0, 200),
-          outputSystemLength: output.system.length,
-        });
-      } else {
-        logDebug("autoRecallHook block was EMPTY — no injection", { sessionId: input.sessionID });
-      }
-
-      if (profileTtlExpired && profileBlock) {
-        appendToSystem(output.system, profileBlock);
-        logDebug("autoRecallHook profile injected after context", { sessionId: input.sessionID, outputSystemLength: output.system.length });
-      }
-
-      logDebug("autoRecallHook injection complete", { sessionId: input.sessionID });
-
-      const didInjectProfile = !!profileBlock;
-      const didInjectContext = !!ctxResult.text;
-
-      createEventAndReturn({
-        keptCount: ctxResult.injectedCount,
-        discardedCount: storedDiscardedIds.length,
-        injectedContent: didInjectContext ? ctxResult.text : undefined,
-        actualProfileInjected: didInjectProfile,
-        actualProfileContent: profileBlock || undefined,
-        actualInjectedCount: ctxResult.injectedCount,
-        injectedMemoryIds: ctxResult.injectedMemoryIds,
-      });
-
-      // --- Toast (every branch shows toast) ---
-      if (didInjectProfile && didInjectContext) {
-        showToast(tui, "🧠 Context + Profile Injected", `${profileCountText} · recall active`, "success", toastDelayMs);
-      } else if (didInjectProfile) {
-        showToast(tui, "👨 Profile Injected", `${profileCountText} · no recall needed`, "success", toastDelayMs);
-      } else if (didInjectContext) {
-        showToast(tui, "🧠 Context Injected", `Recall active · profile cached`, "success", toastDelayMs);
-      } else {
-        showToast(tui, "🧠 Cerebro", "profile cached · no recall needed", "info", toastDelayMs);
-      }
-
-      if (saveKeywordDetectedSessions.has(input.sessionID)) {
-        appendToSystem(output.system, KEYWORD_NUDGE);
-        saveKeywordDetectedSessions.delete(input.sessionID);
-      }
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      if (errMsg.includes("[cerebro]")) {
-        // Server returned error (500, etc.) with details
-        const cleanMsg = errMsg.replace(/^\[cerebro\]\s*/, "");
-        if (cleanMsg.startsWith("500")) {
-          showToast(tui, "🧠 Cerebro Server Error", cleanMsg.substring(0, 200), "error");
-        } else if (cleanMsg.includes("timed out")) {
-          showToast(tui, "🧠 Cerebro Service Timeout", cleanMsg.substring(0, 100), "error");
-        } else {
-          showToast(tui, "🧠 Cerebro Error", cleanMsg.substring(0, 150), "error");
-        }
-      } else if (errMsg.includes("fetch") || errMsg.includes("network")) {
-        showToast(tui, "🧠 Cerebro Service Unavailable", "Network error · check API connection", "error");
-      } else {
-        showToast(tui, "🧠 Memory Recall Error", errMsg.substring(0, 100), "error");
-      }
+    if (policy === "none") {
+      injectedSessions.add(input.sessionID);
+      return;
     }
-  };
-}
 
-export function keywordDetectionHook(_client: CerebroClient, _containerTags: string[], threshold: number, _tui: any, _ingestMode: "smart" | "raw" = "smart", config: Partial<OmemPluginConfig> = {}, agentId?: string) {
-  const effectiveAgentId = agentId || process.env.OMEM_AGENT_ID || "opencode";
-  return async (
-    input: { sessionID: string; messageID?: string },
-    output: { message: UserMessage; parts: Part[] },
-  ) => {
     const textContent = output.parts
-      .filter((p): p is any => p.type === "text")
-      .map((p) => (p as any).text || (p as any).content || "")
+      .filter((p: any) => p.type === "text")
+      .map((p: any) => p.text || (p as any).content || "")
       .join(" ")
       || (output.message as any).content
       || "";
 
-    if (!firstMessages.has(input.sessionID)) {
-      firstMessages.set(input.sessionID, textContent);
-    }
-
-    if (detectSaveKeyword(textContent)) {
-      saveKeywordDetectedSessions.add(input.sessionID);
-      logDebug("keywordDetectionHook triggered", { sessionId: input.sessionID });
-    }
+    const query = extractUserRequest(textContent);
 
-    const policy = resolveAgentPolicy(effectiveAgentId, config);
-    if (policy === "none") {
+    const TRIVIAL_PATTERNS = /^(hi|hello|hey|你好|嗨|嗯|ok|okay|好的|收到|\s*)$/i;
+    if (!query || TRIVIAL_PATTERNS.test(query.trim())) {
+      logDebug("chatMessageRecallHook: trivial query, will retry next turn", { sessionId: input.sessionID });
       return;
     }
 
-    if (!sessionMessages.has(input.sessionID)) {
-      sessionMessages.set(input.sessionID, []);
-    }
-    sessionMessages.get(input.sessionID)!.push({
-      role: "user",
-      content: textContent,
-    });
-
-    const messages = sessionMessages.get(input.sessionID)!;
-    if (messages.length >= threshold) {
-      // Threshold reached — messages will be processed on next session.idle
+    try {
+      const injection = await buildMemoryInjection(client, directory, query, config);
+
+      const hasContent = (injection.profileCount ?? 0) > 0
+        || (injection.memoryCount ?? 0) > 0
+        || (injection.projectMemoryCount ?? 0) > 0;
+
+      if (injection.text && hasContent && injection.text.length > 20) {
+        injectedSessions.add(input.sessionID);
+
+        output.parts.unshift({
+          type: "text",
+          text: injection.text,
+          synthetic: true,
+        } as any);
+
+        showToast(tui, "🧠 Memory Injected",
+          `${injection.profileCount} prefs · ${injection.projectMemoryCount} project · ${injection.memoryCount} relevant`,
+          "success");
+
+        client.createRecallEvent({
+          session_id: input.sessionID,
+          recall_type: "auto",
+          query_text: query,
+          max_score: 0,
+          llm_confidence: 0,
+          profile_injected: injection.profileCount > 0,
+          kept_count: injection.projectMemoryCount + injection.memoryCount,
+          discarded_count: 0,
+          injected_count: injection.projectMemoryCount + injection.memoryCount,
+          injected_content: injection.text,
+        }).catch((e: unknown) => {
+          logErr("chatMessageRecallHook createRecallEvent failed", { error: String(e) });
+        });
+      } else if (!hasContent) {
+        logDebug("chatMessageRecallHook: no content available, will retry next turn", {
+          sessionId: input.sessionID,
+          profileCount: injection.profileCount,
+          memoryCount: injection.memoryCount,
+          projectMemoryCount: injection.projectMemoryCount,
+        });
+        showToast(tui, "🧠 Memory Unavailable", "API timeout or no memories yet", "warning");
+      }
+    } catch (err) {
+      logErr("chatMessageRecallHook failed", { error: String(err) });
+      showToast(tui, "🧠 Memory Injection Failed", "Check connection", "error");
     }
   };
 }
@@ -778,6 +539,8 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
       profileInjectedSessions.delete(input.sessionID);
       lastUserMsgCount.delete(input.sessionID);
       firstMessages.delete(input.sessionID);
+      processedMessageIds.delete(input.sessionID);
+      injectedSessions.delete(input.sessionID);
       if (input.sessionID) {
         logDebug("compactingHook cleared session state", { sessionID: input.sessionID });
       }
@@ -787,6 +550,8 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
     if (input.sessionID) {
       profileInjectedSessions.delete(input.sessionID);
       lastUserMsgCount.delete(input.sessionID);
+      processedMessageIds.delete(input.sessionID);
+      injectedSessions.delete(input.sessionID);
       logDebug("compactingHook cleared profile TTL for re-injection", { sessionID: input.sessionID });
     }
   };
@@ -902,7 +667,7 @@ export function autocontinueHook(
   };
 }
 
-const processedMessageIds = new Set<string>();
+const processedMessageIds = new Map<string, Set<string>>();
 const pluginStartTime = Date.now();
 
 export function sessionIdleHook(
@@ -1071,7 +836,11 @@ export function sessionIdleHook(
 
         for (const msg of messages) {
           const msgId = msg.info?.id;
-          if (!msgId || processedMessageIds.has(msgId)) continue;
+          if (!msgId) continue;
+          if (!processedMessageIds.has(sessionID)) {
+            processedMessageIds.set(sessionID, new Set());
+          }
+          if (processedMessageIds.get(sessionID)!.has(msgId)) continue;
 
           const msgTime = msg.info?.createdAt ? new Date(msg.info.createdAt).getTime() : 0;
           if (msgTime > 0 && msgTime < pluginStartTime) continue;
@@ -1131,7 +900,7 @@ export function sessionIdleHook(
           await cerebroClient.sessionIngest(conversationMessages, sessionID, effectiveAgentId, sessionTitle, projectName, projectPath);
           logInfo("sessionIdleHook sessionIngest ok");
           for (const id of newMessageIds) {
-            processedMessageIds.add(id);
+            processedMessageIds.get(sessionID)!.add(id);
           }
           showToast(tui, "🧠 Memory Sealed", `${conversationMessages.length} dialogues captured · entrusted to the heavens for refinement`, "success");
         } catch (err) {

package/src/index.ts

@@ -5,11 +5,12 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import type { Server } from "node:http";
 import { CerebroClient } from "./client.js";
-import { autoRecallHook, autocontinueHook, compactingHook, keywordDetectionHook, sessionIdleHook, showToast as hooksShowToast } from "./hooks.js";
+import { chatMessageRecallHook, autocontinueHook, compactingHook, sessionIdleHook, showToast as hooksShowToast, sessionMessages, firstMessages } from "./hooks.js";
+import { detectSaveKeyword, detectRecallKeyword, KEYWORD_NUDGE, RECALL_NUDGE } from "./keywords.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logDebug, logError } from "./logger.js";
-import { loadPluginConfig } from "./config.js";
+import { loadPluginConfig, resolveAgentPolicy } from "./config.js";
 import { startWebServer, stopWebServer } from "./web-server.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -103,7 +104,7 @@ const OmemPlugin: Plugin = async (input) => {
   let mainSessionLocked = false;
   let cachedAgentName: string | undefined;
 
-  const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
+  const chatMessageRecall = chatMessageRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
 
   let webServer: Server | null = null;
   const webEnabled = config.web?.enabled !== false;
@@ -125,13 +126,17 @@ const OmemPlugin: Plugin = async (input) => {
   }
 
   const shutdown = async () => {
-    if (webServer) {
-      await stopWebServer(webServer);
-      webServer = null;
-    }
+    try {
+      if (webServer) {
+        await stopWebServer(webServer);
+        webServer = null;
+      }
+    } catch {}
+    process.exit(0);  // 强制退出，确保 HTTP server 停止
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
+  process.on("disconnect", shutdown);  // OpenCode 窗口关闭时触发
 
   return {
     config: async (cfg: any) => {
@@ -141,16 +146,46 @@ const OmemPlugin: Plugin = async (input) => {
         description: "Toggle Cerebro auto-store ON or OFF for current session",
       };
     },
-    "experimental.chat.system.transform": async (input: any, output: any) => {
-      logDebug("transform input", { sessionID: input.sessionID });
+    "chat.message": async (input: any, output: any) => {
       if (input.sessionID && !mainSessionLocked) {
         mainSessionId = input.sessionID;
         mainSessionLocked = true;
         logInfo("mainSessionId locked", { sessionId: input.sessionID });
       }
-      return recallHook(input, output);
+      await chatMessageRecall(input, output);
+      const textContent = output.parts
+        .filter((p: any) => p.type === "text" && !(p as any).synthetic)
+        .map((p: any) => p.text || (p as any).content || "")
+        .join(" ")
+        || (output.message as any).content
+        || "";
+      if (!firstMessages.has(input.sessionID)) {
+        firstMessages.set(input.sessionID, textContent);
+      }
+      if (detectSaveKeyword(textContent)) {
+        output.parts.push({
+          type: "text",
+          text: KEYWORD_NUDGE,
+          synthetic: true,
+        } as any);
+        logDebug("keyword nudge pushed via parts.push", { sessionId: input.sessionID });
+      }
+      if (detectRecallKeyword(textContent)) {
+        output.parts.push({
+          type: "text",
+          text: RECALL_NUDGE,
+          synthetic: true,
+        } as any);
+        logDebug("recall nudge pushed via parts.push", { sessionId: input.sessionID });
+      }
+      const policy = resolveAgentPolicy(agentId, config);
+      if (policy !== "none") {
+        if (!sessionMessages.has(input.sessionID)) {
+          sessionMessages.set(input.sessionID, []);
+        }
+        sessionMessages.get(input.sessionID)!.push({ role: "user", content: textContent });
+      }
     },
-    "chat.message": keywordDetectionHook(cerebroClient, containerTags, config.ingest.autoCaptureThreshold, tui, config.ingest.ingestMode, config, agentId),
     "experimental.session.compacting": compactingHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId, directory),
     "experimental.compaction.autocontinue": autocontinueHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId, directory),
     tool: buildTools(cerebroClient, containerTags, { agentId, getSessionId: () => mainSessionId, getAgentName: () => cachedAgentName || agentId, getProjectPath: () => directory }),

package/src/keywords.ts

@@ -1,16 +1,23 @@
 const SAVE_KEYWORDS: readonly string[] = [
-  "remember",
-  "save this",
-  "don't forget",
-  "keep in mind",
-  "note that",
-  "store this",
-  "memorize",
-  "记住",
-  "记一下",
-  "保存",
-  "记下来",
-  "别忘了",
+  "remember", "save this", "don't forget",
+  "记住", "记一下", "保存", "记下来", "别忘了",
+  "memory_store",
+] as const;
+
+const RECALL_KEYWORDS: readonly string[] = [
+  // English — explicit past-conversation references
+  "i remember", "i recall", "we discussed", "we talked about",
+  "last time", "earlier we", "previously", "before we",
+  "look up", "find that", "search for", "check what",
+  "what did we", "do you remember", "from our previous", "as discussed",
+  // Chinese — explicit memory recall cues
+  "我记得", "之前说过", "之前聊过", "上次说的",
+  "之前讨论", "我记得之前", "查一下", "搜一下", "找一下",
+  "之前提到", "记得吗", "你还记得", "回忆一下",
+  "上次那个", "之前那个", "上次讨论", "上次做的",
+  "之前记录", "之前保存", "上次决定", "之前约定",
+  // Direct tool references
+  "memory_search", "memory_get",
 ] as const;
 
 export function detectSaveKeyword(text: string): boolean {
@@ -18,6 +25,13 @@ export function detectSaveKeyword(text: string): boolean {
   return SAVE_KEYWORDS.some((kw) => lower.includes(kw));
 }
 
+export function detectRecallKeyword(text: string): boolean {
+  const lower = text.toLowerCase();
+  return RECALL_KEYWORDS.some((kw) => lower.includes(kw));
+}
+
 export const KEYWORD_NUDGE =
-  "The user appears to want you to remember something. " +
-  "Consider using the `memory_store` tool to save this information for future reference.";
+  "[cerebro] The user wants you to remember this. Use the `memory_store` tool to save it now.";
+
+export const RECALL_NUDGE =
+  "[cerebro] The user references past conversations or stored information. Use `memory_search` with keywords from their message to retrieve relevant memories before responding.";