@mingxy/cerebro 1.12.8 → 1.13.0

package/src/hooks.ts

@@ -297,7 +297,7 @@ function buildClusteredContextBlock(clustered: import("./client.js").ClusteredRe
   ].join("\n");
 }
 
-export function autoRecallHook(client: CerebroClient, containerTags: string[], tui: any, config: Partial<OmemPluginConfig> = {}, getAgentName?: () => string) {
+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;
@@ -367,6 +367,7 @@ export function autoRecallHook(client: CerebroClient, containerTags: string[], t
           refine_strategy: refineStrategy,
           refine_medium_chars: refineMediumChars,
         },
+        directory || process.env.OMEM_PROJECT_DIR,
       );
 
       if (!shouldRecallRes) {
@@ -626,7 +627,7 @@ export function keywordDetectionHook(_client: CerebroClient, _containerTags: str
   };
 }
 
-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) {
+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 (
     input: { sessionID?: string },
@@ -677,10 +678,12 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
 
     // Resolve project name (shared by ingest + poll)
     let projectName: string | undefined;
+    let projectPath: string | undefined;
     try {
       if (sdkClient && input.sessionID) {
         const sessionInfo = await sdkClient.session.get({ path: { id: input.sessionID } });
         logDebug("compactingHook project.rootPath", { rootPath: sessionInfo?.data?.directory });
+        projectPath = sessionInfo?.data?.directory || directory || process.env.OMEM_PROJECT_DIR;
         projectName = sessionInfo?.data?.directory
           ? await detectProjectName(sessionInfo.data.directory)
           : undefined;
@@ -688,6 +691,9 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
     } catch (e) {
       logErr("compactingHook detectProjectName failed", { error: String(e) });
     }
+    if (!projectPath) {
+      projectPath = directory || process.env.OMEM_PROJECT_DIR;
+    }
 
     // --- Phase 1: Ingest tracked messages from sessionMessages (if available) ---
     if (input.sessionID && sessionMessages.has(input.sessionID)) {
@@ -706,6 +712,7 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
               sessionId: effectiveSessionId,
               projectName: projectName,
               agentId: effectiveAgentId,
+              projectPath,
             });
             logInfo("compactingHook ingestMessages result", { result: result === null ? "null(blocked)" : "ok" });
             if (result === null) {
@@ -723,6 +730,10 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
       sessionMessages.delete(input.sessionID);
       profileInjectedSessions.delete(input.sessionID);
       firstMessages.delete(input.sessionID);
+      if (input.sessionID) {
+        const deleted = pendingToolCalls.delete(input.sessionID);
+        logDebug("compactingHook cleared session pendingToolCalls", { sessionID: input.sessionID, hadPending: deleted });
+      }
       // Evict stale injectedMemoryIds if over size cap (200 sessions)
       if (injectedMemoryIds.size > 200) {
         injectedMemoryIds.clear();
@@ -734,6 +745,7 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
       const pollSessionId = input.sessionID;
       const pollEffectiveSessionId = effectiveSessionId;
       const pollProjectName = projectName;
+      const pollProjectPath = projectPath;
       const pollAgentId = effectiveAgentId;
 
       let baselineMsgIds: Set<string> = new Set();
@@ -843,6 +855,7 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
                         sessionId: pollEffectiveSessionId,
                         projectName: pollProjectName,
                         agentId: pollAgentId,
+                        projectPath: pollProjectPath,
                       },
                     );
                     logInfo("compactingHook: compact summary store result", {
@@ -881,6 +894,7 @@ export function autocontinueHook(
   sdkClient?: any,
   config: Partial<OmemPluginConfig> = {},
   agentId?: string,
+  directory?: string,
 ) {
   const effectiveAgentId = agentId || process.env.OMEM_AGENT_ID || "opencode";
   return async (
@@ -936,14 +950,19 @@ export function autocontinueHook(
       }
 
       let projectName: string | undefined;
+      let projectPath: string | undefined;
       try {
         const sessionInfo = await sdkClient.session.get({ path: { id: input.sessionID } });
+        projectPath = sessionInfo?.data?.directory || directory || process.env.OMEM_PROJECT_DIR;
         projectName = sessionInfo?.data?.directory
           ? await detectProjectName(sessionInfo.data.directory)
           : undefined;
       } catch (e) {
         logErr("autocontinueHook detectProjectName failed", { error: String(e) });
       }
+      if (!projectPath) {
+        projectPath = directory || process.env.OMEM_PROJECT_DIR;
+      }
 
       const messages = [{ role: "user" as const, content: summaryText }];
       logInfo("autocontinueHook storing compact summary", {
@@ -960,6 +979,7 @@ export function autocontinueHook(
         sessionId: effectiveSessionId,
         projectName: projectName,
         agentId: effectiveAgentId,
+        projectPath,
       });
 
       logInfo("autocontinueHook store result", { result: result === null ? "null(blocked)" : "ok" });
@@ -977,6 +997,69 @@ export function autocontinueHook(
 const processedMessageIds = new Set<string>();
 const pluginStartTime = Date.now();
 
+// ── Soul Whisper: pending tool call tracking (per-session isolation) ──
+const pendingToolCalls = new Map<string, Map<string, { toolName: string; timestamp: number }>>();
+
+export function soulWhisperToolTracker(config: OmemPluginConfig) {
+  return async (input: { tool: string; sessionID: string; callID: string }, _output: { args: any }) => {
+    if (config.soulWhisper?.enabled === false) {
+      logDebug("soulWhisperToolTracker disabled by config", { tool: input.tool });
+      return;
+    }
+
+    const sw = config.soulWhisper;
+    const toolName = input.tool;
+
+    const excludeTools = sw?.excludeTools ?? [];
+    if (excludeTools.includes(toolName)) {
+      logDebug("soulWhisperToolTracker excluded", { tool: toolName });
+      return;
+    }
+
+    const includeTools = sw?.tools ?? ["*"];
+    const isWildcard = includeTools.includes("*");
+    if (!isWildcard && !includeTools.includes(toolName)) {
+      logDebug("soulWhisperToolTracker not in whitelist", { tool: toolName, whitelist: includeTools });
+      return;
+    }
+
+    const sid = input.sessionID || "_default";
+    let sessionMap = pendingToolCalls.get(sid);
+    if (!sessionMap) {
+      sessionMap = new Map();
+      pendingToolCalls.set(sid, sessionMap);
+    }
+    sessionMap.set(input.callID, { toolName, timestamp: Date.now() });
+    logDebug("soulWhisperToolTracker recorded", { tool: toolName, callID: input.callID, sessionID: sid, totalSessions: pendingToolCalls.size, sessionCallCount: sessionMap.size });
+  };
+}
+
+function buildWhisperText(toolNames: string[], maxToolNames: number): string | null {
+  if (toolNames.length === 0) return null;
+
+  const lines: string[] = ["<cerebro-system-reminder>"];
+
+  if (toolNames.length <= maxToolNames) {
+    lines.push(`SOUL WHISPER — Detected tool call: ${toolNames.join(", ")}.`);
+    lines.push("Your memories (cerebro-context) may contain:");
+    lines.push("- Exact commands or flags someone already tested");
+    lines.push("- File paths or configurations that worked before");
+    lines.push("- Solutions to errors you previously encountered");
+    lines.push(`If a memory matches → use it. Then reply: 💜 受到灵魂的召唤——[what you used]`);
+  } else {
+    lines.push("SOUL WHISPER — Memories from past sessions are loaded above (see <cerebro-context>).");
+    lines.push("Before you act:");
+    lines.push("1. Scan cerebro-context for commands, paths, or patterns matching your current task");
+    lines.push("2. If found → use directly, do not re-derive from scratch");
+    lines.push(`3. If a memory guided your action → reply: 💜 受到灵魂的召唤——[what you used]`);
+  }
+
+  lines.push(`If memory summaries are insufficient → use memory_get("id") to fetch full content, or memory_search("query") to find more.`);
+  lines.push("</cerebro-system-reminder>");
+
+  return lines.join("\n");
+}
+
 const FETCH_POLICY_NUDGE = [
   "<cerebro-system-reminder>",
   "MEMORY REMINDER: You have injected memories above (see <cerebro-context>).",
@@ -985,7 +1068,7 @@ const FETCH_POLICY_NUDGE = [
   "</cerebro-system-reminder>",
 ].join("\n");
 
-export function fetchPolicyNudgeHook(getContextInjectedFlag: () => boolean) {
+export function fetchPolicyNudgeHook(getContextInjectedFlag: () => boolean, config?: OmemPluginConfig) {
   return async (_input: Record<string, unknown>, output: { messages: any[] }) => {
     let shouldNudge = getContextInjectedFlag();
     if (!shouldNudge && Array.isArray(output.messages)) {
@@ -994,12 +1077,17 @@ export function fetchPolicyNudgeHook(getContextInjectedFlag: () => boolean) {
         m.parts.some((p: any) => typeof p.text === "string" && p.text.includes("<cerebro-context>"))
       );
     }
-    if (!shouldNudge) return;
+
+    const swEnabled = config?.soulWhisper?.enabled !== false;
+    const hasAnyPending = pendingToolCalls.size > 0;
+    if (!shouldNudge && !(swEnabled && hasAnyPending)) {
+      logDebug("fetchPolicyNudgeHook skipped", { shouldNudge, swEnabled, hasAnyPending });
+      return;
+    }
 
     const messages = output.messages;
     if (!messages || !Array.isArray(messages) || messages.length === 0) return;
 
-    // Find the last user message
     let lastUserIdx = -1;
     for (let i = messages.length - 1; i >= 0; i--) {
       if (messages[i]?.info?.role === "user") {
@@ -1012,13 +1100,29 @@ export function fetchPolicyNudgeHook(getContextInjectedFlag: () => boolean) {
     const userMsg = messages[lastUserIdx];
     if (!Array.isArray(userMsg.parts)) return;
 
-    // Idempotency check
-    const nudgeId = `cerebro_nudge_${userMsg.info.sessionID || userMsg.info.id}`;
+    const sessionId = userMsg.info.sessionID || "_default";
+    const nudgeId = `cerebro_nudge_${sessionId}`;
     for (const part of userMsg.parts) {
       if (part.id === nudgeId) return;
     }
 
-    // Find the first text part position, insert synthetic part before it
+    const parts: string[] = [];
+    if (shouldNudge) parts.push(FETCH_POLICY_NUDGE);
+
+    const sessionCalls = swEnabled ? pendingToolCalls.get(sessionId) : undefined;
+    if (sessionCalls && sessionCalls.size > 0) {
+      const toolNames = [...new Set([...sessionCalls.values()].map(v => v.toolName))];
+      const maxToolNames = config?.soulWhisper?.maxToolNames ?? 3;
+      const whisperText = buildWhisperText(toolNames, maxToolNames);
+      if (whisperText) parts.push(whisperText);
+      pendingToolCalls.delete(sessionId);
+      logDebug("soulWhisper consumed session calls", { sessionId, callCount: sessionCalls.size, toolNames });
+    } else if (swEnabled) {
+      logDebug("soulWhisper no pending calls for session", { sessionId, globalSessionCount: pendingToolCalls.size });
+    }
+
+    if (parts.length === 0) return;
+
     const textPartIdx = userMsg.parts.findIndex((p: any) => p.type === "text" && typeof p.text === "string");
 
     const syntheticPart = {
@@ -1026,7 +1130,7 @@ export function fetchPolicyNudgeHook(getContextInjectedFlag: () => boolean) {
       messageID: userMsg.info.id,
       sessionID: userMsg.info.sessionID || "",
       type: "text" as const,
-      text: FETCH_POLICY_NUDGE,
+      text: parts.join("\n\n"),
       synthetic: true,
     };
 
@@ -1036,7 +1140,7 @@ export function fetchPolicyNudgeHook(getContextInjectedFlag: () => boolean) {
       userMsg.parts.push(syntheticPart);
     }
 
-    logDebug("fetchPolicyNudgeHook injected", { sessionId: userMsg.info.sessionID || "", nudgeId });
+    logDebug("fetchPolicyNudgeHook injected", { sessionId, nudgeId, hasWhisper: sessionCalls != null && sessionCalls.size > 0, partsCount: parts.length });
   };
 }
 
@@ -1052,6 +1156,7 @@ export function sessionIdleHook(
   agentId?: string,
   config: Partial<OmemPluginConfig> = {},
   onAgentResolved?: (name: string) => void,
+  directory?: string,
 ) {
   let idleTimeout: ReturnType<typeof setTimeout> | null = null;
   let isCapturing = false;
@@ -1118,6 +1223,7 @@ export function sessionIdleHook(
 
         let sessionTitle: string | undefined;
         let projectName: string | undefined;
+        let projectPath: string | undefined;
         let effectiveAgentId = agentId || "opencode";
         try {
           const sessionInfo = await sdkClient.session.get({ path: { id: sessionID } });
@@ -1126,12 +1232,16 @@ export function sessionIdleHook(
             onAgentResolved?.(effectiveAgentId);
           }
           sessionTitle = sessionInfo?.data?.title;
+          projectPath = sessionInfo?.data?.directory || directory || process.env.OMEM_PROJECT_DIR;
           projectName = sessionInfo?.data?.directory
             ? await detectProjectName(sessionInfo.data.directory)
             : undefined;
         } catch (e) {
           logErr("sessionIdleHook detectProjectName failed", { error: String(e) });
         }
+        if (!projectPath) {
+          projectPath = directory || process.env.OMEM_PROJECT_DIR;
+        }
 
         logDebug("sessionIdleHook resolved agentId", { effectiveAgentId, fallbackAgentId: agentId });
 
@@ -1143,7 +1253,7 @@ export function sessionIdleHook(
 
         try {
           logInfo("sessionIdleHook sessionIngest called", { msgCount: conversationMessages.length, sessionId: sessionID, agentId: effectiveAgentId, title: String(sessionTitle) });
-          await cerebroClient.sessionIngest(conversationMessages, sessionID, effectiveAgentId, sessionTitle, projectName);
+          await cerebroClient.sessionIngest(conversationMessages, sessionID, effectiveAgentId, sessionTitle, projectName, projectPath);
           logInfo("sessionIdleHook sessionIngest ok");
           for (const id of newMessageIds) {
             processedMessageIds.add(id);
@@ -1159,6 +1269,8 @@ export function sessionIdleHook(
       } finally {
         isCapturing = false;
         idleTimeout = null;
+        const deleted = pendingToolCalls.delete(sessionID);
+        if (deleted) logDebug("sessionIdleHook cleared session pendingToolCalls", { sessionID, hadPending: deleted });
       }
     }, 10000);
   };

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, fetchPolicyNudgeHook, keywordDetectionHook, sessionIdleHook } from "./hooks.js";
+import { autoRecallHook, autocontinueHook, compactingHook, fetchPolicyNudgeHook, keywordDetectionHook, sessionIdleHook, soulWhisperToolTracker } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logDebug, logError } from "./logger.js";
@@ -119,7 +119,7 @@ const OmemPlugin: Plugin = async (input) => {
   let mainSessionLocked = false;
   let cachedAgentName: string | undefined;
 
-  const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId);
+  const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
 
   let contextInjectedThisTurn = false;
 
@@ -147,11 +147,12 @@ const OmemPlugin: Plugin = async (input) => {
       return wrappedRecallHook(input, output);
     },
     "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),
-    "experimental.compaction.autocontinue": autocontinueHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId),
-    tool: buildTools(cerebroClient, containerTags, { agentId, getSessionId: () => mainSessionId, getAgentName: () => cachedAgentName || agentId }),
-    event: sessionIdleHook(cerebroClient, containerTags, tui, client, config.ingest.ingestMode, config.ingest.autoCaptureThreshold, () => mainSessionId, isAutoStoreEnabled, agentId, config, (name: string) => { cachedAgentName = name; }),
-    "experimental.chat.messages.transform": fetchPolicyNudgeHook(() => contextInjectedThisTurn),
+    "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 }),
+    event: sessionIdleHook(cerebroClient, containerTags, tui, client, config.ingest.ingestMode, config.ingest.autoCaptureThreshold, () => mainSessionId, isAutoStoreEnabled, agentId, config, (name: string) => { cachedAgentName = name; }, directory),
+    "experimental.chat.messages.transform": fetchPolicyNudgeHook(() => contextInjectedThisTurn, config),
+    "tool.execute.before": (() => { const tracker = soulWhisperToolTracker(config); return tracker; })(),
     "shell.env": async (_input: any, output: any) => {
       if (directory) {
         output.env.OMEM_PROJECT_DIR = directory;

package/src/tools.ts

@@ -6,6 +6,7 @@ export interface ToolContext {
   agentId?: string;
   getSessionId: () => string | undefined;
   getAgentName?: () => string;
+  getProjectPath?: () => string | undefined;
 }
 
 export function buildTools(client: CerebroClient, containerTags: string[], context: ToolContext) {
@@ -16,7 +17,10 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
         "Use when the user explicitly asks to remember something, " +
         "or when you identify important preferences, facts, or decisions worth preserving. " +
         "IMPORTANT: Before calling, you MUST analyze: (1) Which category fits best? (2) Is this project-specific or cross-project? (3) Does it contain sensitive data? (4) Are tags accurate and descriptive? " +
-        "Every memory MUST have a correct category and at least 1 meaningful tag.",
+        "Every memory MUST have a correct category and at least 1 meaningful tag. " +
+        "Memories are automatically scoped to the current project via project_path. " +
+        "Set scope='global' for cross-project memories that should be visible everywhere. " +
+        "Private memories (visibility='private') are always agent-scoped and not bound to any project — use for sensitive data.",
       args: {
         content: tool.schema.string().describe(
           "The information to remember. MUST be: atomic (one fact per memory), complete (self-contained without context), and precise (no ambiguity). " +
@@ -77,6 +81,7 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
           context.getSessionId(),
           args.visibility,
           args.category,
+          context.getProjectPath?.(),
         );
         if (!result) return JSON.stringify({ ok: false, error: "The Cerebro server may be unavailable." });
         return JSON.stringify({ ok: true, id: result.id, tags: result.tags });
@@ -86,7 +91,10 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
     memory_search: tool({
       description:
         "Search the user's long-term memory by semantic similarity. " +
-        "Use to recall previously stored preferences, facts, or context.",
+        "Use to recall previously stored preferences, facts, or context. " +
+        "Searches are automatically filtered by the current project_path. " +
+        "Global-scope memories and memories without a project_path are always included in results. " +
+        "Private memories are visible only to the creating agent.",
       args: {
         query: tool.schema.string().describe("Natural-language search query"),
         limit: tool.schema
@@ -104,6 +112,7 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
           args.limit ?? 10,
           args.scope,
           containerTags,
+          context.getProjectPath?.(),
         );
         if (results.length === 0) return JSON.stringify({ ok: true, count: 0, results: [] });
         const items = results.map((r) => ({
@@ -189,7 +198,9 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
 
     memory_ingest: tool({
       description:
-        "Ingest conversation messages for intelligent extraction. The system extracts atomic facts, deduplicates, and reconciles with existing memories.",
+        "Ingest conversation messages for intelligent extraction. The system extracts atomic facts, deduplicates, and reconciles with existing memories. " +
+        "Extracted memories are automatically scoped to the current project via project_path. " +
+        "Global-scope memories are visible across all projects.",
       args: {
         messages: tool.schema
           .array(
@@ -219,6 +230,7 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
           tags: args.tags,
           sessionId: args.session_id,
           agentId: effectiveAgentId,
+          projectPath: context.getProjectPath?.(),
         });
         if (result === null) return JSON.stringify({ ok: false, error: "Ingestion failed" });
         return JSON.stringify({ ok: true, result });