ofiere-openclaw-plugin 4.34.0 → 4.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.34.0",
+  "version": "4.35.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

@@ -26,6 +26,7 @@ const TOOL_SUMMARIES: Record<string, string> = {
   OFIERE_PLAN_OPS: "Visual execution plan builder (DAG drafts → real tasks)",
   OFIERE_SOP_OPS: "Standard Operating Procedures for department chiefs",
   OFIERE_BRAIN_OPS: "Agent memory, knowledge graph, self-improvement (TMT/MAGMA)",
+  OFIERE_TALENT_OPS: "Talents: list, get, activate, deactivate cognitive skill presets",
 };
 
 // ─── Tier B: Full Tool Documentation ────────────────────────────────────────
@@ -113,6 +114,15 @@ Actions: "list_templates", "create", "list", "get", "update", "delete", "list_su
 Memory Tiers: L1_focus (24h), L2_episode (days), L3_pattern (weeks), L4_rule (permanent), L5_persona (permanent)
 Actions: 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
 - This is your SUBCONSCIOUS — use instinctively, not deliberately`,
+
+  OFIERE_TALENT_OPS: `Manage cognitive skill presets (Talents).
+Actions: "list", "get", "activate", "deactivate"
+- list: List all talents. Optional: category, scope, status
+- get: Get full talent details. Required: talent_id OR name
+- activate: Enable a talent (status → active). Required: talent_id
+- deactivate: Disable a talent (status → inactive). Required: talent_id
+- Active talents inject their execution_protocol and guardrails into your system prompt automatically
+- Talents chain other tools: SPHINX chains KNOWLEDGE_OPS+BRAIN_OPS, PRISM chains BRAIN_OPS trajectories, ATLAS chains PLAN_OPS+TASK_OPS+SOP_OPS`,
 };
 
 export function getSystemPrompt(state: {

package/src/tools.ts

@@ -5632,6 +5632,191 @@ function registerBrainOps(
   }));
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// TALENT OPS — Cognitive Skill Presets (list / get / activate / deactivate)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerTalentOps(
+  api: any, supabase: SupabaseClient, userId: string,
+) {
+  api.registerTool(api.createToolDefinition({
+    name: "OFIERE_TALENT_OPS",
+    label: "Ofiere Talent Operations",
+    description:
+      `Manage cognitive skill presets (Talents).\n` +
+      `Actions: "list", "get", "activate", "deactivate"\n` +
+      `- list: List all talents. Optional: category, scope, status\n` +
+      `- get: Get full talent details. Required: talent_id OR name\n` +
+      `- activate: Enable a talent (status → active). Required: talent_id\n` +
+      `- deactivate: Disable a talent (status → inactive). Required: talent_id\n` +
+      `- Active talents inject their execution_protocol and guardrails into your system prompt automatically\n` +
+      `- Talents chain other tools: SPHINX chains KNOWLEDGE_OPS+BRAIN_OPS, PRISM chains BRAIN_OPS trajectories, ATLAS chains PLAN_OPS+TASK_OPS+SOP_OPS`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: { type: "string", description: "list, get, activate, deactivate" },
+        talent_id: { type: "string", description: "Talent UUID" },
+        name: { type: "string", description: "Talent name (for get by name)" },
+        category: { type: "string", description: "Filter: research, analysis, operations, general" },
+        scope: { type: "string", description: "Filter: global, agent_specific" },
+        status: { type: "string", description: "Filter: active, inactive" },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+      try {
+        switch (action) {
+          case "list": {
+            let q = supabase.from("ofiere_talents")
+              .select("id, name, codename, description, category, icon, scope, status, tags, version")
+              .eq("user_id", userId)
+              .order("created_at", { ascending: false });
+            if (params.category) q = q.eq("category", params.category as string);
+            if (params.scope) q = q.eq("scope", params.scope as string);
+            if (params.status) q = q.eq("status", params.status as string);
+            const { data, error } = await q.limit(50);
+            if (error) return { success: false, result: error.message };
+            return { success: true, result: { talents: data || [], count: data?.length || 0 } };
+          }
+          case "get": {
+            const tid = params.talent_id as string;
+            const tname = params.name as string;
+            if (!tid && !tname) return { success: false, result: "Required: talent_id or name" };
+            let q = supabase.from("ofiere_talents").select("*").eq("user_id", userId);
+            if (tid) q = q.eq("id", tid);
+            else q = q.ilike("name", `%${tname}%`);
+            const { data, error } = await q.limit(1).maybeSingle();
+            if (error) return { success: false, result: error.message };
+            if (!data) return { success: false, result: "Talent not found" };
+            return { success: true, result: data };
+          }
+          case "activate": {
+            const tid = params.talent_id as string;
+            if (!tid) return { success: false, result: "Required: talent_id" };
+            const { error } = await supabase.from("ofiere_talents")
+              .update({ status: "active", updated_at: new Date().toISOString() })
+              .eq("id", tid).eq("user_id", userId);
+            if (error) return { success: false, result: error.message };
+            return { success: true, result: { message: "Talent activated", talent_id: tid } };
+          }
+          case "deactivate": {
+            const tid = params.talent_id as string;
+            if (!tid) return { success: false, result: "Required: talent_id" };
+            const { error } = await supabase.from("ofiere_talents")
+              .update({ status: "inactive", updated_at: new Date().toISOString() })
+              .eq("id", tid).eq("user_id", userId);
+            if (error) return { success: false, result: error.message };
+            return { success: true, result: { message: "Talent deactivated", talent_id: tid } };
+          }
+          default:
+            return { success: false, result: `Unknown action: ${action}. Valid: list, get, activate, deactivate` };
+        }
+      } catch (e) {
+        return { success: false, result: e instanceof Error ? e.message : String(e) };
+      }
+    },
+  }));
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TALENT CONTEXT HOOK — Injects active talent protocols into system prompt
+// ═══════════════════════════════════════════════════════════════════════════════
+// This is the engine that makes talents WORK. Without this hook, talents are
+// just database rows. The hook turns them into cognitive directives injected
+// before every agent turn via appendSystemContext.
+
+const talentCache = new Map<string, { text: string; at: number }>();
+const TALENT_CACHE_TTL = 300_000; // 5 min
+
+function registerTalentContextHook(
+  api: any, supabase: SupabaseClient, userId: string, fallbackAgentId: string,
+) {
+  try {
+    api.on("before_prompt_build", async (_event: any, ctx: any) => {
+      try {
+        const ctxAgentId = ctx?.agentId || "";
+        let resolvedAgentId = fallbackAgentId;
+        if (ctxAgentId && !isSystemName(ctxAgentId)) {
+          try {
+            const resolved = await resolveAgentId(ctxAgentId, userId, supabase);
+            if (resolved) resolvedAgentId = resolved;
+          } catch { /* fallback */ }
+        }
+
+        const cacheKey = `talent:${resolvedAgentId || "global"}`;
+        const cached = talentCache.get(cacheKey);
+        if (cached && (Date.now() - cached.at) < TALENT_CACHE_TTL) {
+          return cached.text ? { appendSystemContext: cached.text } : undefined;
+        }
+
+        // Query active talents: global OR assigned to this agent
+        const { data: talents } = await supabase
+          .from("ofiere_talents")
+          .select("name, codename, execution_protocol, guardrails, trigger_conditions, config")
+          .eq("user_id", userId)
+          .eq("status", "active")
+          .order("created_at", { ascending: true });
+
+        if (!talents || talents.length === 0) {
+          talentCache.set(cacheKey, { text: "", at: Date.now() });
+          return;
+        }
+
+        // Filter: global talents + agent-specific talents assigned to this agent
+        // (assigned_agent_ids check is done client-side since JSONB contains is complex)
+        const sections: string[] = [];
+        for (const t of talents) {
+          const ep = t.execution_protocol || [];
+          const gr = t.guardrails || {};
+          const tc = t.trigger_conditions || {};
+
+          let block = `### 🎯 Talent: ${t.name} (${t.codename || "custom"})`;
+
+          // Triggers
+          const triggers = [
+            ...(tc.keywords || []),
+            ...(tc.explicit_commands || []),
+          ];
+          if (triggers.length > 0) {
+            block += `\nTriggers: ${triggers.join(", ")}`;
+          }
+
+          // Execution Protocol (compact)
+          if (ep.length > 0) {
+            block += "\nExecution Protocol:";
+            for (let i = 0; i < ep.length; i++) {
+              const step = ep[i] as any;
+              block += `\n${i + 1}. **${step.phase}**: ${step.instruction}`;
+              if (step.checkpoint) block += `\n   ✓ Checkpoint: ${step.checkpoint}`;
+            }
+          }
+
+          // Guardrails (compact)
+          const mustNever = gr.must_never || [];
+          const hardConstraints = gr.hard_constraints || [];
+          if (mustNever.length > 0 || hardConstraints.length > 0) {
+            block += "\n⚠️ Guardrails:";
+            for (const mn of mustNever) block += `\n- 🚫 NEVER: ${mn}`;
+            for (const hc of hardConstraints) block += `\n- ⛔ CONSTRAINT: ${hc}`;
+          }
+
+          sections.push(block);
+        }
+
+        const talentContext = `<agent-talents>\n## Your Active Talents (${talents.length})\n\nThese are cognitive skill presets that define HOW you should approach specific types of tasks.\nWhen a user request matches a talent's triggers, follow that talent's execution protocol.\n\n${sections.join("\n\n---\n\n")}\n</agent-talents>`;
+
+        talentCache.set(cacheKey, { text: talentContext, at: Date.now() });
+        return { appendSystemContext: talentContext };
+      } catch (e) {
+        api.logger.debug?.(`[ofiere-talent] before_prompt_build error: ${e instanceof Error ? e.message : e}`);
+      }
+    });
+  } catch {
+    api.logger.debug?.("[ofiere] Could not register talent context hook");
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -5663,22 +5848,19 @@ export function registerTools(
   registerPlanOps(api, supabase, userId, resolveAgent);       // 12
   registerSOPOps(api, supabase, userId, resolveAgent);        // 13
   registerBrainOps(api, supabase, userId, resolveAgent);      // 14
+  registerTalentOps(api, supabase, userId);                   // 15
 
   // ── 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 talent context hook ──
+  registerTalentContextHook(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).
-  // 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 toolCount = 15;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);