ofiere-openclaw-plugin 4.27.2 → 4.28.0

package/openclaw.plugin.json

@@ -28,6 +28,9 @@
       }
     }
   },
+  "hooks": {
+    "allowConversationAccess": true
+  },
   "uiHints": {
     "enabled": {
       "label": "Enable Ofiere PM",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.27.2",
+  "version": "4.28.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/prompt.ts

@@ -151,17 +151,21 @@ const TOOL_DOCS: Record<string, string> = {
     - 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
+  OFIERE_BRAIN_OPS: `- **OFIERE_BRAIN_OPS** — Agent memory, knowledge graph, and self-improvement (TMT/MAGMA architecture)
+    - Memory Tiers: L1_focus (24h), L2_episode (days-weeks), L3_pattern (weeks-months), L4_rule (permanent guardrails), L5_persona (permanent identity)
+    - save_memory: Store a memory. Required: content, tier. Optional: agent_id, source (auto|manual|reflection|tool), context_key, importance (1-10)
+    - recall: Full-text search memories. 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
+    - promote_memory: Move memory up a tier. Required: memory_id, new_tier
+    - log_learning: Record as L4_rule guardrail. Required: title, category. Optional: agent_id, detail, severity
+    - list_learnings: View active L4 guardrails. Optional: agent_id, category, limit
+    - resolve_learning: Supersede a guardrail. Required: memory_id. Optional: resolution
+    - save_entity: Add to Knowledge Graph. Required: label, node_type (entity|concept|event|action). Optional: agent_id, properties
+    - link_entities: Connect graph nodes. Required: source_id, target_id, relation_type. Optional: graph_type, weight, evidence
+    - query_graph: Search Knowledge Graph. Required: query. Optional: agent_id, node_type, limit
+    - start_trajectory: Begin recording execution trace. Optional: agent_id, conversation_id
+    - end_trajectory: Close trajectory. Required: trajectory_id, outcome (success|failure|partial). Optional: satisfaction_signal
+    - get_brain_status: Full brain dashboard — memory tiers, graph stats, trajectory stats. Optional: agent_id
     - This is your SUBCONSCIOUS — use it instinctively, not deliberately`,
 };
 
@@ -287,31 +291,45 @@ Action:
 - 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)
+## Agent Brain Protocol (TMT Subconscious)
 
-Your brain persists across conversations. Active memories and unresolved learnings are injected at startup.
+Your brain persists across conversations via the TMT (Temporal Memory Tree) hierarchy. At startup, your L5 persona, L4 guardrails, and L1 focus memories are injected automatically.
 
 ### 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)
+- User shares important context → L2_episode, source: "auto"
+- You complete a task with noteworthy results → L2_episode, source: "tool"
+- You observe important system behavior → L2_episode, source: "auto"
+- Something needs immediate working context → L1_focus (auto-expires 24h)
+- A pattern emerges across multiple episodes → L3_pattern, source: "reflection"
 
 ### Auto-Learn (OFIERE_BRAIN_OPS log_learning)
-After interactions where ANY of these occur, call log_learning:
+After interactions where ANY of these occur, call log_learning (stored as L4_rule):
 - 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"
+- You discover a better approach → category: "best_practice"
+
+### Knowledge Graph (OFIERE_BRAIN_OPS save_entity/link_entities)
+When you encounter key entities, concepts, or causal relationships:
+- Create entities for users, projects, tools, or recurring concepts
+- Link entities with typed edges (causes, depends_on, related_to)
+- Query the graph when reasoning about relationships or dependencies
+
+### Trajectory Recording (OFIERE_BRAIN_OPS start_trajectory/end_trajectory)
+For complex multi-step tasks:
+- Call start_trajectory before executing a tool chain
+- Call end_trajectory with outcome when the chain completes
+- This feeds the ReasoningBank for autonomous self-improvement
 
 ### 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
+- When you see your L4 guardrails at startup, actively avoid violating them
+- Use promote_memory when a pattern solidifies: L2→L3→L4→L5
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -5099,56 +5099,67 @@ function registerBrainOps(
     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` +
+      `Agent memory, knowledge graph, and self-improvement system (TMT/MAGMA architecture).\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.`,
+      `- "save_memory": Store a memory. Required: content, tier. Optional: agent_id, source, context_key, importance (1-10)\n` +
+      `- "recall": Full-text search memories. Required: query. Optional: agent_id, tier, limit\n` +
+      `- "delete_memory": Remove a memory. Required: memory_id\n` +
+      `- "promote_memory": Move memory up a tier. Required: memory_id, new_tier\n\n` +
+      `Learning Actions (stored as L4_rule memories):\n` +
+      `- "log_learning": Record a self-improvement entry as L4 guardrail. Required: title, category (correction|error|insight|best_practice|feature_request). Optional: agent_id, detail, severity\n` +
+      `- "list_learnings": View L4 guardrails. Optional: agent_id, category, limit\n` +
+      `- "resolve_learning": Supersede a guardrail. Required: memory_id. Optional: resolution\n\n` +
+      `Knowledge Graph Actions:\n` +
+      `- "save_entity": Add entity/concept/event to graph. Required: label, node_type (entity|concept|event|action). Optional: agent_id, properties\n` +
+      `- "link_entities": Connect two nodes. Required: source_id, target_id, relation_type. Optional: graph_type (semantic|temporal|causal|entity), weight, evidence\n` +
+      `- "query_graph": Find nodes + edges. Required: query. Optional: agent_id, node_type, limit\n\n` +
+      `Trajectory Actions:\n` +
+      `- "start_trajectory": Begin recording execution trace. Optional: agent_id, conversation_id\n` +
+      `- "end_trajectory": Close trajectory. Required: trajectory_id, outcome (success|failure|partial). Optional: satisfaction_signal\n\n` +
+      `Status:\n` +
+      `- "get_brain_status": Full brain dashboard — memory tiers, graph stats, trajectory stats. Optional: agent_id\n\n` +
+      `Tiers: L1_focus (transient, 24h), L2_episode (days-weeks), L3_pattern (weeks-months), L4_rule (permanent guardrails), L5_persona (permanent identity).`,
     parameters: {
       type: "object",
       required: ["action"],
       properties: {
         action: {
           type: "string",
-          description: "The operation to perform: save_memory, recall, delete_memory, log_learning, list_learnings, promote_learning, resolve_learning, get_brain_status, configure_brain",
+          description: "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",
         },
         // 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" },
+        content: { type: "string", description: "Memory content" },
+        tier: { type: "string", enum: ["L1_focus", "L2_episode", "L3_pattern", "L4_rule", "L5_persona"], description: "Memory tier" },
+        new_tier: { type: "string", enum: ["L1_focus", "L2_episode", "L3_pattern", "L4_rule", "L5_persona"], description: "Target tier for promote" },
+        source: { type: "string", enum: ["auto", "manual", "reflection", "tool"], description: "Memory source" },
         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" },
+        memory_id: { type: "string", description: "Memory ID for delete/promote/resolve" },
         // 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: ["pending", "resolved", "wont_fix", "promoted"] },
-        promoted_to: { type: "string", enum: ["soul", "agents", "tools", "sop", "prompt_chunk"] },
-        source_conversation_id: { type: "string" },
-        source_task_id: { type: "string" },
+        // Knowledge Graph params
+        label: { type: "string", description: "Node label for save_entity" },
+        node_type: { type: "string", enum: ["entity", "concept", "event", "action"], description: "Graph node type" },
+        properties: { type: "object", description: "Arbitrary properties for graph node" },
+        source_id: { type: "string", description: "Source node ID for link_entities" },
+        target_id: { type: "string", description: "Target node ID for link_entities" },
+        relation_type: { type: "string", description: "Edge relation type (e.g. 'causes', 'related_to', 'depends_on')" },
+        graph_type: { type: "string", enum: ["semantic", "temporal", "causal", "entity"], description: "Graph type for edge" },
+        weight: { type: "number", description: "Edge weight (0-1)" },
+        evidence: { type: "string", description: "Evidence text for edge" },
+        // Trajectory params
+        trajectory_id: { type: "string", description: "Trajectory ID for end_trajectory" },
+        outcome: { type: "string", enum: ["success", "failure", "partial"], description: "Trajectory outcome" },
+        satisfaction_signal: { type: "string", description: "User satisfaction signal" },
+        conversation_id: { type: "string", description: "Conversation ID for trajectory" },
         // Shared
         agent_id: { type: "string", description: "Agent name or ID" },
-        query: { type: "string", description: "Search query for recall/list" },
+        query: { type: "string", description: "Search query for recall/query_graph" },
         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>) {
@@ -5167,19 +5178,9 @@ function registerBrainOps(
           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();
+            expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
           }
 
           const { data, error } = await supabase.from("agent_memories").insert({
@@ -5187,27 +5188,31 @@ function registerBrainOps(
             agent_id: agentId,
             tier,
             content: params.content,
-            source: (params.source as string) || "conversation",
+            source: (params.source as string) || "auto",
             context_key: (params.context_key as string) || null,
             importance: (params.importance as number) || 5,
+            decay_score: 1.0,
             expires_at: expiresAt,
-          }).select("id, tier, importance, created_at").single();
+          }).select("id, tier, importance, decay_score, created_at").single();
 
           if (error) return err(error.message);
           return ok({ message: `Memory saved to ${tier}`, memory: data });
         }
 
-        // ── Memory: Recall ──
+        // ── 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 searchTerm = `%${params.query}%`;
           const limit = (params.limit as number) || 20;
+          const queryText = params.query as string;
 
+          // Use full-text search via tsvector
           let q = supabase.from("agent_memories")
-            .select("id, agent_id, tier, content, source, context_key, importance, created_at")
+            .select("id, agent_id, tier, content, source, context_key, importance, decay_score, access_count, created_at, last_accessed_at")
             .eq("user_id", userId)
-            .ilike("content", searchTerm)
+            .textSearch("search_vector", queryText, { type: "plain" })
+            .gt("decay_score", 0.05)
+            .or("expires_at.is.null,expires_at.gt." + new Date().toISOString())
             .order("importance", { ascending: false })
             .order("created_at", { ascending: false })
             .limit(limit);
@@ -5215,12 +5220,31 @@ function registerBrainOps(
           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 });
+          if (error) {
+            // Fallback to ILIKE if tsvector search fails
+            let fallback = supabase.from("agent_memories")
+              .select("id, agent_id, tier, content, source, context_key, importance, decay_score, created_at")
+              .eq("user_id", userId)
+              .ilike("content", `%${queryText}%`)
+              .gt("decay_score", 0.05)
+              .or("expires_at.is.null,expires_at.gt." + new Date().toISOString())
+              .order("importance", { ascending: false })
+              .limit(limit);
+            if (agentId) fallback = fallback.eq("agent_id", agentId);
+            if (params.tier) fallback = fallback.eq("tier", params.tier as string);
+            const { data: fbData, error: fbErr } = await fallback;
+            if (fbErr) return err(fbErr.message);
+            return ok({ memories: fbData || [], count: (fbData || []).length, query: queryText, search_mode: "fallback" });
+          }
+
+          // Touch access_count + last_accessed_at for FadeMem
+          if (data && data.length > 0) {
+            const ids = data.map((m: any) => m.id);
+            supabase.rpc("touch_memories", { memory_ids: ids }).then(() => {}).catch(() => {});
+          }
+
+          return ok({ memories: data || [], count: (data || []).length, query: queryText, search_mode: "fulltext" });
         }
 
         // ── Memory: Delete ──
@@ -5234,7 +5258,22 @@ function registerBrainOps(
           return ok({ message: "Memory deleted", ok: true });
         }
 
-        // ── Learning: Log ──
+        // ── Memory: Promote ──
+        case "promote_memory": {
+          if (!params.memory_id) return err("Missing required: memory_id");
+          if (!params.new_tier) return err("Missing required: new_tier");
+          const { data, error } = await supabase.from("agent_memories")
+            .update({ tier: params.new_tier as string })
+            .eq("id", params.memory_id as string)
+            .eq("user_id", userId)
+            .select("id, tier, content, importance")
+            .single();
+          if (error) return err(error.message);
+          if (!data) return err("Memory not found");
+          return ok({ message: `Memory promoted to ${params.new_tier}`, memory: data });
+        }
+
+        // ── Learning: Log (→ L4_rule memory) ──
         case "log_learning": {
           {
             const missing: string[] = [];
@@ -5245,163 +5284,253 @@ function registerBrainOps(
           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({
+          const content = `[${params.category}] ${params.title}${params.detail ? `: ${params.detail}` : ""}`;
+          const severityToImportance: Record<string, number> = { low: 5, medium: 7, high: 8, critical: 10 };
+          const imp = severityToImportance[(params.severity as string) || "low"] || 5;
+
+          const { data, error } = await supabase.from("agent_memories").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();
+            tier: "L4_rule",
+            content,
+            source: "reflection",
+            context_key: (params.category as string) || null,
+            importance: imp,
+            decay_score: 1.0,
+          }).select("id, tier, content, importance, created_at").single();
 
           if (error) return err(error.message);
-          return ok({ message: `Learning logged: "${params.title}"`, learning: data });
+          return ok({ message: `Learning logged as L4 guardrail: "${params.title}"`, memory: data });
         }
 
-        // ── Learning: List ──
+        // ── Learning: List (→ L4_rule query) ──
         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")
+          let q = supabase.from("agent_memories")
+            .select("id, agent_id, tier, content, context_key, importance, decay_score, created_at, superseded_by")
             .eq("user_id", userId)
+            .eq("tier", "L4_rule")
+            .is("superseded_by", null)
+            .order("importance", { ascending: false })
             .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);
+          if (params.category) q = q.eq("context_key", params.category 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": {
-          {
-            const missing: string[] = [];
-            if (!params.learning_id) missing.push("learning_id");
-            if (!params.promoted_to) missing.push("promoted_to");
-            if (missing.length > 0) return err(`Missing required: ${missing.join(", ")}`);
+        // ── Learning: Resolve (supersede) ──
+        case "resolve_learning": {
+          if (!params.memory_id) return err("Missing required: memory_id");
+
+          if (params.resolution) {
+            // Create a superseding memory with the resolution
+            const agentId = await resolveAgent(params.agent_id as string);
+            const { data: newMem } = await supabase.from("agent_memories").insert({
+              user_id: userId,
+              agent_id: agentId || "system",
+              tier: "L4_rule",
+              content: `[resolved] ${params.resolution}`,
+              source: "reflection",
+              importance: 5,
+              decay_score: 1.0,
+            }).select("id").single();
+
+            if (newMem) {
+              await supabase.from("agent_memories")
+                .update({ superseded_by: newMem.id })
+                .eq("id", params.memory_id as string)
+                .eq("user_id", userId);
+            }
+            return ok({ message: "Learning resolved with new guardrail", superseded_by: newMem?.id });
           }
-          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)
+
+          // Just delete if no resolution
+          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: "Learning removed", ok: true });
+        }
+
+        // ── Knowledge Graph: Save Entity ──
+        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);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const { data, error } = await supabase.from("knowledge_graph_nodes").insert({
+            user_id: userId,
+            agent_id: agentId,
+            label: params.label as string,
+            node_type: params.node_type as string,
+            properties: (params.properties as Record<string, unknown>) || {},
+          }).select("id, label, node_type, created_at").single();
+
+          if (error) return err(error.message);
+          return ok({ message: `Entity "${params.label}" saved`, node: data });
+        }
+
+        // ── Knowledge Graph: Link Entities ──
+        case "link_entities": {
+          const missing: string[] = [];
+          if (!params.source_id) missing.push("source_id");
+          if (!params.target_id) missing.push("target_id");
+          if (!params.relation_type) missing.push("relation_type");
+          if (missing.length > 0) return err(`Missing required: ${missing.join(", ")}`);
+
+          const { data, error } = await supabase.from("knowledge_graph_edges").insert({
+            user_id: userId,
+            source_id: params.source_id as string,
+            target_id: params.target_id as string,
+            relation_type: params.relation_type as string,
+            graph_type: (params.graph_type as string) || "semantic",
+            weight: (params.weight as number) || 1.0,
+            evidence: (params.evidence as string) || null,
+          }).select("id, relation_type, graph_type, weight, created_at").single();
+
+          if (error) return err(error.message);
+          return ok({ message: `Edge "${params.relation_type}" created`, edge: data });
+        }
+
+        // ── 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 limit = (params.limit as number) || 20;
+
+          let q = supabase.from("knowledge_graph_nodes")
+            .select("id, agent_id, label, node_type, properties, created_at")
             .eq("user_id", userId)
-            .select("id, title, status, promoted_to")
-            .single();
+            .ilike("label", `%${params.query}%`)
+            .limit(limit);
+
+          if (agentId) q = q.eq("agent_id", agentId);
+          if (params.node_type) q = q.eq("node_type", params.node_type as string);
+
+          const { data: nodes, error } = await q;
           if (error) return err(error.message);
-          return ok({ message: `Learning promoted to ${params.promoted_to}`, learning: data });
+
+          // Fetch edges for found nodes
+          let edges: any[] = [];
+          if (nodes && nodes.length > 0) {
+            const nodeIds = nodes.map((n: any) => n.id);
+            const { data: edgeData } = await supabase.from("knowledge_graph_edges")
+              .select("id, source_id, target_id, relation_type, graph_type, weight, evidence")
+              .eq("user_id", userId)
+              .or(`source_id.in.(${nodeIds.join(",")}),target_id.in.(${nodeIds.join(",")})`)
+              .limit(50);
+            edges = edgeData || [];
+          }
+
+          return ok({ nodes: nodes || [], edges, node_count: (nodes || []).length, edge_count: edges.length });
         }
 
-        // ── 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'");
+        // ── Trajectory: Start ──
+        case "start_trajectory": {
+          const agentId = await resolveAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const { data, error } = await supabase.from("execution_trajectories").insert({
+            user_id: userId,
+            agent_id: agentId,
+            conversation_id: (params.conversation_id as string) || null,
+            trajectory: [],
+            outcome: "pending",
+            analysis_status: "pending",
+          }).select("id, agent_id, created_at").single();
+
+          if (error) return err(error.message);
+          return ok({ message: "Trajectory recording started", trajectory: data });
+        }
+
+        // ── Trajectory: End ──
+        case "end_trajectory": {
+          if (!params.trajectory_id) return err("Missing required: trajectory_id");
+          if (!params.outcome) return err("Missing required: outcome");
 
           const updates: Record<string, unknown> = {
-            status: newStatus,
-            resolved_at: new Date().toISOString(),
+            outcome: params.outcome as string,
+            completed_at: new Date().toISOString(),
           };
-          if (params.resolution) updates.resolution = params.resolution;
+          if (params.satisfaction_signal) updates.user_satisfaction_signal = params.satisfaction_signal;
 
-          const { data, error } = await supabase.from("agent_learnings")
+          const { data, error } = await supabase.from("execution_trajectories")
             .update(updates)
-            .eq("id", params.learning_id as string)
+            .eq("id", params.trajectory_id as string)
             .eq("user_id", userId)
-            .select("id, title, status, resolution")
+            .select("id, outcome, completed_at")
             .single();
           if (error) return err(error.message);
-          return ok({ message: `Learning marked as ${newStatus}`, learning: data });
+          return ok({ message: `Trajectory closed: ${params.outcome}`, trajectory: 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 now = new Date().toISOString();
+
+          // Parallel queries for speed
+          const memFilter = agentId
+            ? supabase.from("agent_memories").select("tier").eq("user_id", userId).eq("agent_id", agentId).or("expires_at.is.null,expires_at.gt." + now)
+            : supabase.from("agent_memories").select("tier").eq("user_id", userId).or("expires_at.is.null,expires_at.gt." + now);
+
+          const graphFilter = agentId
+            ? supabase.from("knowledge_graph_nodes").select("id").eq("user_id", userId).eq("agent_id", agentId)
+            : supabase.from("knowledge_graph_nodes").select("id").eq("user_id", userId);
+
+          const trajFilter = agentId
+            ? supabase.from("execution_trajectories").select("outcome").eq("user_id", userId).eq("agent_id", agentId)
+            : supabase.from("execution_trajectories").select("outcome").eq("user_id", userId);
+
+          const consolFilter = agentId
+            ? supabase.from("memory_consolidation_log").select("operation").eq("user_id", userId).eq("agent_id", agentId).limit(50)
+            : supabase.from("memory_consolidation_log").select("operation").eq("user_id", userId).limit(50);
+
+          const [memRes, graphRes, edgeRes, trajRes, consolRes] = await Promise.all([
+            memFilter,
+            graphFilter,
+            supabase.from("knowledge_graph_edges").select("id").eq("user_id", userId),
+            trajFilter,
+            consolFilter,
+          ]);
+
+          const tierCounts: Record<string, number> = { L1_focus: 0, L2_episode: 0, L3_pattern: 0, L4_rule: 0, L5_persona: 0 };
+          for (const row of memRes.data || []) {
             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;
+          const trajOutcomes: Record<string, number> = {};
+          for (const row of trajRes.data || []) {
+            const o = (row as any).outcome;
+            trajOutcomes[o] = (trajOutcomes[o] || 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;
+          const consolOps: Record<string, number> = {};
+          for (const row of consolRes.data || []) {
+            const o = (row as any).operation;
+            consolOps[o] = (consolOps[o] || 0) + 1;
+          }
 
           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 },
+            memories: { ...tierCounts, total: (memRes.data || []).length },
+            knowledge_graph: { nodes: (graphRes.data || []).length, edges: (edgeRes.data || []).length },
+            trajectories: { total: (trajRes.data || []).length, by_outcome: trajOutcomes },
+            consolidation: { operations: (consolRes.data || []).length, by_type: consolOps },
           });
         }
 
-        // ── 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}".`);
+          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`);
       }
     },
   });
@@ -5447,6 +5576,12 @@ export function registerTools(
     api.logger.warn?.(`[ofiere] Brain context injection failed: ${e?.message || e}`);
   });
 
+  // ── Register agent_end hook for server-side brain extraction ──
+  // This is the FIX for Bug 2: extraction was client-side only (useSocket.ts).
+  // Now every completed agent turn — from ANY channel (Telegram, Discord,
+  // webchat, scheduled) — triggers memory extraction server-side.
+  registerBrainExtractionHook(api, supabase, userId, fallbackAgentId);
+
   // ── Count and log ──
   const toolCount = 14;
   const callerName = getCallingAgentName(api);
@@ -5456,10 +5591,183 @@ export function registerTools(
   return toolCount;
 }
 
+// ── Server-Side Brain Extraction (agent_end hook) ─────────────────────────
+// Fires after EVERY agent turn completes, regardless of channel.
+// 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.
+
+function registerBrainExtractionHook(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  fallbackAgentId: string,
+): void {
+  try {
+    api.on("agent_end", async (event: any) => {
+      try {
+        // Extract messages from event — agent_end provides the conversation
+        const messages: any[] = event?.messages || event?.context?.messages || [];
+        if (!messages || messages.length < 2) return;
+
+        // Find last user + last assistant message
+        let lastUser = "";
+        let lastAssistant = "";
+        for (let i = messages.length - 1; i >= 0; i--) {
+          const msg = messages[i];
+          const role = msg?.role || msg?.message?.role;
+          const text = typeof msg === "string" ? msg
+            : msg?.text || msg?.content || msg?.message?.content
+              ?.filter?.((c: any) => c.type === "text")
+              ?.map?.((c: any) => c.text)
+              ?.join?.("\n")
+            || (typeof msg?.message?.content === "string" ? msg.message.content : "");
+
+          if (!lastAssistant && (role === "assistant" || role === "model")) {
+            lastAssistant = typeof text === "string" ? text : "";
+          }
+          if (!lastUser && role === "user") {
+            lastUser = typeof text === "string" ? text : "";
+          }
+          if (lastUser && lastAssistant) break;
+        }
+
+        // Skip trivial exchanges
+        if (lastUser.length < 20 || lastAssistant.length < 30) return;
+
+        // Resolve agent identity from event context
+        const agentId = event?.agentId
+          || event?.context?.agentId
+          || event?.sessionKey?.split?.(":")?.[0]
+          || fallbackAgentId
+          || "";
+
+        if (!agentId || agentId === "unknown" || agentId === "system") return;
+
+        // Resolve to actual DB agent_id
+        let resolvedAgentId = agentId;
+        try {
+          const resolved = await resolveAgentId(agentId, userId, supabase);
+          if (resolved) resolvedAgentId = resolved;
+        } catch {
+          // Use raw agentId
+        }
+
+        const sessionKey = event?.sessionKey || event?.context?.sessionKey || undefined;
+
+        // ── Fast Stream: Write L1_focus ──
+        const rawContent = `User: ${lastUser}\nAssistant: ${lastAssistant}`;
+        if (rawContent.length > 50) {
+          await supabase.from("agent_memories").insert({
+            user_id: userId,
+            agent_id: resolvedAgentId,
+            tier: "L1_focus",
+            content: rawContent.slice(0, 2000),
+            source: "auto",
+            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({
+            user_id: userId,
+            agent_id: resolvedAgentId,
+            tier: "L2_episode",
+            content: episodeSummary.slice(0, 1000),
+            source: "auto",
+            importance: 4,
+            context_key: sessionKey ? `episode:${sessionKey}` : null,
+          });
+        }
+
+        // ── Rule-based L3/L4 extraction from user message ──
+        // Extract factual statements → L3_pattern
+        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,
+        ];
+
+        for (const pattern of factPatterns) {
+          const matches = lastUser.matchAll(pattern);
+          for (const match of matches) {
+            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,
+              tier: "L3_pattern",
+              content: fact,
+              source: "auto",
+              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) {
+            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,
+              tier: "L4_rule",
+              content: rule,
+              source: "auto",
+              importance: 7,
+              context_key: contextKey,
+            });
+          }
+        }
+
+        api.logger.debug?.(`[ofiere-brain] Extracted memory for agent=${resolvedAgentId} session=${sessionKey || "none"}`);
+      } catch (e) {
+        // Silent — brain extraction must never block chat
+        api.logger.debug?.(`[ofiere-brain] Extraction error: ${e instanceof Error ? e.message : e}`);
+      }
+    });
+
+    api.logger.info("[ofiere] agent_end brain extraction hook registered");
+  } catch {
+    api.logger.debug?.("[ofiere] Could not register agent_end hook — may not be supported in this OpenClaw version");
+  }
+}
+
 // ── 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.
+// 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:
+//   L1_focus  — active working memory (not expired, sorted by importance)
+//   L4_rule   — operational guardrails (source='reflection', sorted by importance)
+//   L5_persona — identity context (permanent, top 3)
+// Runs once at registration time (~20ms, 3 parallel queries).
 
 async function injectBrainContext(
   api: any,
@@ -5467,73 +5775,67 @@ async function injectBrainContext(
   userId: string,
   agentId: string,
 ): Promise<void> {
-  if (!agentId) return; // Can't inject without knowing which agent
+  if (!agentId) return;
 
   const now = new Date().toISOString();
 
-  // Parallel queries — fast
-  const [l1Res, l3Res, learningsRes] = await Promise.all([
-    // Active L1 focus memories (not expired)
+  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),
-    // Recent L3 core (long-term wisdom)
+    // L4: Guardrails (non-superseded reflections)
     supabase.from("agent_memories")
-      .select("content")
+      .select("content, importance")
       .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("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("status", "pending")
-      .order("severity", { ascending: false })
-      .limit(10),
+      .eq("tier", "L5_persona")
+      .order("importance", { ascending: false })
+      .limit(3),
   ]);
 
   const l1 = l1Res.data || [];
-  const l3 = l3Res.data || [];
-  const learnings = learningsRes.data || [];
+  const l4 = l4Res.data || [];
+  const l5 = l5Res.data || [];
 
-  // Only inject if there's something to inject
-  if (l1.length === 0 && l3.length === 0 && learnings.length === 0) return;
+  if (l1.length === 0 && l4.length === 0 && l5.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 (l5.length > 0) {
+    sections.push("### Identity (L5_persona)\n" + l5.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 (l4.length > 0) {
+    sections.push("### ⚠️ Guardrails (L4_rule — DO NOT violate)\n" + l4.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")
-    );
+  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\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>`;
 
-  // 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");
   }
 }