ofiere-openclaw-plugin 4.29.0 → 4.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.29.0",
+  "version": "4.31.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 14 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, and agent brain (memory + self-improvement)",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/agent-resolver.ts

@@ -35,12 +35,12 @@ export async function resolveAgentId(
     return cache.get(cacheKey)!;
   }
 
-  // 2. Look up by name (case-insensitive)
+  // 2. Look up by name OR codename in a single query (v4.30.0 optimization)
   const { data: existing } = await supabase
     .from("agents")
     .select("id")
     .eq("user_id", userId)
-    .ilike("name", accountId)
+    .or(`name.ilike.${accountId},codename.ilike.${accountId}`)
     .limit(1)
     .single();
 
@@ -49,21 +49,7 @@ export async function resolveAgentId(
     return existing.id;
   }
 
-  // 3. Also try matching by codename
-  const { data: byCodename } = await supabase
-    .from("agents")
-    .select("id")
-    .eq("user_id", userId)
-    .ilike("codename", accountId)
-    .limit(1)
-    .single();
-
-  if (byCodename?.id) {
-    cache.set(cacheKey, byCodename.id);
-    return byCodename.id;
-  }
-
-  // 4. Auto-register a new agent
+  // 3. Auto-register a new agent
   const newId = `agent-${accountId.toLowerCase()}-${Date.now()}`;
   const { data: created } = await supabase
     .from("agents")

package/src/tools.ts

@@ -113,10 +113,16 @@ const SYSTEM_NAME_BLOCKLIST = new Set([
   "ofiere pm plugin", "ofiere-openclaw-plugin",
 ]);
 
+// Module-scoped brain context cache (v4.30.0)
+// Shared between registerBrainContextHook and BRAIN_OPS save_memory
+// so explicit saves invalidate the cache for immediate consistency.
+const brainCache = new Map<string, { text: string; at: number }>();
+
 function isSystemName(name: string): boolean {
   return SYSTEM_NAME_BLOCKLIST.has(name.toLowerCase().trim());
 }
 
+
 function createAgentResolver(
   api: any,
   supabase: SupabaseClient,
@@ -5095,7 +5101,9 @@ function registerBrainOps(
   userId: string,
   resolveAgent: (id?: string) => Promise<string | null>,
 ): void {
-  api.registerTool({
+  // Register as a FACTORY so OpenClaw passes ToolContext with agentAccountId.
+  // This is the primary fix for the Daisy→Celia misattribution bug.
+  api.registerTool((toolCtx: any) => ({
     name: "OFIERE_BRAIN_OPS",
     label: "Ofiere Brain Operations",
     description:
@@ -5165,6 +5173,21 @@ function registerBrainOps(
     async execute(_id: string, params: Record<string, unknown>) {
       const action = params.action as string;
 
+      // ── Resolve agent identity ──────────────────────────────────
+      // Priority: explicit param > factory context > resolver fallback
+      // The factory context (toolCtx) carries the actual calling agent's
+      // accountId from OpenClaw, fixing the Daisy→Celia misattribution.
+      const ctxAgentHint = toolCtx?.agentAccountId || toolCtx?.agentId || "";
+
+      async function resolveCallingAgent(explicitId?: string): Promise<string | null> {
+        // 1. Explicit param from LLM
+        if (explicitId && explicitId.trim()) return resolveAgent(explicitId);
+        // 2. OpenClaw tool context (the fix)
+        if (ctxAgentHint) return resolveAgent(ctxAgentHint);
+        // 3. Original resolver fallback
+        return resolveAgent();
+      }
+
       switch (action) {
         // ── Memory: Save ──
         case "save_memory": {
@@ -5174,7 +5197,7 @@ function registerBrainOps(
             if (!params.tier) missing.push("tier");
             if (missing.length > 0) return err(`Missing required: ${missing.join(", ")}`);
           }
-          const agentId = await resolveAgent(params.agent_id as string);
+          const agentId = await resolveCallingAgent(params.agent_id as string);
           if (!agentId) return err("Could not resolve agent_id");
 
           const tier = params.tier as string;
@@ -5196,13 +5219,19 @@ function registerBrainOps(
           }).select("id, tier, importance, decay_score, created_at").single();
 
           if (error) return err(error.message);
+
+          // Invalidate brain context cache so next prompt build sees the new memory
+          if (agentId) brainCache.delete(agentId);
+
           return ok({ message: `Memory saved to ${tier}`, memory: data });
         }
 
         // ── Memory: Recall (Full-text search) ──
         case "recall": {
           if (!params.query) return err("Missing required: query");
-          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+          const agentId = params.agent_id
+            ? await resolveAgent(params.agent_id as string)
+            : (ctxAgentHint ? await resolveAgent(ctxAgentHint) : null);
           const limit = (params.limit as number) || 20;
           const queryText = params.query as string;
 
@@ -5281,7 +5310,7 @@ function registerBrainOps(
             if (!params.category) missing.push("category");
             if (missing.length > 0) return err(`Missing required: ${missing.join(", ")}`);
           }
-          const agentId = await resolveAgent(params.agent_id as string);
+          const agentId = await resolveCallingAgent(params.agent_id as string);
           if (!agentId) return err("Could not resolve agent_id");
 
           const content = `[${params.category}] ${params.title}${params.detail ? `: ${params.detail}` : ""}`;
@@ -5305,7 +5334,9 @@ function registerBrainOps(
 
         // ── Learning: List (→ L4_rule query) ──
         case "list_learnings": {
-          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+          const agentId = params.agent_id
+            ? await resolveAgent(params.agent_id as string)
+            : (ctxAgentHint ? await resolveAgent(ctxAgentHint) : null);
           const limit = (params.limit as number) || 20;
 
           let q = supabase.from("agent_memories")
@@ -5331,7 +5362,7 @@ function registerBrainOps(
 
           if (params.resolution) {
             // Create a superseding memory with the resolution
-            const agentId = await resolveAgent(params.agent_id as string);
+            const agentId = await resolveCallingAgent(params.agent_id as string);
             const { data: newMem } = await supabase.from("agent_memories").insert({
               user_id: userId,
               agent_id: agentId || "system",
@@ -5364,7 +5395,7 @@ function registerBrainOps(
         case "save_entity": {
           if (!params.label) return err("Missing required: label");
           if (!params.node_type) return err("Missing required: node_type");
-          const agentId = await resolveAgent(params.agent_id as string);
+          const agentId = await resolveCallingAgent(params.agent_id as string);
           if (!agentId) return err("Could not resolve agent_id");
 
           const { data, error } = await supabase.from("knowledge_graph_nodes").insert({
@@ -5404,7 +5435,9 @@ function registerBrainOps(
         // ── Knowledge Graph: Query ──
         case "query_graph": {
           if (!params.query) return err("Missing required: query");
-          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+          const agentId = params.agent_id
+            ? await resolveAgent(params.agent_id as string)
+            : (ctxAgentHint ? await resolveAgent(ctxAgentHint) : null);
           const limit = (params.limit as number) || 20;
 
           let q = supabase.from("knowledge_graph_nodes")
@@ -5436,7 +5469,7 @@ function registerBrainOps(
 
         // ── Trajectory: Start ──
         case "start_trajectory": {
-          const agentId = await resolveAgent(params.agent_id as string);
+          const agentId = await resolveCallingAgent(params.agent_id as string);
           if (!agentId) return err("Could not resolve agent_id");
 
           const { data, error } = await supabase.from("execution_trajectories").insert({
@@ -5475,7 +5508,9 @@ function registerBrainOps(
 
         // ── Brain Status ──
         case "get_brain_status": {
-          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+          const agentId = params.agent_id
+            ? await resolveAgent(params.agent_id as string)
+            : (ctxAgentHint ? await resolveAgent(ctxAgentHint) : null);
           const now = new Date().toISOString();
 
           // Parallel queries for speed
@@ -5533,7 +5568,7 @@ function registerBrainOps(
           return err(`Unknown action "${action}". Valid: save_memory, recall, delete_memory, promote_memory, log_learning, list_learnings, resolve_learning, save_entity, link_entities, query_graph, start_trajectory, end_trajectory, get_brain_status`);
       }
     },
-  });
+  }));
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -5568,13 +5603,12 @@ export function registerTools(
   registerSOPOps(api, supabase, userId, resolveAgent);        // 13
   registerBrainOps(api, supabase, userId, resolveAgent);      // 14
 
-  // ── Inject brain context at bootstrap ──
-  // This loads the agent's active memories + unresolved learnings into the
-  // system prompt so the agent starts every conversation with full context.
-  // Runs async — does NOT block registration.
-  injectBrainContext(api, supabase, userId, fallbackAgentId).catch((e: any) => {
-    api.logger.warn?.(`[ofiere] Brain context injection failed: ${e?.message || e}`);
-  });
+  // ── Register dynamic brain context hook ──
+  // FIX (v4.30.0): Was injectBrainContext() which loaded once at registration.
+  // Now registers a before_prompt_build hook that dynamically resolves the
+  // calling agent from ctx.agentId and loads THAT agent's brain memories.
+  // Each agent sees its own brain context — Daisy sees Daisy's, Ivy sees Ivy's.
+  registerBrainContextHook(api, supabase, userId, fallbackAgentId);
 
   // ── Register agent_end hook for server-side brain extraction ──
   // This is the FIX for Bug 2: extraction was client-side only (useSocket.ts).
@@ -5596,6 +5630,10 @@ export function registerTools(
 // Extracts L1 raw fragments and lightweight L2 summaries.
 // Replaces the client-side extractBrainMemory() in useSocket.ts.
 // Requires allowConversationAccess: true in plugin config on the OpenClaw side.
+//
+// FIX (v4.30.0): OpenClaw passes (event, ctx: PluginHookAgentContext) where
+// ctx.agentId is the calling agent's accountId. Previously we only read the
+// event arg, causing all writes to fall back to the first DB agent alphabetically.
 
 function registerBrainExtractionHook(
   api: any,
@@ -5604,7 +5642,7 @@ function registerBrainExtractionHook(
   fallbackAgentId: string,
 ): void {
   try {
-    api.on("agent_end", async (event: any) => {
+    api.on("agent_end", async (event: any, ctx: any) => {
       try {
         // Extract messages from event — agent_end provides the conversation
         const messages: any[] = event?.messages || event?.context?.messages || [];
@@ -5635,9 +5673,14 @@ function registerBrainExtractionHook(
         // Skip trivial exchanges
         if (lastUser.length < 20 || lastAssistant.length < 30) return;
 
-        // Resolve agent identity from event context
-        const agentId = event?.agentId
+        // ── Agent identity resolution (FIX) ──────────────────────────
+        // Priority: ctx.agentId (from PluginHookAgentContext, the CORRECT source)
+        //         > event fields (legacy compat)
+        //         > fallbackAgentId (last resort)
+        const agentId = ctx?.agentId
+          || event?.agentId
           || event?.context?.agentId
+          || ctx?.sessionKey?.split?.(":")?.[0]
           || event?.sessionKey?.split?.(":")?.[0]
           || fallbackAgentId
           || "";
@@ -5653,12 +5696,16 @@ function registerBrainExtractionHook(
           // Use raw agentId
         }
 
-        const sessionKey = event?.sessionKey || event?.context?.sessionKey || undefined;
+        const sessionKey = ctx?.sessionKey || event?.sessionKey || event?.context?.sessionKey || undefined;
+
+        api.logger.debug?.(`[ofiere-brain] agent_end identity: ctx.agentId=${ctx?.agentId || "(none)"} event.agentId=${event?.agentId || "(none)"} resolved=${resolvedAgentId}`);
 
-        // ── Fast Stream: Write L1_focus ──
+        // ── Fast Stream: Write L1_focus + L2_episode in parallel ──
         const rawContent = `User: ${lastUser}\nAssistant: ${lastAssistant}`;
+        const immediateWrites: Promise<any>[] = [];
+
         if (rawContent.length > 50) {
-          await supabase.from("agent_memories").insert({
+          immediateWrites.push(supabase.from("agent_memories").insert({
             user_id: userId,
             agent_id: resolvedAgentId,
             tier: "L1_focus",
@@ -5667,16 +5714,14 @@ function registerBrainExtractionHook(
             importance: 3,
             context_key: sessionKey ? `conversation:${sessionKey}` : null,
             expires_at: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString(),
-          });
+          }));
         }
 
-        // ── Lightweight L2 episode summary ──
         if (lastUser.length + lastAssistant.length > 200) {
           const userSummary = lastUser.split(/[.!?]\s/)[0];
           const assistSummary = lastAssistant.split(/[.!?]\s/)[0];
           const episodeSummary = `User asked: "${userSummary}". Agent responded: "${assistSummary}"`;
-
-          await supabase.from("agent_memories").insert({
+          immediateWrites.push(supabase.from("agent_memories").insert({
             user_id: userId,
             agent_id: resolvedAgentId,
             tier: "L2_episode",
@@ -5684,70 +5729,86 @@ function registerBrainExtractionHook(
             source: "auto",
             importance: 4,
             context_key: sessionKey ? `episode:${sessionKey}` : null,
-          });
+          }));
         }
 
-        // ── Rule-based L3/L4 extraction from user message ──
-        // Extract factual statements → L3_pattern
+        // Fire L1+L2 writes in parallel (no await needed between them)
+        await Promise.all(immediateWrites);
+
+        // ── Batched L3/L4 extraction (v4.30.0 optimization) ──
+        // Collect all candidates first, dedup in one parallel batch, insert in one batch.
         const factPatterns = [
           /(?:my name is|i'm called|call me)\s+(\w+)/gi,
           /(?:i (?:work|am working) (?:at|for|with))\s+(.+?)(?:\.|,|$)/gi,
           /(?:i (?:like|love|prefer|enjoy|hate|dislike))\s+(.+?)(?:\.|,|$)/gi,
           /(?:i (?:am|'m))\s+(?:a|an)\s+(.+?)(?:\.|,|$)/gi,
         ];
+        const rulePatterns = [
+          /(?:always|never|make sure|don't|do not|please always)\s+(.+?)(?:\.|!|$)/gi,
+          /(?:remember to|keep in mind|note that)\s+(.+?)(?:\.|!|$)/gi,
+        ];
+
+        // Phase 1: Collect all regex candidates
+        type MemCandidate = { tier: string; content: string; contextKey: string; importance: number };
+        const candidates: MemCandidate[] = [];
 
         for (const pattern of factPatterns) {
-          const matches = lastUser.matchAll(pattern);
-          for (const match of matches) {
+          for (const match of lastUser.matchAll(pattern)) {
             const fact = match[0].trim();
-            const contextKey = `fact:${fact.slice(0, 50).toLowerCase().replace(/\s+/g, "_")}`;
-            // Dedup: check if context_key already exists
-            const { data: existing } = await supabase.from("agent_memories")
-              .select("id").eq("user_id", userId).eq("agent_id", resolvedAgentId)
-              .eq("context_key", contextKey).is("superseded_by", null).limit(1);
-            if (existing && existing.length > 0) continue;
-
-            await supabase.from("agent_memories").insert({
-              user_id: userId,
-              agent_id: resolvedAgentId,
+            candidates.push({
               tier: "L3_pattern",
               content: fact,
-              source: "auto",
+              contextKey: `fact:${fact.slice(0, 50).toLowerCase().replace(/\s+/g, "_")}`,
               importance: 6,
-              context_key: contextKey,
             });
           }
         }
-
-        // Extract directives → L4_rule
-        const rulePatterns = [
-          /(?:always|never|make sure|don't|do not|please always)\s+(.+?)(?:\.|!|$)/gi,
-          /(?:remember to|keep in mind|note that)\s+(.+?)(?:\.|!|$)/gi,
-        ];
-
         for (const pattern of rulePatterns) {
-          const matches = lastUser.matchAll(pattern);
-          for (const match of matches) {
+          for (const match of lastUser.matchAll(pattern)) {
             const rule = match[0].trim();
             if (rule.length < 10) continue;
-            const contextKey = `rule:${rule.slice(0, 50).toLowerCase().replace(/\s+/g, "_")}`;
-            const { data: existing } = await supabase.from("agent_memories")
-              .select("id").eq("user_id", userId).eq("agent_id", resolvedAgentId)
-              .eq("context_key", contextKey).is("superseded_by", null).limit(1);
-            if (existing && existing.length > 0) continue;
-
-            await supabase.from("agent_memories").insert({
-              user_id: userId,
-              agent_id: resolvedAgentId,
+            candidates.push({
               tier: "L4_rule",
               content: rule,
-              source: "auto",
+              contextKey: `rule:${rule.slice(0, 50).toLowerCase().replace(/\s+/g, "_")}`,
               importance: 7,
-              context_key: contextKey,
             });
           }
         }
 
+        // Phase 2: Parallel dedup check (1 query per candidate, all at once)
+        if (candidates.length > 0) {
+          const dedupResults = await Promise.all(
+            candidates.map(c =>
+              supabase.from("agent_memories")
+                .select("id")
+                .eq("user_id", userId)
+                .eq("agent_id", resolvedAgentId)
+                .eq("context_key", c.contextKey)
+                .is("superseded_by", null)
+                .limit(1)
+            )
+          );
+
+          // Phase 3: Batch insert only new candidates
+          const toInsert = candidates
+            .filter((_, i) => !dedupResults[i].data?.length)
+            .map(c => ({
+              user_id: userId,
+              agent_id: resolvedAgentId,
+              tier: c.tier,
+              content: c.content,
+              source: "auto" as const,
+              importance: c.importance,
+              context_key: c.contextKey,
+              decay_score: 1.0,
+            }));
+
+          if (toInsert.length > 0) {
+            await supabase.from("agent_memories").insert(toInsert);
+          }
+        }
+
         api.logger.debug?.(`[ofiere-brain] Extracted memory for agent=${resolvedAgentId} session=${sessionKey || "none"}`);
       } catch (e) {
         // Silent — brain extraction must never block chat
@@ -5762,79 +5823,98 @@ function registerBrainExtractionHook(
 }
 
 // ── Brain Context Bootstrap Injection ──────────────────────────────────────
-// Queries the agent's active memories at boot and injects them into the system
-// prompt via api.on("before_prompt_build"). Uses the TMT hierarchy:
+// Injects the calling agent's active memories into the system prompt via
+// api.on("before_prompt_build"). Uses the TMT hierarchy:
 //   L1_focus  — active working memory (not expired, sorted by importance)
-//   L4_rule   — operational guardrails (source='reflection', sorted by importance)
+//   L4_rule   — operational guardrails (non-superseded, sorted by importance)
 //   L5_persona — identity context (permanent, top 3)
-// Runs once at registration time (~20ms, 3 parallel queries).
+//
+// FIX (v4.30.0): Previously loaded brain context ONCE at registration time
+// using fallbackAgentId (= first agent alphabetically). Now the hook is
+// DYNAMIC — it reads ctx.agentId from the PluginHookAgentContext passed by
+// OpenClaw on every prompt build, resolves the correct agent, and loads
+// that specific agent's brain. Each agent gets its own memories.
 
-async function injectBrainContext(
+function registerBrainContextHook(
   api: any,
   supabase: SupabaseClient,
   userId: string,
-  agentId: string,
-): Promise<void> {
-  if (!agentId) return;
-
-  const now = new Date().toISOString();
+  fallbackAgentId: string,
+): void {
+  // Uses module-scoped brainCache (declared at top of file) for cross-function
+  // invalidation. save_memory calls brainCache.delete(agentId) for immediate consistency.
+  const CACHE_TTL_MS = 300_000;
 
-  const [l1Res, l4Res, l5Res] = await Promise.all([
-    // L1: Active working memory (not expired)
-    supabase.from("agent_memories")
-      .select("content, importance")
-      .eq("user_id", userId)
-      .eq("agent_id", agentId)
-      .eq("tier", "L1_focus")
-      .gt("decay_score", 0.1)
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .limit(5),
-    // L4: Guardrails (non-superseded reflections)
-    supabase.from("agent_memories")
-      .select("content, importance")
-      .eq("user_id", userId)
-      .eq("agent_id", agentId)
-      .eq("tier", "L4_rule")
-      .is("superseded_by", null)
-      .order("importance", { ascending: false })
-      .limit(10),
-    // L5: Persona (permanent identity)
-    supabase.from("agent_memories")
-      .select("content")
-      .eq("user_id", userId)
-      .eq("agent_id", agentId)
-      .eq("tier", "L5_persona")
-      .order("importance", { ascending: false })
-      .limit(3),
-  ]);
+  try {
+    api.on("before_prompt_build", async (_event: any, ctx: any) => {
+      try {
+        // ── Resolve which agent is building its prompt ──
+        const ctxAgentId = ctx?.agentId || "";
+        let resolvedAgentId = fallbackAgentId;
 
-  const l1 = l1Res.data || [];
-  const l4 = l4Res.data || [];
-  const l5 = l5Res.data || [];
+        if (ctxAgentId && !isSystemName(ctxAgentId)) {
+          try {
+            const resolved = await resolveAgentId(ctxAgentId, userId, supabase);
+            if (resolved) resolvedAgentId = resolved;
+          } catch {
+            // Fall through to fallback
+          }
+        }
 
-  if (l1.length === 0 && l4.length === 0 && l5.length === 0) return;
+        if (!resolvedAgentId) return;
 
-  const sections: string[] = [];
+        // ── Check cache ──
+        const cached = brainCache.get(resolvedAgentId);
+        if (cached && Date.now() - cached.at < CACHE_TTL_MS) {
+          return cached.text ? { appendSystemContext: cached.text } : undefined;
+        }
 
-  if (l5.length > 0) {
-    sections.push("### Identity (L5_persona)\n" + l5.map((m: any) => `- ${m.content}`).join("\n"));
-  }
+        // ── Query brain memories for THIS specific agent ──
+        // v4.30.0: Single combined query instead of 3 separate tier queries.
+        const now = new Date().toISOString();
 
-  if (l4.length > 0) {
-    sections.push("### ⚠️ Guardrails (L4_rule — DO NOT violate)\n" + l4.map((m: any) => `- ${m.content}`).join("\n"));
-  }
+        const { data: allBrain } = await supabase
+          .from("agent_memories")
+          .select("content, importance, tier")
+          .eq("user_id", userId)
+          .eq("agent_id", resolvedAgentId)
+          .in("tier", ["L1_focus", "L4_rule", "L5_persona"])
+          .gt("decay_score", 0.1)
+          .is("superseded_by", null)
+          .or(`expires_at.is.null,expires_at.gt.${now}`)
+          .order("importance", { ascending: false })
+          .limit(18); // 5 L1 + 10 L4 + 3 L5
+
+        // Client-side split by tier
+        const all = allBrain || [];
+        const l1 = all.filter((m: any) => m.tier === "L1_focus").slice(0, 5);
+        const l4 = all.filter((m: any) => m.tier === "L4_rule").slice(0, 10);
+        const l5 = all.filter((m: any) => m.tier === "L5_persona").slice(0, 3);
+
+        if (l1.length === 0 && l4.length === 0 && l5.length === 0) {
+          brainCache.set(resolvedAgentId, { text: "", at: Date.now() });
+          return;
+        }
 
-  if (l1.length > 0) {
-    sections.push("### Active Focus (L1_focus)\n" + l1.map((m: any) => `- ${m.content}`).join("\n"));
-  }
+        const sections: string[] = [];
+        if (l5.length > 0) {
+          sections.push("### Identity (L5_persona)\n" + l5.map((m: any) => `- ${m.content}`).join("\n"));
+        }
+        if (l4.length > 0) {
+          sections.push("### ⚠️ Guardrails (L4_rule — DO NOT violate)\n" + l4.map((m: any) => `- ${m.content}`).join("\n"));
+        }
+        if (l1.length > 0) {
+          sections.push("### Active Focus (L1_focus)\n" + l1.map((m: any) => `- ${m.content}`).join("\n"));
+        }
 
-  const brainContext = `<agent-brain>\n## Your Brain Context (TMT)\n\n${sections.join("\n\n")}\n</agent-brain>`;
+        const brainContext = `<agent-brain>\n## Your Brain Context (TMT)\n\n${sections.join("\n\n")}\n</agent-brain>`;
+        brainCache.set(resolvedAgentId, { text: brainContext, at: Date.now() });
 
-  try {
-    api.on("before_prompt_build", () => ({
-      appendSystemContext: brainContext,
-    }));
+        return { appendSystemContext: brainContext };
+      } catch (e) {
+        api.logger.debug?.(`[ofiere-brain] before_prompt_build error: ${e instanceof Error ? e.message : e}`);
+      }
+    });
   } catch {
     api.logger.debug?.("[ofiere] Could not register brain context hook — appendSystemContext may not be supported");
   }