@mingxy/cerebro 1.14.6 → 1.15.2

package/src/hooks.ts

@@ -130,7 +130,7 @@ function showToast(tui: any, title: string, message: string, variant: string = "
     try {
       tui.showToast({ body: { title, message, variant, duration: 5000 } });
     } catch (err) {
-      console.error("[cerebro] showToast failed:", err);
+      logErr("showToast failed", { error: String(err) });
     }
   }, delayMs);
 }
@@ -172,6 +172,18 @@ const injectedMemoryIds = new Map<string, Set<string>>();
 const firstMessages = new Map<string, string>();
 const sessionMessages = new Map<string, Array<{ role: string; content: string }>>();
 const profileInjectedSessions = new Map<string, number>();
+const injectedSessions = new Set<string>();
+const compactingSummaryCooldown = new Map<string, number>();
+
+function hashString(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash |= 0;
+  }
+  return hash.toString(36);
+}
 
 function formatRelativeAge(isoDate: string): string {
   const diffMs = Date.now() - new Date(isoDate).getTime();
@@ -236,7 +248,9 @@ function formatMemoryLine(r: SearchResult, maxContentLength: number): string {
 
 const FETCH_POLICY = [
   "<cerebro-fetch-policy>",
-  "Each memory above is a condensed summary with a retrievable ID. memory_get(\"id\") unlocks the full content — your knowledge depth control. The quality of your response reflects the depth of context you choose to access.",
+  "IMPORTANT: Each memory above is a condensed summary. The full version contains critical details that may change your response quality.",
+  "You MUST use memory_get(\"id\") to retrieve the complete content, or memory_search(\"query\") to find specific memories before making decisions based on any summary.",
+  "Do NOT rely on condensed summaries alone — depth of recall determines quality of response.",
   "</cerebro-fetch-policy>",
 ].join("\n");
 
@@ -601,6 +615,348 @@ export function autoRecallHook(client: CerebroClient, containerTags: string[], t
   };
 }
 
+export function memoryInjectionHook(
+  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 refineMediumChars = config.recall?.refineMediumChars ?? 200;
+  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;
+
+  return async (
+    input: { sessionID?: string; messageID?: string; model: Model },
+    output: { message: UserMessage; parts: Part[] },
+  ) => {
+    if (!input.sessionID) return;
+
+    const agentId = getAgentName?.() || process.env.OMEM_AGENT_ID || "opencode";
+    const policy = resolveAgentPolicy(agentId, config);
+    if (policy === "none") return;
+
+    const isFirstInjection = !injectedSessions.has(input.sessionID);
+    const isKeywordTriggered = keywordDetectedSessions.has(input.sessionID);
+    if (!isFirstInjection && !isKeywordTriggered) return;
+
+    try {
+      logDebug("memoryInjectionHook start", { sessionId: input.sessionID, agentId, policy, isFirstInjection, isKeywordTriggered, similarityThreshold, maxRecallResults });
+      const messages = sessionMessages.get(input.sessionID) ?? [];
+      const userMessages = messages.filter((m) => m.role === "user");
+
+      // --- Profile Fetch ---
+      const profile = await client.getProfile();
+      let profileInjected = false;
+      let profileCountText = "";
+      let profileBlock = "";
+      const lastInjected = profileInjectedSessions.get(input.sessionID);
+      const ttlExpired = !lastInjected || (Date.now() - lastInjected > 30 * 60 * 1000);
+      const profileIsFirstInjection = !lastInjected;
+      if (profile && ttlExpired) {
+        const prefs = ((profile as any)?.static_facts ?? [])
+          .filter((sf: any) => {
+            const t: string[] = sf.tags ?? [];
+            return t.includes("preferences");
+          })
+          .map((sf: any) => sf.l2_content ?? sf.content ?? "")
+          .filter(Boolean);
+        const profileLines = prefs.length > 0
+          ? prefs.map((c: string) => `  · ${c}`).join("\n")
+          : "  · (preferences queuing, will populate on next refresh)";
+        profileBlock = [
+          "<cerebro-profile>",
+          profileLines,
+          "</cerebro-profile>",
+        ].join("\n");
+        profileInjected = true;
+        profileInjectedSessions.set(input.sessionID, Date.now());
+        const p = profile as any;
+        const dynamicCount = p?.dynamic_context?.length ?? 0;
+        const staticCount = p?.static_facts?.length ?? 0;
+        profileCountText = `Dynamic(${dynamicCount}) · Static(${staticCount})`;
+        if (profileIsFirstInjection) {
+          logDebug("memoryInjectionHook profile ready (first)", { dynamicCount, staticCount });
+        } else {
+          logDebug("memoryInjectionHook profile ready (TTL)", { dynamicCount, staticCount });
+        }
+      }
+
+      if (userMessages.length === 0) {
+        logDebug("memoryInjectionHook 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("memoryInjectionHook 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,
+          refine_medium_chars: refineMediumChars,
+        },
+        directory || process.env.OMEM_PROJECT_DIR,
+      );
+
+      if (!shouldRecallRes) {
+        showToast(tui, "🧠 Cerebro Service Unavailable", "Unable to reach memory API · check connection", "error", toastDelayMs);
+        return;
+      }
+      logDebug("memoryInjectionHook shouldRecall result", { shouldRecall: shouldRecallRes.should_recall, confidence: shouldRecallRes.confidence, memCount: shouldRecallRes.memories?.length ?? 0, discardedCount: shouldRecallRes.discarded?.length ?? 0, clustered: !!shouldRecallRes.clustered });
+
+      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 (
+        injectedCount: number,
+        keptCount: number,
+        discardedCount: number,
+        injectedContent?: string,
+      ): 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: true,
+            })) ?? []),
+            ...(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: profileInjected,
+            kept_count: keptCount,
+            discarded_count: discardedCount,
+            injected_count: injectedCount,
+            profile_content: profileInjected && profileBlock ? profileBlock : undefined,
+            injected_content: injectedContent,
+            items: items.length > 0 ? items : undefined,
+          });
+          return result?.event_id;
+        } catch (e) {
+          logErr("memoryInjectionHook createRecallEvent failed", { error: String(e) });
+          return undefined;
+        }
+      };
+
+      // --- no-recall path: inject profile only ---
+      if (!shouldRecallRes.should_recall) {
+        const partsToInject: string[] = [];
+        if (profileBlock) partsToInject.push(profileBlock);
+        if (partsToInject.length > 0) {
+          const injectText = partsToInject.join("\n\n");
+          const contextPart: Part = {
+            id: `prt_cerebro-context-${Date.now()}`,
+            sessionID: input.sessionID,
+            messageID: output.message.id,
+            type: "text",
+            text: injectText,
+            synthetic: true,
+          };
+          output.parts.unshift(contextPart);
+          logDebug("memoryInjectionHook profile injected (no-recall path)", { sessionId: input.sessionID });
+        }
+        injectedSessions.add(input.sessionID);
+        if (profileInjected && profileIsFirstInjection) {
+          await createEventAndReturn(0, 0, 0);
+          showToast(tui, "👨 Profile Injected", `${profileCountText} · no memory recall needed`, "success", toastDelayMs);
+        }
+        return;
+      }
+
+      const results = shouldRecallRes.memories ?? [];
+      const clustered = shouldRecallRes.clustered;
+
+      const existingIds = injectedMemoryIds.get(input.sessionID) ?? new Set<string>();
+      const newResults = results.filter((r) => !existingIds.has(r.memory.id));
+      logDebug("memoryInjectionHook dedup", { totalResults: results.length, existingCount: existingIds.size, newCount: newResults.length });
+
+      // --- dedup path: inject profile only ---
+      if (newResults.length === 0) {
+        const partsToInject: string[] = [];
+        if (profileBlock) partsToInject.push(profileBlock);
+        if (partsToInject.length > 0) {
+          const injectText = partsToInject.join("\n\n");
+          const contextPart: Part = {
+            id: `prt_cerebro-context-${Date.now()}`,
+            sessionID: input.sessionID,
+            messageID: output.message.id,
+            type: "text",
+            text: injectText,
+            synthetic: true,
+          };
+          output.parts.unshift(contextPart);
+          logDebug("memoryInjectionHook profile injected (dedup path)", { sessionId: input.sessionID });
+        }
+        injectedSessions.add(input.sessionID);
+        if (profileInjected && profileIsFirstInjection) {
+          showToast(tui, "👨 Profile Injected", `${profileCountText} · all memories already injected`, "success", toastDelayMs);
+        }
+        return;
+      }
+
+      // --- Token Budget Calculation ---
+      const profileChars = profileInjected ? profileBlock.length : 0;
+      const budgetRemaining = maxContentChars - profileChars;
+      if (budgetRemaining < 0) {
+        logDebug("memoryInjectionHook budget overflow", { profileChars, maxContentChars, deficit: -budgetRemaining });
+      }
+      const itemCount = clustered
+        ? (clustered.cluster_summaries.length + clustered.standalone_memories.length)
+        : newResults.length;
+      const dynamicMaxContentLength = itemCount > 0
+        ? Math.min(maxContentLength, Math.max(MIN_ITEM_CONTENT_CHARS, Math.floor(budgetRemaining / itemCount)))
+        : maxContentLength;
+      logDebug("memoryInjectionHook budget", {
+        maxContentChars, profileChars, budgetRemaining, itemCount,
+        configuredMax: maxContentLength, dynamicMax: dynamicMaxContentLength,
+      });
+
+      const block = clustered
+        ? buildClusteredContextBlock(clustered, dynamicMaxContentLength)
+        : buildContextBlock(newResults, dynamicMaxContentLength);
+
+      // ★★★ Core change: inject via output.parts.unshift + synthetic:true ★★★
+      const partsToInject: string[] = [];
+      if (profileBlock) partsToInject.push(profileBlock);
+      if (block) partsToInject.push(block);
+      if (block) partsToInject.push(FETCH_POLICY);
+      if (isKeywordTriggered) partsToInject.push(KEYWORD_NUDGE);
+
+      if (partsToInject.length > 0) {
+        const injectText = partsToInject.join("\n\n");
+        const contextPart: Part = {
+          id: `prt_cerebro-context-${Date.now()}`,
+          sessionID: input.sessionID,
+          messageID: output.message.id,
+          type: "text",
+          text: injectText,
+          synthetic: true,
+        };
+        output.parts.unshift(contextPart);
+        logDebug("memoryInjectionHook block injected to output.parts", {
+          sessionId: input.sessionID,
+          injectTextLen: injectText.length,
+          blockPreview: block?.slice(0, 200),
+        });
+      } else {
+        logDebug("memoryInjectionHook no content to inject", { sessionId: input.sessionID });
+      }
+
+      injectedSessions.add(input.sessionID);
+
+      if (isKeywordTriggered) {
+        keywordDetectedSessions.delete(input.sessionID);
+      }
+
+      const newIds = newResults.map((r) => r.memory.id);
+      injectedMemoryIds.set(input.sessionID, new Set([...existingIds, ...newIds]));
+      logDebug("memoryInjectionHook injection complete", { newIds: newIds.length, clustered: !!clustered, sessionId: input.sessionID });
+
+      await createEventAndReturn(newResults.length, storedMemoryIds.length, storedDiscardedIds.length, block || undefined);
+
+      const memDynamic = newResults.filter((r) => r.memory.memory_type === "fact" || r.memory.memory_type === "event").length;
+      const memStatic = newResults.filter((r) => r.memory.memory_type === "pinned" || r.memory.memory_type === "preference").length;
+      const memOther = newResults.length - memDynamic - memStatic;
+
+      let memCountMsg = "";
+      if (memDynamic > 0) memCountMsg += `Dynamic(${memDynamic}) `;
+      if (memStatic > 0) memCountMsg += `Static(${memStatic}) `;
+      if (memOther > 0) memCountMsg += `Other(${memOther}) `;
+
+      const categories = categorize(newResults);
+      const catSummary = Array.from(categories.entries())
+        .map(([label, items]) => `${label}(${items.length})`)
+        .join(" · ");
+
+      let toastTitle: string;
+      let toastMessage: string;
+
+      if (clustered) {
+        const clusterCount = clustered.cluster_summaries.length;
+        const standaloneCount = clustered.standalone_memories.length;
+        toastTitle = `🧠 Context Injected · ${clusterCount} 主题簇${standaloneCount > 0 ? ` · ${standaloneCount} 补充` : ""}`;
+        toastMessage = profileInjected
+          ? `Profile: ${profileCountText} · 聚合记忆展示`
+          : `聚合记忆展示`;
+      } else {
+        toastTitle = `🧠 Context Injected · ${newResults.length} fragments`;
+        toastMessage = profileInjected
+          ? `Profile: ${profileCountText} · Memories: ${memCountMsg.trim()}${catSummary ? ` · ${catSummary}` : ""}`
+          : `${memCountMsg.trim()}${catSummary ? ` · ${catSummary}` : ""}`;
+      }
+
+      showToast(tui, toastTitle, toastMessage, "success", toastDelayMs);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("[cerebro]")) {
+        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");
+      }
+    }
+  };
+}
+
 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 (
@@ -643,6 +999,57 @@ export function keywordDetectionHook(_client: CerebroClient, _containerTags: str
   };
 }
 
+export function createCerebroCompactionPrompt(
+  context: string[],
+  projectMemories: SearchResult[],
+): string {
+  const sections: string[] = [
+    "[Cerebro Compaction Context]",
+    "",
+    "## 1. User's Original Request",
+    "Preserve the user's verbatim original request from the conversation above.",
+    "",
+    "## 2. Final Goal",
+    "What is the ultimate objective the user wants to achieve?",
+    "",
+    "## 3. Work Completed",
+    "List all completed work with file paths and technical decisions made.",
+    "",
+    "## 4. Remaining Tasks",
+    "What is still unfinished or pending?",
+    "",
+    "## 5. Prohibited Actions",
+    "Key constraints and forbidden operations to remember.",
+    "",
+    "## 6. Existing Project Knowledge",
+  ];
+
+  if (projectMemories.length > 0) {
+    const memBlock = projectMemories
+      .slice(0, 10)
+      .map((r) => {
+        const content = r.memory.content ?? "";
+        const truncated = content.length > 200 ? content.slice(0, 200) + "..." : content;
+        return `  - [${r.memory.category ?? "general"}] ${truncated}`;
+      })
+      .join("\n");
+    sections.push(memBlock);
+  } else {
+    sections.push("  (No project memories retrieved)");
+  }
+
+  if (context.length > 0) {
+    sections.push("");
+    sections.push("### Additional Context");
+    sections.push(...context);
+  }
+
+  sections.push("");
+  sections.push("IMPORTANT: Output must preserve the user's original language (Chinese/English/etc). Do not translate.");
+
+  return sections.join("\n");
+}
+
 export function compactingHook(client: CerebroClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart", isAutoStoreEnabled?: (sessionId: string | undefined) => boolean, getMainSessionId?: () => string | undefined, sdkClient?: any, config: Partial<OmemPluginConfig> = {}, agentId?: string, directory?: string) {
   const effectiveAgentId = agentId || process.env.OMEM_AGENT_ID || "opencode";
   return async (
@@ -654,18 +1061,18 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
     // Search (read) always runs — even readonly agents need context during compacting
     try {
       const results = await client.searchMemories("*", 20, undefined, containerTags);
-      const block = buildContextBlock(results);
-      if (block) {
-        if (output.context.length > 0) {
-          output.context[output.context.length - 1] += "\n\n" + block;
-        } else {
-          output.context.push(block);
-        }
-        if (output.context.length > 0) {
-          output.context[output.context.length - 1] += "\n\n" + FETCH_POLICY;
-        } else {
-          output.context.push(FETCH_POLICY);
-        }
+      const compactionPrompt = createCerebroCompactionPrompt(output.context, results);
+      if (output.prompt !== undefined) {
+        output.prompt = compactionPrompt;
+      } else if (output.context.length > 0) {
+        output.context[output.context.length - 1] += "\n\n" + compactionPrompt;
+      } else {
+        output.context.push(compactionPrompt);
+      }
+      if (output.context.length > 0) {
+        output.context[output.context.length - 1] += "\n\n" + FETCH_POLICY;
+      } else {
+        output.context.push(FETCH_POLICY);
       }
       // 将compacting搜索结果的ID写入injectedMemoryIds，避免后续autoRecall重复注入
       if (input.sessionID && results.length > 0) {
@@ -870,9 +1277,19 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
                   logInfo("compactingHook: storing compact summary", {
                     summaryLen: summaryText.length, msgId: compactMsg.info?.id,
                   });
+                  // Dedup check: 30s cooldown per session+content hash
+                  const summaryHash = `${pollSessionId}:${hashString(summaryText)}`;
+                  const lastCompacting = compactingSummaryCooldown.get(summaryHash);
+                  if (lastCompacting && Date.now() - lastCompacting < 30000) {
+                    logDebug("compactingHook summary dedup", { sessionId: pollSessionId });
+                    break;
+                  }
+                  compactingSummaryCooldown.set(summaryHash, Date.now());
+
+                  const prefixedSummary = `[Session Summary] ${summaryText}`;
                   try {
                     const result = await client.ingestMessages(
-                      [{ role: "user" as const, content: summaryText }],
+                      [{ role: "user" as const, content: prefixedSummary }],
                       {
                         mode: ingestMode,
                         tags: [...containerTags, "auto-capture", "compact-summary"],
@@ -1064,9 +1481,9 @@ export function buildWhisperText(toolNames: string[], maxToolNames: number): str
   const lines: string[] = ["<cerebro-memory-activation>"];
 
   if (toolNames.length <= maxToolNames) {
-    lines.push(`Your ${toolNames.join(", ")} usage gets sharper with context. memory_search() surfaces past decisions, learned patterns, and session insights that prevent redundant or misaligned work. A moment of recall elevates every action.`);
+    lines.push(`Before using ${toolNames.join(", ")}, memory_search() may surface relevant past decisions or patterns. Brief recall → better outcomes.`);
   } else {
-    lines.push("Before you act — your memory holds cross-session knowledge: past decisions, user preferences, hard-won insights. memory_search() activates this advantage. The strongest responses are built on remembered context.");
+    lines.push("Before you act — memory_search() surfaces cross-session context: past decisions, user preferences, hard-won insights. The strongest responses are built on remembered context.");
   }
 
   lines.push("</cerebro-memory-activation>");

package/src/index.ts

@@ -4,7 +4,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { CerebroClient } from "./client.js";
-import { autoRecallHook, autocontinueHook, compactingHook, keywordDetectionHook, sessionIdleHook, soulWhisperToolTracker, pendingToolCalls, buildWhisperText } from "./hooks.js";
+import { autoRecallHook, memoryInjectionHook, autocontinueHook, compactingHook, keywordDetectionHook, sessionIdleHook, soulWhisperToolTracker, pendingToolCalls, buildWhisperText } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logDebug, logError } from "./logger.js";
@@ -55,7 +55,7 @@ function showToast(tui: any, title: string, message?: string, variant: string =
       }
       tui.showToast({ body });
     } catch (err) {
-      console.error("[cerebro] showToast failed:", err);
+      logError("showToast failed", { error: String(err) });
     }
   }, 3000);
 }
@@ -119,11 +119,7 @@ const OmemPlugin: Plugin = async (input) => {
   let mainSessionLocked = false;
   let cachedAgentName: string | undefined;
 
-  const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
-
-  const wrappedRecallHook = async (input: any, output: any) => {
-    await recallHook(input, output);
-
+  const soulWhisperSystemHook = async (input: any, output: any) => {
     // ── Soul Whisper: inject to system prompt (v2 — system.transform) ──
     if (config.soulWhisper?.enabled !== false) {
       const sid = input.sessionID || "_default";
@@ -145,6 +141,29 @@ const OmemPlugin: Plugin = async (input) => {
     }
   };
 
+  // ── Fallback strategy: "parts" (new) vs "system" (legacy) ──
+  const strategy = config.injectionStrategy ?? "parts";
+
+  const chatMessageHook = strategy === "parts"
+    ? async (input: any, output: any) => {
+        // New path: keyword detection + memory injection
+        await keywordDetectionHook(cerebroClient, containerTags, config.ingest.autoCaptureThreshold, tui, config.ingest.ingestMode, config, agentId)(input, output);
+        await memoryInjectionHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory)(input, output);
+      }
+    : async (input: any, output: any) => {
+        // Fallback: keyword detection only (memory injection via system.transform legacy autoRecallHook)
+        await keywordDetectionHook(cerebroClient, containerTags, config.ingest.autoCaptureThreshold, tui, config.ingest.ingestMode, config, agentId)(input, output);
+      };
+
+  const systemTransformHook = strategy === "parts"
+    ? soulWhisperSystemHook
+    : async (input: any, output: any) => {
+        // Fallback: legacy autoRecallHook + soulWhisper
+        const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
+        await recallHook(input, output);
+        await soulWhisperSystemHook(input, output);
+      };
+
   return {
     config: async (cfg: any) => {
       cfg.command ??= {};
@@ -154,15 +173,15 @@ const OmemPlugin: Plugin = async (input) => {
       };
     },
     "experimental.chat.system.transform": async (input: any, output: any) => {
-      logDebug("transform input", { sessionID: input.sessionID });
+      logDebug("transform input", { sessionID: input.sessionID, strategy });
       if (input.sessionID && !mainSessionLocked) {
         mainSessionId = input.sessionID;
         mainSessionLocked = true;
         logInfo("mainSessionId locked", { sessionId: input.sessionID });
       }
-      return wrappedRecallHook(input, output);
+      return systemTransformHook(input, output);
     },
-    "chat.message": keywordDetectionHook(cerebroClient, containerTags, config.ingest.autoCaptureThreshold, tui, config.ingest.ingestMode, config, agentId),
+    "chat.message": chatMessageHook,
     "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 }),