ofiere-openclaw-plugin 4.25.0 → 4.27.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.25.0",
+  "version": "4.27.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM - 13 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, and SOP management",
+  "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"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/prompt.ts

@@ -150,6 +150,19 @@ const TOOL_DOCS: Record<string, string> = {
     - Status values: draft, active, archived
     - SOPs appear in the SOP Manager page immediately via real-time sync
     - ADAPTIVE PROTOCOL: Do NOT always load SOPs. See the SOP PROTOCOL section in Rules for when to load vs skip`,
+
+  OFIERE_BRAIN_OPS: `- **OFIERE_BRAIN_OPS** — Agent memory and self-improvement (action: "save_memory", "recall", "delete_memory", "log_learning", "list_learnings", "promote_learning", "resolve_learning", "get_brain_status", "configure_brain")
+    - Memory Tiers: L1_focus (working memory, 24h TTL), L2_journal (medium-term events), L3_core (long-term wisdom)
+    - save_memory: Store a memory. Required: content, tier. Optional: agent_id, source, context_key, importance (1-10)
+    - recall: Search memories by keyword. Required: query. Optional: agent_id, tier, limit
+    - delete_memory: Remove a memory. Required: memory_id
+    - log_learning: Record a self-improvement entry. Required: title, category (correction|error|insight|best_practice|feature_request). Optional: agent_id, detail, severity, source_conversation_id, source_task_id
+    - list_learnings: View learnings. Optional: agent_id, category, status, limit
+    - promote_learning: Elevate to production config. Required: learning_id, promoted_to (soul|agents|tools|sop|prompt_chunk)
+    - resolve_learning: Mark resolved/wont_fix. Required: learning_id, status. Optional: resolution
+    - get_brain_status: Memory/learning stats + config. Optional: agent_id
+    - configure_brain: Update brain settings. Required: agent_id. Optional: l1_ttl_hours, l2_max_entries, auto_learn, auto_memory
+    - This is your SUBCONSCIOUS — use it instinctively, not deliberately`,
 };
 
 export function getSystemPrompt(state: {
@@ -222,6 +235,13 @@ ${toolDocs}
 - When creating SOPs for department chiefs (Thalia=CMO, Ivy=COO, Daisy=CTO-Intel, Celia=CTO-Eng), tailor content to their domain expertise.
 - Prerequisites should be actionable checklist items. Success criteria should be measurable outcomes.
 - After creating an SOP, suggest the agent set it to "active" status when ready for execution.
+- PLANNING GATE: Before creating ANY task with 3+ execution steps, a due_date, or when the user describes a multi-phase project, ALWAYS ask: "Should I create a Plan first so you can review the structure before I create individual tasks?" If the user says yes, use OFIERE_PLAN_OPS. If they say no or it's a simple one-shot task, proceed directly with OFIERE_TASK_OPS.
+- TASK PLACEMENT — SOP-AWARE ROUTING: When creating a task, the system auto-assigns a PM space. But for FOLDER placement, follow this protocol:
+  1. If the user explicitly provides space_id or folder_id, use those directly.
+  2. If not, and you have active SOPs (loaded via 🔴 COMPLEX assessment), check if any SOP defines an operating structure or folder routing (e.g. "place marketing tasks in Marketing/Campaigns"). Follow the SOP's structure.
+  3. If no SOP guidance exists, check the Space Files tab for an operating map/structure document using OFIERE_FILE_OPS action:"list_files". If found, read it with "read_text_file" and follow its routing rules.
+  4. If no routing guidance exists at all, ask the user: "I can place this task in your default space root, or create a new folder/project for it. Which do you prefer?"
+  5. Do NOT blindly dump all SOPs to check routing — smart-select only SOPs whose title/department matches the task domain.
 
 ## SOP PROTOCOL — Adaptive Complexity Assessment
 
@@ -266,6 +286,32 @@ Action:
 - When you load SOPs (🔴): state which SOP(s) you're following
 - When you ask about SOPs (🟡): keep the question brief and direct
 - When you skip SOPs (🟢): do NOT mention SOPs at all — just execute silently
+
+## Agent Brain Protocol (Subconscious)
+
+Your brain persists across conversations. Active memories and unresolved learnings are injected at startup.
+
+### Auto-Memory (OFIERE_BRAIN_OPS save_memory)
+After interactions where ANY of these occur, call save_memory:
+- User shares important context about themselves, preferences, or workflow → L2_journal, source: "conversation"
+- You complete a task with noteworthy results or discoveries → L2_journal, source: "task_execution"
+- You observe important system behavior worth tracking → L2_journal, source: "observation"
+- Something needs to stay in your working context RIGHT NOW → L1_focus (auto-expires)
+
+### Auto-Learn (OFIERE_BRAIN_OPS log_learning)
+After interactions where ANY of these occur, call log_learning:
+- User corrects you → category: "correction", severity: "medium"
+- A tool call fails or returns an error → category: "error"
+- User asks for something you can't do → category: "feature_request"
+- Your knowledge or assumption was wrong → category: "insight"
+- You discover a better approach than what you did → category: "best_practice"
+
+### Rules
+- These calls happen AFTER your response to the user — never delay your reply to save a memory
+- Do NOT announce "saving memory" or "logging learning" to the user — this is subconscious
+- Do NOT save trivial interactions (greetings, confirmations, simple CRUD) — only signal worth remembering
+- Keep memory content concise: 1-3 sentences max. No system junk, keep it human
+- When you see your unresolved learnings at startup, actively avoid repeating those mistakes
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -441,6 +441,61 @@ async function handleCreateTask(
       cf.assignees = [{ id: assignee, type: "agent" }];
     }
 
+    // ── Intelligent space_id resolution ──────────────────────────────────
+    // Priority: explicit param > agent's default_space_id > first existing space > auto-create
+    let resolvedSpaceId = (params.space_id as string) || null;
+    let resolvedFolderId = (params.folder_id as string) || null;
+    let spaceAutoCreated = false;
+
+    if (!resolvedSpaceId) {
+      try {
+        // 1. Check agent's configured default_space_id
+        if (assignee) {
+          const { data: agentRow } = await supabase
+            .from("agents")
+            .select("default_space_id")
+            .eq("id", assignee)
+            .eq("user_id", userId)
+            .single();
+          if (agentRow?.default_space_id) {
+            resolvedSpaceId = agentRow.default_space_id;
+          }
+        }
+
+        // 2. Fallback: use the first existing space for this user
+        if (!resolvedSpaceId) {
+          const { data: existingSpaces } = await supabase
+            .from("pm_spaces")
+            .select("id")
+            .eq("user_id", userId)
+            .order("created_at", { ascending: true })
+            .limit(1);
+          if (existingSpaces && existingSpaces.length > 0) {
+            resolvedSpaceId = existingSpaces[0].id;
+          }
+        }
+
+        // 3. Nuclear fallback: auto-create a space
+        if (!resolvedSpaceId) {
+          const newSpaceId = crypto.randomUUID();
+          const { error: spaceErr } = await supabase.from("pm_spaces").insert({
+            id: newSpaceId,
+            user_id: userId,
+            name: "Operations",
+            icon: "🏢",
+            icon_color: "#FF6D29",
+            sort_order: 0,
+          });
+          if (!spaceErr) {
+            resolvedSpaceId = newSpaceId;
+            spaceAutoCreated = true;
+          }
+        }
+      } catch {
+        // Non-fatal: task will still be created, just without space context
+      }
+    }
+
     const insertData: Record<string, unknown> = {
       id,
       user_id: userId,
@@ -450,8 +505,8 @@ async function handleCreateTask(
       assignee_type: "agent",
       status: (params.status as string) || "PENDING",
       priority: params.priority !== undefined ? params.priority : 1,
-      space_id: (params.space_id as string) || null,
-      folder_id: (params.folder_id as string) || null,
+      space_id: resolvedSpaceId,
+      folder_id: resolvedFolderId,
       start_date: (params.start_date as string) || null,
       due_date: (params.due_date as string) || (params.start_date as string) || null,
       tags: (params.tags as string[]) || [],
@@ -578,6 +633,17 @@ async function handleCreateTask(
       id,
       message: `Task "${params.title}" created and assigned to ${assignee || "no one"}${extrasStr}`,
       task: insertData,
+      spacePlacement: resolvedSpaceId
+        ? {
+            space_id: resolvedSpaceId,
+            auto_created: spaceAutoCreated,
+            note: spaceAutoCreated
+              ? 'A new "Operations" space was auto-created because no PM spaces existed.'
+              : resolvedFolderId
+                ? `Placed in folder ${resolvedFolderId}`
+                : "Placed in space root. To organize, check your SOPs/operating structure for folder routing, or specify folder_id.",
+          }
+        : undefined,
       scheduledExecution: didSchedule ? `Will auto-execute on ${startDate}` : undefined,
       recurrence: recurrenceInfo,
     });
@@ -5019,6 +5085,317 @@ async function handleSOPApplyTemplate(
 }
 
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 14: OFIERE_BRAIN_OPS — Agent Memory + Self-Improvement
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerBrainOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+): void {
+  api.registerTool({
+    name: "OFIERE_BRAIN_OPS",
+    label: "Ofiere Brain Operations",
+    description:
+      `Agent memory and self-improvement system. Persistent brain that learns, remembers, and never repeats mistakes.\n\n` +
+      `Memory Actions:\n` +
+      `- "save_memory": Store a memory. Required: content, tier (L1_focus|L2_journal|L3_core). Optional: agent_id, source, context_key, importance (1-10)\n` +
+      `- "recall": Search memories. Required: query. Optional: agent_id, tier, limit\n` +
+      `- "delete_memory": Remove a memory. Required: memory_id\n\n` +
+      `Learning Actions:\n` +
+      `- "log_learning": Record a self-improvement entry. Required: title, category (correction|error|insight|best_practice|feature_request). Optional: agent_id, detail, severity (low|medium|high|critical), source_conversation_id, source_task_id\n` +
+      `- "list_learnings": View learnings. Optional: agent_id, category, status, limit\n` +
+      `- "promote_learning": Promote to production. Required: learning_id, promoted_to (soul|agents|tools|sop|prompt_chunk)\n` +
+      `- "resolve_learning": Mark resolved/wont_fix. Required: learning_id, status (resolved|wont_fix). Optional: resolution\n\n` +
+      `Status Actions:\n` +
+      `- "get_brain_status": Memory counts, learning stats, config. Optional: agent_id\n` +
+      `- "configure_brain": Update brain settings. Required: agent_id. Optional: l1_ttl_hours, l2_max_entries, auto_learn, auto_memory\n\n` +
+      `Tier Guide: L1_focus = working memory (24h TTL), L2_journal = medium-term events, L3_core = long-term wisdom.\n` +
+      `This tool is your subconscious — call it after corrections, errors, discoveries, and insights.`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "save_memory", "recall", "delete_memory",
+            "log_learning", "list_learnings", "promote_learning", "resolve_learning",
+            "get_brain_status", "configure_brain",
+          ],
+        },
+        // Memory params
+        content: { type: "string", description: "Memory content or search query" },
+        tier: { type: "string", enum: ["L1_focus", "L2_journal", "L3_core"], description: "Memory tier" },
+        source: { type: "string", description: "Where memory came from: conversation, task_execution, observation, manual" },
+        context_key: { type: "string", description: "Grouping key (task_id, conversation_id, topic)" },
+        importance: { type: "number", description: "1-10 importance scale" },
+        memory_id: { type: "string", description: "Memory ID for delete" },
+        // Learning params
+        title: { type: "string", description: "Learning title/summary" },
+        category: { type: "string", enum: ["correction", "error", "insight", "best_practice", "feature_request"] },
+        severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
+        detail: { type: "string", description: "Full context of the learning" },
+        resolution: { type: "string", description: "How it was resolved" },
+        learning_id: { type: "string", description: "Learning ID for promote/resolve" },
+        status: { type: "string", enum: ["resolved", "wont_fix"] },
+        promoted_to: { type: "string", enum: ["soul", "agents", "tools", "sop", "prompt_chunk"] },
+        source_conversation_id: { type: "string" },
+        source_task_id: { type: "string" },
+        // Shared
+        agent_id: { type: "string", description: "Agent name or ID" },
+        query: { type: "string", description: "Search query for recall/list" },
+        limit: { type: "number", description: "Max results (default 20)" },
+        // Config params
+        l1_ttl_hours: { type: "number", description: "L1 memory expiry in hours (default 24)" },
+        l2_max_entries: { type: "number", description: "Max L2 entries before compaction (default 500)" },
+        auto_learn: { type: "boolean", description: "Enable auto-learning from corrections" },
+        auto_memory: { type: "boolean", description: "Enable auto-memory from conversations" },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+
+      switch (action) {
+        // ── Memory: Save ──
+        case "save_memory": {
+          if (!params.content || !params.tier) return err("Missing required: content, tier");
+          const agentId = await resolveAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const tier = params.tier as string;
+
+          // Calculate L1 expiry
+          let expiresAt: string | null = null;
+          if (tier === "L1_focus") {
+            // Check config for custom TTL
+            const { data: config } = await supabase
+              .from("agent_memory_config")
+              .select("l1_ttl_hours")
+              .eq("user_id", userId)
+              .eq("agent_id", agentId)
+              .single();
+            const ttlHours = config?.l1_ttl_hours || 24;
+            expiresAt = new Date(Date.now() + ttlHours * 60 * 60 * 1000).toISOString();
+          }
+
+          const { data, error } = await supabase.from("agent_memories").insert({
+            user_id: userId,
+            agent_id: agentId,
+            tier,
+            content: params.content,
+            source: (params.source as string) || "conversation",
+            context_key: (params.context_key as string) || null,
+            importance: (params.importance as number) || 5,
+            expires_at: expiresAt,
+          }).select("id, tier, importance, created_at").single();
+
+          if (error) return err(error.message);
+          return ok({ message: `Memory saved to ${tier}`, memory: data });
+        }
+
+        // ── Memory: Recall ──
+        case "recall": {
+          if (!params.query) return err("Missing required: query");
+          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+          const searchTerm = `%${params.query}%`;
+          const limit = (params.limit as number) || 20;
+
+          let q = supabase.from("agent_memories")
+            .select("id, agent_id, tier, content, source, context_key, importance, created_at")
+            .eq("user_id", userId)
+            .ilike("content", searchTerm)
+            .order("importance", { ascending: false })
+            .order("created_at", { ascending: false })
+            .limit(limit);
+
+          if (agentId) q = q.eq("agent_id", agentId);
+          if (params.tier) q = q.eq("tier", params.tier as string);
+
+          // Exclude expired L1 memories
+          q = q.or("expires_at.is.null,expires_at.gt." + new Date().toISOString());
+
+          const { data, error } = await q;
+          if (error) return err(error.message);
+          return ok({ memories: data || [], count: (data || []).length, query: params.query });
+        }
+
+        // ── Memory: Delete ──
+        case "delete_memory": {
+          if (!params.memory_id) return err("Missing required: memory_id");
+          const { error } = await supabase.from("agent_memories")
+            .delete()
+            .eq("id", params.memory_id as string)
+            .eq("user_id", userId);
+          if (error) return err(error.message);
+          return ok({ message: "Memory deleted", ok: true });
+        }
+
+        // ── Learning: Log ──
+        case "log_learning": {
+          if (!params.title || !params.category) return err("Missing required: title, category");
+          const agentId = await resolveAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const { data, error } = await supabase.from("agent_learnings").insert({
+            user_id: userId,
+            agent_id: agentId,
+            category: params.category,
+            severity: (params.severity as string) || "low",
+            title: params.title,
+            detail: (params.detail as string) || null,
+            source_conversation_id: (params.source_conversation_id as string) || null,
+            source_task_id: (params.source_task_id as string) || null,
+          }).select("id, category, severity, title, status, created_at").single();
+
+          if (error) return err(error.message);
+          return ok({ message: `Learning logged: "${params.title}"`, learning: data });
+        }
+
+        // ── Learning: List ──
+        case "list_learnings": {
+          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+          const limit = (params.limit as number) || 20;
+
+          let q = supabase.from("agent_learnings")
+            .select("id, agent_id, category, severity, title, detail, resolution, status, promoted_to, created_at, resolved_at")
+            .eq("user_id", userId)
+            .order("created_at", { ascending: false })
+            .limit(limit);
+
+          if (agentId) q = q.eq("agent_id", agentId);
+          if (params.category) q = q.eq("category", params.category as string);
+          if (params.status) q = q.eq("status", params.status as string);
+
+          const { data, error } = await q;
+          if (error) return err(error.message);
+          return ok({ learnings: data || [], count: (data || []).length });
+        }
+
+        // ── Learning: Promote ──
+        case "promote_learning": {
+          if (!params.learning_id || !params.promoted_to) return err("Missing required: learning_id, promoted_to");
+          const { data, error } = await supabase.from("agent_learnings")
+            .update({
+              status: "promoted",
+              promoted_to: params.promoted_to as string,
+              resolved_at: new Date().toISOString(),
+            })
+            .eq("id", params.learning_id as string)
+            .eq("user_id", userId)
+            .select("id, title, status, promoted_to")
+            .single();
+          if (error) return err(error.message);
+          return ok({ message: `Learning promoted to ${params.promoted_to}`, learning: data });
+        }
+
+        // ── Learning: Resolve ──
+        case "resolve_learning": {
+          if (!params.learning_id) return err("Missing required: learning_id");
+          const newStatus = (params.status as string) || "resolved";
+          if (!["resolved", "wont_fix"].includes(newStatus)) return err("status must be 'resolved' or 'wont_fix'");
+
+          const updates: Record<string, unknown> = {
+            status: newStatus,
+            resolved_at: new Date().toISOString(),
+          };
+          if (params.resolution) updates.resolution = params.resolution;
+
+          const { data, error } = await supabase.from("agent_learnings")
+            .update(updates)
+            .eq("id", params.learning_id as string)
+            .eq("user_id", userId)
+            .select("id, title, status, resolution")
+            .single();
+          if (error) return err(error.message);
+          return ok({ message: `Learning marked as ${newStatus}`, learning: data });
+        }
+
+        // ── Brain Status ──
+        case "get_brain_status": {
+          const agentId = params.agent_id ? await resolveAgent(params.agent_id as string) : null;
+
+          // Memory counts by tier
+          let memQ = supabase.from("agent_memories")
+            .select("tier")
+            .eq("user_id", userId)
+            .or("expires_at.is.null,expires_at.gt." + new Date().toISOString());
+          if (agentId) memQ = memQ.eq("agent_id", agentId);
+          const { data: memRows } = await memQ;
+
+          const tierCounts: Record<string, number> = { L1_focus: 0, L2_journal: 0, L3_core: 0 };
+          for (const row of memRows || []) {
+            const t = (row as any).tier;
+            tierCounts[t] = (tierCounts[t] || 0) + 1;
+          }
+
+          // Learning counts by status
+          let learnQ = supabase.from("agent_learnings")
+            .select("status, category")
+            .eq("user_id", userId);
+          if (agentId) learnQ = learnQ.eq("agent_id", agentId);
+          const { data: learnRows } = await learnQ;
+
+          const statusCounts: Record<string, number> = {};
+          const categoryCounts: Record<string, number> = {};
+          for (const row of learnRows || []) {
+            const s = (row as any).status;
+            const c = (row as any).category;
+            statusCounts[s] = (statusCounts[s] || 0) + 1;
+            categoryCounts[c] = (categoryCounts[c] || 0) + 1;
+          }
+
+          // Config
+          let configQ = supabase.from("agent_memory_config")
+            .select("*")
+            .eq("user_id", userId);
+          if (agentId) configQ = configQ.eq("agent_id", agentId);
+          const { data: configs } = await configQ;
+
+          return ok({
+            memories: { ...tierCounts, total: (memRows || []).length },
+            learnings: {
+              total: (learnRows || []).length,
+              by_status: statusCounts,
+              by_category: categoryCounts,
+            },
+            config: configs?.[0] || { l1_ttl_hours: 24, l2_max_entries: 500, auto_learn: true, auto_memory: true },
+          });
+        }
+
+        // ── Configure Brain ──
+        case "configure_brain": {
+          const agentId = await resolveAgent(params.agent_id as string);
+          if (!agentId) return err("Missing required: agent_id");
+
+          const configData: Record<string, unknown> = {
+            user_id: userId,
+            agent_id: agentId,
+          };
+          if (params.l1_ttl_hours !== undefined) configData.l1_ttl_hours = params.l1_ttl_hours;
+          if (params.l2_max_entries !== undefined) configData.l2_max_entries = params.l2_max_entries;
+          if (params.auto_learn !== undefined) configData.auto_learn = params.auto_learn;
+          if (params.auto_memory !== undefined) configData.auto_memory = params.auto_memory;
+
+          // Upsert by (user_id, agent_id)
+          const { data, error } = await supabase.from("agent_memory_config")
+            .upsert(configData, { onConflict: "user_id,agent_id" })
+            .select()
+            .single();
+
+          if (error) return err(error.message);
+          return ok({ message: `Brain config updated for agent`, config: data });
+        }
+
+        default:
+          return err(`Unknown action "${action}".`);
+      }
+    },
+  });
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -5049,12 +5426,104 @@ export function registerTools(
   registerFileOps(api, supabase, userId);                     // 11
   registerPlanOps(api, supabase, userId, resolveAgent);       // 12
   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}`);
+  });
 
   // ── Count and log ──
-  const toolCount = 13;
+  const toolCount = 14;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);
 
   return toolCount;
 }
+
+// ── Brain Context Bootstrap Injection ──────────────────────────────────────
+// Queries the agent's active memories and unresolved learnings, then appends
+// them to the system prompt via api.on("before_prompt_build"). This happens
+// once at registration time (per conversation) and costs ~20ms.
+
+async function injectBrainContext(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  agentId: string,
+): Promise<void> {
+  if (!agentId) return; // Can't inject without knowing which agent
+
+  const now = new Date().toISOString();
+
+  // Parallel queries — fast
+  const [l1Res, l3Res, learningsRes] = await Promise.all([
+    // Active L1 focus memories (not expired)
+    supabase.from("agent_memories")
+      .select("content, importance")
+      .eq("user_id", userId)
+      .eq("agent_id", agentId)
+      .eq("tier", "L1_focus")
+      .or(`expires_at.is.null,expires_at.gt.${now}`)
+      .order("importance", { ascending: false })
+      .limit(5),
+    // Recent L3 core (long-term wisdom)
+    supabase.from("agent_memories")
+      .select("content")
+      .eq("user_id", userId)
+      .eq("agent_id", agentId)
+      .eq("tier", "L3_core")
+      .order("created_at", { ascending: false })
+      .limit(3),
+    // Unresolved learnings (don't repeat mistakes)
+    supabase.from("agent_learnings")
+      .select("title, category, detail")
+      .eq("user_id", userId)
+      .eq("agent_id", agentId)
+      .eq("status", "pending")
+      .order("severity", { ascending: false })
+      .limit(10),
+  ]);
+
+  const l1 = l1Res.data || [];
+  const l3 = l3Res.data || [];
+  const learnings = learningsRes.data || [];
+
+  // Only inject if there's something to inject
+  if (l1.length === 0 && l3.length === 0 && learnings.length === 0) return;
+
+  const sections: string[] = [];
+
+  if (l1.length > 0) {
+    sections.push("### Active Focus (L1)\n" + l1.map((m: any) => `- ${m.content}`).join("\n"));
+  }
+
+  if (l3.length > 0) {
+    sections.push("### Core Wisdom (L3)\n" + l3.map((m: any) => `- ${m.content}`).join("\n"));
+  }
+
+  if (learnings.length > 0) {
+    sections.push(
+      "### ⚠️ Unresolved Learnings (DO NOT repeat these)\n" +
+      learnings.map((l: any) => `- [${l.category}] ${l.title}${l.detail ? `: ${l.detail}` : ""}`).join("\n")
+    );
+  }
+
+  const brainContext = `<agent-brain>\n## Your Brain Context\n\n${sections.join("\n\n")}\n</agent-brain>`;
+
+  // Append to the existing before_prompt_build hook
+  // We use a second hook — OpenClaw supports multiple listeners
+  try {
+    api.on("before_prompt_build", () => ({
+      appendSystemContext: brainContext,
+    }));
+  } catch {
+    // Fallback: log that injection wasn't possible
+    api.logger.debug?.("[ofiere] Could not register brain context hook — appendSystemContext may not be supported");
+  }
+}
+