@mingxy/cerebro 1.10.9 → 1.10.10

package/package.json

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

package/src/config.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, appendFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -144,6 +144,25 @@ function deepMerge(base: OmemPluginConfig, overrides: Partial<OmemPluginConfig>)
 
 // ── Load config ──────────────────────────────────────────────────────
 
+/** File-only logger for config.ts (cannot import logger.ts due to circular dependency). */
+function configLog(message: string, fields?: Record<string, unknown>): void {
+  try {
+    const logDir = join(homedir(), ".config", "cerebro", "logs");
+    const logPath = join(logDir, "plugin.log");
+    const ts = new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+    const parts = [`WARN  ${ts} service=cerebro ${message}`];
+    if (fields) {
+      for (const [k, v] of Object.entries(fields)) {
+        parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+      }
+    }
+    mkdirSync(logDir, { recursive: true });
+    appendFileSync(logPath, parts.join(" ") + "\n");
+  } catch (writeErr) {
+    process.stderr.write(`[cerebro] configLog write failed: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}\n`);
+  }
+}
+
 export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPluginConfig {
   let config: OmemPluginConfig = structuredClone(DEFAULTS);
 
@@ -157,8 +176,8 @@ export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPlu
 
     // Merge nested groups with defaults for safety
     config = deepMerge(config, parsed);
-  } catch {
-    // Config file doesn't exist or is invalid, use defaults
+  } catch (e) {
+    configLog("config.json load failed, using defaults", { error: String(e) });
   }
 
   // Apply environment variable overrides (flat OMEM_* → nested paths)
@@ -201,7 +220,20 @@ export function resolveAgentPolicy(
   agentName: string,
   config: Partial<OmemPluginConfig>,
 ): AgentPolicy {
-  return config.agentMemoryPolicy?.[agentName] ?? config.defaultPolicy ?? "readwrite";
+  const policies = config.agentMemoryPolicy;
+  if (policies) {
+    const exact = policies[agentName];
+    if (exact) return exact;
+    const lower = agentName.toLowerCase();
+    for (const [key, policy] of Object.entries(policies)) {
+      if (lower.startsWith(key.toLowerCase()) || key.toLowerCase().startsWith(lower)) {
+        return policy;
+      }
+    }
+  }
+  if (config.defaultPolicy) return config.defaultPolicy;
+  configLog("resolveAgentPolicy: no policy configured, defaulting to readwrite", { agentName });
+  return "readwrite";
 }
 
 export { DEFAULTS };

package/src/hooks.ts

@@ -482,6 +482,15 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
     } catch {
     }
 
+    // Main session gate: sub-agents must not write memories via compacting
+    if (getMainSessionId) {
+      const mainId = getMainSessionId();
+      if (mainId && input.sessionID && input.sessionID !== mainId) {
+        logInfo("compactingHook: non-main session skipped", { sessionID: input.sessionID, mainSessionId: mainId });
+        return;
+      }
+    }
+
     // Policy gate: only readwrite agents can write memories
     const policy = resolveAgentPolicy(effectiveAgentId, config);
     if (policy !== "readwrite") {
@@ -515,12 +524,13 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
           }
 
           try {
-            logInfo("compactingHook ingestMessages called", { msgCount: messages.length, sessionId: effectiveSessionId });
+            logInfo("compactingHook ingestMessages called", { msgCount: messages.length, sessionId: effectiveSessionId, agentId: effectiveAgentId });
             const result = await client.ingestMessages(messages, {
               mode: ingestMode,
               tags: [...containerTags, "auto-capture"],
               sessionId: effectiveSessionId,
               projectName: projectName,
+              agentId: effectiveAgentId,
             });
             logInfo("compactingHook ingestMessages result", { result: result === null ? "null(blocked)" : "ok" });
             if (result === null) {
@@ -553,6 +563,7 @@ export function sessionIdleHook(
   isAutoStoreEnabled?: (sessionId: string | undefined) => boolean,
   agentId?: string,
   config: Partial<OmemPluginConfig> = {},
+  onAgentResolved?: (name: string) => void,
 ) {
   let idleTimeout: ReturnType<typeof setTimeout> | null = null;
   let isCapturing = false;
@@ -560,6 +571,8 @@ export function sessionIdleHook(
   return async (input: { event: { type: string; properties?: any } }) => {
     if (input.event.type !== "session.idle") return;
 
+    logDebug("sessionIdleHook event.properties dump", { keys: Object.keys(input.event.properties || {}), raw: JSON.stringify(input.event.properties).substring(0, 2000) });
+
     const sessionID = input.event.properties?.sessionID;
     if (!sessionID) return;
 
@@ -567,7 +580,10 @@ export function sessionIdleHook(
 
     if (getMainSessionId) {
       const mainId = getMainSessionId();
-      if (mainId && sessionID !== mainId) return;
+      if (mainId && sessionID !== mainId) {
+        logInfo("sessionIdleHook: non-main session skipped", { sessionID, mainSessionId: mainId });
+        return;
+      }
     }
 
     if (idleTimeout) clearTimeout(idleTimeout);
@@ -589,8 +605,6 @@ export function sessionIdleHook(
           const msgId = msg.info?.id;
           if (!msgId || processedMessageIds.has(msgId)) continue;
 
-          // Skip messages created before this plugin instance started
-          // (prevents replaying entire session history on restart)
           const msgTime = msg.info?.createdAt ? new Date(msg.info.createdAt).getTime() : 0;
           if (msgTime > 0 && msgTime < pluginStartTime) continue;
 
@@ -614,18 +628,15 @@ export function sessionIdleHook(
           return;
         }
 
-        // Policy gate: only readwrite agents can write memories
-        const policy = resolveAgentPolicy(agentId || "", config);
-        if (policy !== "readwrite") {
-          logInfo("sessionIdleHook blocked by policy", { agentId: agentId || "", policy });
-          return;
-        }
-
         let sessionTitle: string | undefined;
         let projectName: string | undefined;
+        let effectiveAgentId = agentId || "opencode";
         try {
           const sessionInfo = await sdkClient.session.get({ path: { id: sessionID } });
-          logDebug("sessionIdleHook project.rootPath", { rootPath: sessionInfo?.data?.directory });
+          if ((sessionInfo?.data as any)?.agent) {
+            effectiveAgentId = (sessionInfo.data as any).agent;
+            onAgentResolved?.(effectiveAgentId);
+          }
           sessionTitle = sessionInfo?.data?.title;
           projectName = sessionInfo?.data?.directory
             ? await detectProjectName(sessionInfo.data.directory)
@@ -634,9 +645,17 @@ export function sessionIdleHook(
           logErr("sessionIdleHook detectProjectName failed", { error: String(e) });
         }
 
+        logDebug("sessionIdleHook resolved agentId", { effectiveAgentId, fallbackAgentId: agentId });
+
+        const policy = resolveAgentPolicy(effectiveAgentId, config);
+        if (policy !== "readwrite") {
+          logInfo("sessionIdleHook blocked by policy", { agentId: effectiveAgentId, policy, defaultPolicy: String(config.defaultPolicy ?? "undefined") });
+          return;
+        }
+
         try {
-          logInfo("sessionIdleHook sessionIngest called", { msgCount: conversationMessages.length, sessionId: sessionID, title: String(sessionTitle) });
-          await cerebroClient.sessionIngest(conversationMessages, sessionID, agentId, sessionTitle, projectName);
+          logInfo("sessionIdleHook sessionIngest called", { msgCount: conversationMessages.length, sessionId: sessionID, agentId: effectiveAgentId, title: String(sessionTitle) });
+          await cerebroClient.sessionIngest(conversationMessages, sessionID, effectiveAgentId, sessionTitle, projectName);
           logInfo("sessionIdleHook sessionIngest ok");
           for (const id of newMessageIds) {
             processedMessageIds.add(id);

package/src/index.ts

@@ -7,7 +7,7 @@ import { CerebroClient } from "./client.js";
 import { autoRecallHook, compactingHook, keywordDetectionHook, sessionIdleHook } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
-import { logInfo, logError } from "./logger.js";
+import { logInfo, logDebug, logError } from "./logger.js";
 import { loadPluginConfig } from "./config.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -115,7 +115,9 @@ const OmemPlugin: Plugin = async (input) => {
   const containerTags = [getUserTag(email), getProjectTag(cwd)];
   const agentId = process.env.OMEM_AGENT_ID || "opencode";
 
-  let currentSessionId: string | undefined;
+  let mainSessionId: string | undefined;
+  let mainSessionLocked = false;
+  let cachedAgentName: string | undefined;
 
   const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config);
 
@@ -128,13 +130,18 @@ const OmemPlugin: Plugin = async (input) => {
       };
     },
     "experimental.chat.system.transform": async (input: any, output: any) => {
-      if (input.sessionID) currentSessionId = input.sessionID;
+      logDebug("transform input", { sessionID: input.sessionID });
+      if (input.sessionID && !mainSessionLocked) {
+        mainSessionId = input.sessionID;
+        mainSessionLocked = true;
+        logInfo("mainSessionId locked", { sessionId: input.sessionID });
+      }
       return recallHook(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, () => currentSessionId, client, config, agentId),
-    tool: buildTools(cerebroClient, containerTags, { agentId, getSessionId: () => currentSessionId }),
-    event: sessionIdleHook(cerebroClient, containerTags, tui, client, config.ingest.ingestMode, config.ingest.autoCaptureThreshold, () => currentSessionId, isAutoStoreEnabled, agentId, config),
+    "experimental.session.compacting": compactingHook(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; }),
     "shell.env": async (_input: any, output: any) => {
       if (directory) {
         output.env.OMEM_PROJECT_DIR = directory;

package/src/tools.ts

@@ -24,6 +24,7 @@ function extractMemoryIds(result: unknown): string[] {
 export interface ToolContext {
   agentId?: string;
   getSessionId: () => string | undefined;
+  getAgentName?: () => string;
 }
 
 export function buildTools(client: CerebroClient, containerTags: string[], context: ToolContext) {
@@ -85,12 +86,13 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
       },
       async execute(args) {
         const allTags = [...containerTags, ...(args.tags ?? [])];
+        const effectiveAgentId = context.getAgentName?.() || context.agentId;
         const result = await client.createMemory(
           args.content,
           allTags,
           args.source,
           args.scope ?? "project",
-          context.agentId,
+          effectiveAgentId,
           context.getSessionId(),
           args.visibility,
           args.category,
@@ -241,10 +243,12 @@ export function buildTools(client: CerebroClient, containerTags: string[], conte
           .describe("Session ID to associate with the ingestion"),
       },
       async execute(args) {
+        const effectiveAgentId = context.getAgentName?.() || context.agentId;
         const result = await client.ingestMessages(args.messages, {
           mode: args.mode ?? "smart",
           tags: args.tags,
           sessionId: args.session_id,
+          agentId: effectiveAgentId,
         });
         if (result === null) return JSON.stringify({ ok: false, error: "Ingestion failed" });
         if (args.session_id) {