ofiere-openclaw-plugin 4.27.3 → 4.29.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.3",
+  "version": "4.29.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/tools.ts

@@ -5576,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);
@@ -5585,6 +5591,176 @@ 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 at boot and injects them into the system
 // prompt via api.on("before_prompt_build"). Uses the TMT hierarchy: