@mingxy/cerebro 1.10.6 → 1.10.8

package/src/config.ts

@@ -1,104 +1,207 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export interface OmemPluginConfig {
-  // Connection
-  apiUrl: string;
-  apiKey: string;
-  // Timeouts (milliseconds)
-  requestTimeoutMs: number;
-  // Content limits
-  maxQueryLength: number;
-  maxContentChars: number;
-  maxContentLength: number;
-  // Auto capture
-  autoCaptureThreshold: number;
-  ingestMode: "smart" | "raw";
-  // Recall settings
-  similarityThreshold: number;
-  maxRecallResults: number;
-  // UI settings
-  toastDelayMs: number;
-  // Logging
-  logEnabled: boolean;
-  logLevel: "DEBUG" | "INFO" | "WARN" | "ERROR";
-  logDir: string;
-}
-
-const DEFAULTS: OmemPluginConfig = {
-  apiUrl: "https://www.mengxy.cc",
-  apiKey: "",
-  requestTimeoutMs: 15000,
-  maxQueryLength: 200,
-  maxContentChars: 30000,
-  maxContentLength: 500,
-  autoCaptureThreshold: 5,
-  ingestMode: "smart",
-  similarityThreshold: 0.4,
-  maxRecallResults: 10,
-  toastDelayMs: 7000,
-  logEnabled: true,
-  logLevel: "INFO",
-  logDir: join(homedir(), ".config", "cerebro"),
-};
-
-export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPluginConfig {
-  const config: Partial<OmemPluginConfig> = { ...DEFAULTS };
-
-  // Try loading from config file
-  try {
-    const cfgPath = join(homedir(), ".config", "cerebro", "config.json");
-    const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
-
-    if (cfg.apiUrl) config.apiUrl = cfg.apiUrl;
-    if (cfg.apiKey) config.apiKey = cfg.apiKey;
-    if (typeof cfg.requestTimeoutMs === "number") config.requestTimeoutMs = cfg.requestTimeoutMs;
-    if (typeof cfg.maxQueryLength === "number") config.maxQueryLength = cfg.maxQueryLength;
-    if (typeof cfg.maxContentChars === "number") config.maxContentChars = cfg.maxContentChars;
-    if (typeof cfg.maxContentLength === "number") config.maxContentLength = cfg.maxContentLength;
-    if (typeof cfg.autoCaptureThreshold === "number") config.autoCaptureThreshold = cfg.autoCaptureThreshold;
-    if (cfg.ingestMode === "raw" || cfg.ingestMode === "smart") config.ingestMode = cfg.ingestMode;
-    if (typeof cfg.similarityThreshold === "number") config.similarityThreshold = cfg.similarityThreshold;
-    if (typeof cfg.maxRecallResults === "number") config.maxRecallResults = cfg.maxRecallResults;
-    if (typeof cfg.toastDelayMs === "number") config.toastDelayMs = cfg.toastDelayMs;
-    if (typeof cfg.logEnabled === "boolean") config.logEnabled = cfg.logEnabled;
-    if (cfg.logLevel === "DEBUG" || cfg.logLevel === "INFO" || cfg.logLevel === "WARN" || cfg.logLevel === "ERROR") config.logLevel = cfg.logLevel;
-    if (typeof cfg.logDir === "string" && cfg.logDir) config.logDir = cfg.logDir;
-  } catch {
-    // Config file doesn't exist or is invalid, use defaults
-  }
-
-  // Apply environment variable overrides
-  if (process.env.OMEM_API_URL) config.apiUrl = process.env.OMEM_API_URL;
-  if (process.env.OMEM_API_KEY) config.apiKey = process.env.OMEM_API_KEY;
-  if (process.env.OMEM_REQUEST_TIMEOUT_MS) {
-    config.requestTimeoutMs = parseInt(process.env.OMEM_REQUEST_TIMEOUT_MS, 10) || DEFAULTS.requestTimeoutMs;
-  }
-  if (process.env.OMEM_AUTO_CAPTURE_THRESHOLD) {
-    config.autoCaptureThreshold = parseInt(process.env.OMEM_AUTO_CAPTURE_THRESHOLD, 10) || DEFAULTS.autoCaptureThreshold;
-  }
-  if (process.env.OMEM_INGEST_MODE === "raw" || process.env.OMEM_INGEST_MODE === "smart") {
-    config.ingestMode = process.env.OMEM_INGEST_MODE;
-  }
-  if (process.env.OMEM_SIMILARITY_THRESHOLD) {
-    config.similarityThreshold = parseFloat(process.env.OMEM_SIMILARITY_THRESHOLD) || DEFAULTS.similarityThreshold;
-  }
-  if (process.env.OMEM_MAX_RECALL_RESULTS) {
-    config.maxRecallResults = parseInt(process.env.OMEM_MAX_RECALL_RESULTS, 10) || DEFAULTS.maxRecallResults;
-  }
-
-  // Apply explicit overrides (from opencode.json)
-  if (overrides) {
-    Object.assign(config, overrides);
-  }
-
-  // Expand ~ to home directory in logDir
-  if (config.logDir?.startsWith("~")) {
-    config.logDir = config.logDir.replace(/^~/, homedir());
-  }
-
-  return config as OmemPluginConfig;
-}
-
-export { DEFAULTS };
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ── Nested config interface ──────────────────────────────────────────
+
+export interface OmemPluginConfig {
+  connection: {
+    apiUrl: string;
+    apiKey: string;
+    requestTimeoutMs: number;
+  };
+  content: {
+    maxQueryLength: number;
+    maxContentChars: number;
+    maxContentLength: number;
+  };
+  ingest: {
+    autoCaptureThreshold: number;
+    ingestMode: "smart" | "raw";
+  };
+  recall: {
+    similarityThreshold: number;
+    maxRecallResults: number;
+  };
+  logging: {
+    logEnabled: boolean;
+    logLevel: "DEBUG" | "INFO" | "WARN" | "ERROR";
+    logDir: string;
+  };
+  ui: {
+    toastDelayMs: number;
+  };
+  agentMemoryPolicy?: Record<string, "none" | "readonly" | "readwrite">;
+  defaultPolicy?: "none" | "readonly" | "readwrite";
+}
+
+// ── Defaults ─────────────────────────────────────────────────────────
+
+const DEFAULTS: OmemPluginConfig = {
+  connection: {
+    apiUrl: "https://www.mengxy.cc",
+    apiKey: "",
+    requestTimeoutMs: 15000,
+  },
+  content: {
+    maxQueryLength: 200,
+    maxContentChars: 30000,
+    maxContentLength: 500,
+  },
+  ingest: {
+    autoCaptureThreshold: 5,
+    ingestMode: "smart",
+  },
+  recall: {
+    similarityThreshold: 0.4,
+    maxRecallResults: 10,
+  },
+  logging: {
+    logEnabled: true,
+    logLevel: "INFO",
+    logDir: join(homedir(), ".config", "cerebro"),
+  },
+  ui: {
+    toastDelayMs: 7000,
+  },
+};
+
+// ── Flat-to-nested migration ─────────────────────────────────────────
+
+/** Shape of legacy flat config (pre-nesting). */
+interface FlatConfig {
+  apiUrl?: string;
+  apiKey?: string;
+  requestTimeoutMs?: number;
+  maxQueryLength?: number;
+  maxContentChars?: number;
+  maxContentLength?: number;
+  autoCaptureThreshold?: number;
+  ingestMode?: "smart" | "raw";
+  similarityThreshold?: number;
+  maxRecallResults?: number;
+  toastDelayMs?: number;
+  logEnabled?: boolean;
+  logLevel?: "DEBUG" | "INFO" | "WARN" | "ERROR";
+  logDir?: string;
+  // Nested fields that would indicate new format
+  connection?: unknown;
+}
+
+function isFlatConfig(cfg: Record<string, unknown>): boolean {
+  return "apiUrl" in cfg && !("connection" in cfg);
+}
+
+function migrateFlatToNested(flat: FlatConfig): OmemPluginConfig {
+  return {
+    connection: {
+      apiUrl: flat.apiUrl ?? DEFAULTS.connection.apiUrl,
+      apiKey: flat.apiKey ?? DEFAULTS.connection.apiKey,
+      requestTimeoutMs: flat.requestTimeoutMs ?? DEFAULTS.connection.requestTimeoutMs,
+    },
+    content: {
+      maxQueryLength: flat.maxQueryLength ?? DEFAULTS.content.maxQueryLength,
+      maxContentChars: flat.maxContentChars ?? DEFAULTS.content.maxContentChars,
+      maxContentLength: flat.maxContentLength ?? DEFAULTS.content.maxContentLength,
+    },
+    ingest: {
+      autoCaptureThreshold: flat.autoCaptureThreshold ?? DEFAULTS.ingest.autoCaptureThreshold,
+      ingestMode: flat.ingestMode ?? DEFAULTS.ingest.ingestMode,
+    },
+    recall: {
+      similarityThreshold: flat.similarityThreshold ?? DEFAULTS.recall.similarityThreshold,
+      maxRecallResults: flat.maxRecallResults ?? DEFAULTS.recall.maxRecallResults,
+    },
+    logging: {
+      logEnabled: flat.logEnabled ?? DEFAULTS.logging.logEnabled,
+      logLevel: flat.logLevel ?? DEFAULTS.logging.logLevel,
+      logDir: flat.logDir ?? DEFAULTS.logging.logDir,
+    },
+    ui: {
+      toastDelayMs: flat.toastDelayMs ?? DEFAULTS.ui.toastDelayMs,
+    },
+  };
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+type IngestMode = "smart" | "raw";
+const INGEST_MODES: ReadonlySet<string> = new Set<IngestMode>(["smart", "raw"]);
+
+function deepMerge(base: OmemPluginConfig, overrides: Partial<OmemPluginConfig>): OmemPluginConfig {
+  const result: OmemPluginConfig = {
+    connection: { ...base.connection, ...overrides.connection },
+    content: { ...base.content, ...overrides.content },
+    ingest: { ...base.ingest, ...overrides.ingest },
+    recall: { ...base.recall, ...overrides.recall },
+    logging: { ...base.logging, ...overrides.logging },
+    ui: { ...base.ui, ...overrides.ui },
+  };
+  if (overrides.agentMemoryPolicy) result.agentMemoryPolicy = overrides.agentMemoryPolicy;
+  if (overrides.defaultPolicy) result.defaultPolicy = overrides.defaultPolicy;
+  return result;
+}
+
+// ── Load config ──────────────────────────────────────────────────────
+
+export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPluginConfig {
+  let config: OmemPluginConfig = structuredClone(DEFAULTS);
+
+  // Try loading from config file
+  try {
+    const cfgPath = join(homedir(), ".config", "cerebro", "config.json");
+    const raw = JSON.parse(readFileSync(cfgPath, "utf-8")) as Record<string, unknown>;
+
+    // Auto-migrate flat format
+    const parsed: OmemPluginConfig = isFlatConfig(raw) ? migrateFlatToNested(raw as FlatConfig) : raw as unknown as OmemPluginConfig;
+
+    // Merge nested groups with defaults for safety
+    config = deepMerge(config, parsed);
+  } catch {
+    // Config file doesn't exist or is invalid, use defaults
+  }
+
+  // Apply environment variable overrides (flat OMEM_* → nested paths)
+  if (process.env.OMEM_API_URL) config.connection.apiUrl = process.env.OMEM_API_URL;
+  if (process.env.OMEM_API_KEY) config.connection.apiKey = process.env.OMEM_API_KEY;
+  if (process.env.OMEM_REQUEST_TIMEOUT_MS) {
+    config.connection.requestTimeoutMs = parseInt(process.env.OMEM_REQUEST_TIMEOUT_MS, 10) || DEFAULTS.connection.requestTimeoutMs;
+  }
+  if (process.env.OMEM_AUTO_CAPTURE_THRESHOLD) {
+    config.ingest.autoCaptureThreshold = parseInt(process.env.OMEM_AUTO_CAPTURE_THRESHOLD, 10) || DEFAULTS.ingest.autoCaptureThreshold;
+  }
+  if (INGEST_MODES.has(process.env.OMEM_INGEST_MODE ?? "")) {
+    config.ingest.ingestMode = process.env.OMEM_INGEST_MODE as IngestMode;
+  }
+  if (process.env.OMEM_SIMILARITY_THRESHOLD) {
+    config.recall.similarityThreshold = parseFloat(process.env.OMEM_SIMILARITY_THRESHOLD) || DEFAULTS.recall.similarityThreshold;
+  }
+  if (process.env.OMEM_MAX_RECALL_RESULTS) {
+    config.recall.maxRecallResults = parseInt(process.env.OMEM_MAX_RECALL_RESULTS, 10) || DEFAULTS.recall.maxRecallResults;
+  }
+
+  // Apply explicit overrides (from opencode.json)
+  if (overrides) {
+    config = deepMerge(config, overrides);
+  }
+
+  // Expand ~ to home directory in logDir
+  if (config.logging.logDir?.startsWith("~")) {
+    config.logging.logDir = config.logging.logDir.replace(/^~/, homedir());
+  }
+
+  return config;
+}
+
+// ── Agent policy resolver ────────────────────────────────────────────
+
+export type AgentPolicy = "none" | "readonly" | "readwrite";
+
+export function resolveAgentPolicy(
+  agentName: string,
+  config: Partial<OmemPluginConfig>,
+): AgentPolicy {
+  return config.agentMemoryPolicy?.[agentName] ?? config.defaultPolicy ?? "readwrite";
+}
+
+export { DEFAULTS };

package/src/hooks.ts

@@ -1,8 +1,8 @@
 import type { Model, UserMessage, Part } from "@opencode-ai/sdk";
-import type { OmemClient, SearchResult } from "./client.js";
-import type { OmemPluginConfig } from "./config.js";
+import type { CerebroClient, SearchResult } from "./client.js";
+import { type OmemPluginConfig, resolveAgentPolicy } from "./config.js";
 import { detectKeyword, KEYWORD_NUDGE } from "./keywords.js";
-import { logDebug, logError as logErr } from "./logger.js";
+import { logDebug, logInfo, logError as logErr } from "./logger.js";
 import { readFile } from "node:fs/promises";
 
 const projectNameCache = new Map<string, string>();
@@ -182,12 +182,12 @@ function buildContextBlock(results: SearchResult[], maxContentLength: number = 5
   }
 
   return [
-    "<omem-context>",
+    "<cerebro-context>",
     "Treat every memory below as historical context only.",
     "Do not repeat these memories verbatim unless asked.",
     "",
     ...sections,
-    "</omem-context>",
+    "</cerebro-context>",
   ].join("\n");
 }
 
@@ -220,20 +220,20 @@ function buildClusteredContextBlock(clustered: import("./client.js").ClusteredRe
   }
 
   return [
-    "<omem-context>",
+    "<cerebro-context>",
     "Treat every memory below as historical context only.",
     "Do not repeat these memories verbatim unless asked.",
     "",
     ...sections,
-    "</omem-context>",
+    "</cerebro-context>",
   ].join("\n");
 }
 
-export function autoRecallHook(client: OmemClient, containerTags: string[], tui: any, config: Partial<OmemPluginConfig> = {}) {
-  const similarityThreshold = config.similarityThreshold ?? 0.6;
-  const maxRecallResults = config.maxRecallResults ?? 10;
-  const maxContentLength = config.maxContentLength ?? 500;
-  const toastDelayMs = config.toastDelayMs ?? 7000;
+export function autoRecallHook(client: CerebroClient, containerTags: string[], tui: any, config: Partial<OmemPluginConfig> = {}) {
+  const similarityThreshold = config.recall?.similarityThreshold ?? 0.6;
+  const maxRecallResults = config.recall?.maxRecallResults ?? 10;
+  const maxContentLength = config.content?.maxContentLength ?? 500;
+  const toastDelayMs = config.ui?.toastDelayMs ?? 7000;
 
   return async (
     input: { sessionID?: string; model: Model },
@@ -241,7 +241,13 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
   ) => {
     if (!input.sessionID) return;
 
+    // 5a: agent memory policy check — skip recall entirely for 'none' agents
+    const agentId = process.env.OMEM_AGENT_ID || "opencode";
+    const policy = resolveAgentPolicy(agentId, config);
+    if (policy === "none") return;
+
     try {
+      logDebug("autoRecallHook start", { sessionId: input.sessionID, agentId, policy });
       const messages = sessionMessages.get(input.sessionID) ?? [];
       const userMessages = messages.filter((m) => m.role === "user");
       const rawQuery = userMessages[userMessages.length - 1]?.content || firstMessages.get(input.sessionID) || "";
@@ -255,15 +261,16 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
         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, clustered: !!shouldRecallRes.clustered });
 
       const profile = await client.getProfile();
       let profileInjected = false;
       let profileCountText = "";
       if (profile && !profileInjectedSessions.has(input.sessionID)) {
         const profileBlock = [
-          "<omem-profile>",
+          "<cerebro-profile>",
           JSON.stringify(profile, null, 2),
-          "</omem-profile>",
+          "</cerebro-profile>",
         ].join("\n");
         output.system.push(profileBlock);
         profileInjected = true;
@@ -272,6 +279,7 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
         const dynamicCount = p?.dynamic_context?.length ?? 0;
         const staticCount = p?.static_facts?.length ?? 0;
         profileCountText = `Dynamic(${dynamicCount}) · Static(${staticCount})`;
+        logDebug("autoRecallHook profile injected", { dynamicCount, staticCount });
       }
 
       if (!shouldRecallRes.should_recall) {
@@ -286,6 +294,7 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
 
       const existingIds = injectedMemoryIds.get(input.sessionID) ?? new Set<string>();
       const newResults = results.filter((r) => !existingIds.has(r.memory.id));
+      logDebug("autoRecallHook dedup", { totalResults: results.length, existingCount: existingIds.size, newCount: newResults.length });
       if (newResults.length === 0) {
         if (profileInjected) {
           showToast(tui, "👨 Profile Injected", `${profileCountText} · all memories already injected`, "success", toastDelayMs);
@@ -302,6 +311,7 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
 
       const newIds = newResults.map((r) => r.memory.id);
       injectedMemoryIds.set(input.sessionID, new Set([...existingIds, ...newIds]));
+      logDebug("autoRecallHook injection complete", { newIds: newIds.length, clustered: !!clustered });
 
       const recordResult = await client.recordSessionRecall(
         input.sessionID,
@@ -355,9 +365,9 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
-      if (errMsg.includes("[omem]")) {
+      if (errMsg.includes("[cerebro]")) {
         // Server returned error (500, etc.) with details
-        const cleanMsg = errMsg.replace(/^\[omem\]\s*/, "");
+        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")) {
@@ -374,7 +384,8 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
   };
 }
 
-export function keywordDetectionHook(_client: OmemClient, _containerTags: string[], threshold: number, _tui: any, _ingestMode: "smart" | "raw" = "smart") {
+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[] },
@@ -392,6 +403,12 @@ export function keywordDetectionHook(_client: OmemClient, _containerTags: string
 
     if (detectKeyword(textContent)) {
       keywordDetectedSessions.add(input.sessionID);
+      logDebug("keywordDetectionHook triggered", { sessionId: input.sessionID });
+    }
+
+    const policy = resolveAgentPolicy(effectiveAgentId, config);
+    if (policy === "none") {
+      return;
     }
 
     if (!sessionMessages.has(input.sessionID)) {
@@ -403,55 +420,69 @@ export function keywordDetectionHook(_client: OmemClient, _containerTags: string
     });
 
     const messages = sessionMessages.get(input.sessionID)!;
-    // Ingest is now handled by sessionIdleHook (session.idle → sessionIngest API).
-    // This hook only collects messages and detects keywords for recall.
     if (messages.length >= threshold) {
       // Threshold reached — messages will be processed on next session.idle
     }
   };
 }
 
-export function compactingHook(client: OmemClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart", isAutoStoreEnabled?: (sessionId: string | undefined) => boolean, getMainSessionId?: () => string | undefined, sdkClient?: any) {
+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) {
+  const effectiveAgentId = agentId || process.env.OMEM_AGENT_ID || "opencode";
   return async (
     input: { sessionID?: string },
     output: { context: string[]; prompt?: string },
   ) => {
+    // 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) {
+        output.context.push(block);
+      }
+    } catch {
+    }
+
+    // Policy gate: only readwrite agents can write memories
+    const policy = resolveAgentPolicy(effectiveAgentId, config);
+    if (policy !== "readwrite") {
+      logInfo("compactingHook blocked by policy", { agentId: effectiveAgentId, policy });
+      if (input.sessionID) sessionMessages.delete(input.sessionID);
+      return;
+    }
+
     if (input.sessionID && sessionMessages.has(input.sessionID)) {
       if (isAutoStoreEnabled && !isAutoStoreEnabled(input.sessionID)) {
         sessionMessages.delete(input.sessionID);
       } else {
         const messages = sessionMessages.get(input.sessionID)!;
         if (messages.length > 0) {
+
           // Use main session ID for sub-agent sessions so memories merge into the main session
           const effectiveSessionId = (getMainSessionId?.() || input.sessionID);
-          const isSubAgent = getMainSessionId?.() && input.sessionID !== getMainSessionId();
 
           // Detect project name from session info
           let projectName: string | undefined;
           try {
             if (sdkClient && input.sessionID) {
               const sessionInfo = await sdkClient.session.get({ path: { id: input.sessionID } });
-              logDebug("compactingHook sessionInfo", { sessionInfo: JSON.stringify(sessionInfo) });
               logDebug("compactingHook project.rootPath", { rootPath: sessionInfo?.data?.directory });
               projectName = sessionInfo?.data?.directory
                 ? await detectProjectName(sessionInfo.data.directory)
                 : undefined;
-              logDebug("compactingHook projectName", { projectName: String(projectName) });
             }
           } catch (e) {
             logErr("compactingHook detectProjectName failed", { error: String(e) });
           }
 
           try {
-            logDebug("compactingHook ingestMessages called", { msgCount: messages.length, projectName: String(projectName), sessionId: effectiveSessionId });
+            logInfo("compactingHook ingestMessages called", { msgCount: messages.length, sessionId: effectiveSessionId });
             const result = await client.ingestMessages(messages, {
               mode: ingestMode,
               tags: [...containerTags, "auto-capture"],
               sessionId: effectiveSessionId,
-              parentSessionId: isSubAgent ? getMainSessionId?.() : undefined,
               projectName: projectName,
             });
-            logDebug("compactingHook ingestMessages result", { result: result === null ? "null(blocked)" : "ok" });
+            logInfo("compactingHook ingestMessages result", { result: result === null ? "null(blocked)" : "ok" });
             if (result === null) {
               showToast(tui, "🔴 Archive Failed", "Session archive blocked · check spiritual realm status", "error");
             } else {
@@ -465,15 +496,6 @@ export function compactingHook(client: OmemClient, containerTags: string[], tui:
         }
       }
     }
-
-    try {
-      const results = await client.searchMemories("*", 20, undefined, containerTags);
-      const block = buildContextBlock(results);
-      if (block) {
-        output.context.push(block);
-      }
-    } catch {
-    }
   };
 }
 
@@ -481,7 +503,7 @@ const processedMessageIds = new Set<string>();
 const pluginStartTime = Date.now();
 
 export function sessionIdleHook(
-  omemClient: OmemClient,
+  cerebroClient: CerebroClient,
   _containerTags: string[],
   tui: any,
   sdkClient: any,
@@ -490,6 +512,7 @@ export function sessionIdleHook(
   getMainSessionId?: () => string | undefined,
   isAutoStoreEnabled?: (sessionId: string | undefined) => boolean,
   agentId?: string,
+  config: Partial<OmemPluginConfig> = {},
 ) {
   let idleTimeout: ReturnType<typeof setTimeout> | null = null;
   let isCapturing = false;
@@ -548,7 +571,13 @@ export function sessionIdleHook(
         if (!hasNewMessages || conversationMessages.length === 0) return;
 
         if (threshold > 1 && conversationMessages.length < threshold) {
-          // Log that we're waiting for more messages
+          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;
         }
 
@@ -556,21 +585,19 @@ export function sessionIdleHook(
         let projectName: string | undefined;
         try {
           const sessionInfo = await sdkClient.session.get({ path: { id: sessionID } });
-          logDebug("sessionIdleHook sessionInfo", { sessionInfo: JSON.stringify(sessionInfo) });
           logDebug("sessionIdleHook project.rootPath", { rootPath: sessionInfo?.data?.directory });
           sessionTitle = sessionInfo?.data?.title;
           projectName = sessionInfo?.data?.directory
             ? await detectProjectName(sessionInfo.data.directory)
             : undefined;
-          logDebug("sessionIdleHook projectName", { projectName: String(projectName) });
         } catch (e) {
           logErr("sessionIdleHook detectProjectName failed", { error: String(e) });
         }
 
         try {
-          logDebug("sessionIdleHook sessionIngest called", { msgCount: conversationMessages.length, projectName: String(projectName), sessionId: sessionID, title: String(sessionTitle) });
-          await omemClient.sessionIngest(conversationMessages, sessionID, agentId, sessionTitle, projectName);
-          logDebug("sessionIdleHook sessionIngest ok");
+          logInfo("sessionIdleHook sessionIngest called", { msgCount: conversationMessages.length, sessionId: sessionID, title: String(sessionTitle) });
+          await cerebroClient.sessionIngest(conversationMessages, sessionID, agentId, sessionTitle, projectName);
+          logInfo("sessionIdleHook sessionIngest ok");
           for (const id of newMessageIds) {
             processedMessageIds.add(id);
           }