ofiere-openclaw-plugin 4.35.1 → 4.37.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.35.1",
+  "version": "4.37.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)",
+  "description": "OpenClaw plugin for Ofiere PM - 16 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, agent brain, talent management, and corporate frameworks",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/tools.ts

@@ -4847,16 +4847,18 @@ function registerSOPOps(
       `sop_data structure (JSON object):\n` +
       `{\n` +
       `  title: string,\n` +
-      `  objective: string (purpose and expected outcome),\n` +
+      `  purpose: string (why this procedure exists),\n` +
       `  scope: string (department or domain),\n` +
-      `  prerequisites: [{ text: string, checked: boolean }],\n` +
-      `  steps: [{ id: string, name: string, action: string, owner: string, output: string }],\n` +
-      `  deliverables: [string],\n` +
-      `  escalationRules: [{ trigger: string, escalateTo: string, priority: "P1"|"P2"|"P3" }],\n` +
-      `  successCriteria: [{ text: string, checked: boolean }],\n` +
+      `  applicability: string (who/what this applies to),\n` +
+      `  prerequisites: { conditions: [{text,checked}], required_tools: [string], required_permissions: [string], safety_warnings: [string] },\n` +
+      `  procedure_steps: [{ id, name, action, owner, output, decision_logic, failure_state, fallback_action, estimated_duration }],\n` +
+      `  expected_outputs: [string],\n` +
+      `  escalation_rules: [{ trigger, escalateTo, priority: "P1"|"P2"|"P3" }],\n` +
+      `  acceptance_criteria: [{ text, checked }],\n` +
+      `  rollback_procedure: string,\n` +
       `  notes: string\n` +
       `}\n\n` +
-      `Status values: "draft", "active", "archived"`,
+      `Status values: "draft", "active", "archived", "under_review"`,
     parameters: {
       type: "object",
       required: ["action"],
@@ -4868,19 +4870,21 @@ function registerSOPOps(
         template_id: { type: "string", description: "Template ID (required for apply_template)" },
         title: { type: "string", description: "SOP title" },
         department: { type: "string", description: "Department name (e.g. Marketing & Revenue)" },
-        status: { type: "string", enum: ["draft", "active", "archived"], description: "SOP status" },
+        status: { type: "string", enum: ["draft", "active", "archived", "under_review"], description: "SOP status" },
         sop_data: {
           type: "object",
-          description: "Structured SOP content — pass a complete SOPData JSON object",
+          description: "Structured SOP content — pass a complete SOPData JSON object (accepts both old and new field names)",
           properties: {
             title: { type: "string" },
-            objective: { type: "string" },
+            purpose: { type: "string", description: "Why this procedure exists (also accepts 'objective')" },
             scope: { type: "string" },
-            prerequisites: { type: "array", items: { type: "object", properties: { text: { type: "string" }, checked: { type: "boolean" } }, required: ["text"] } },
-            steps: { type: "array", items: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, action: { type: "string" }, owner: { type: "string" }, output: { type: "string" } }, required: ["name", "action"] } },
-            deliverables: { type: "array", items: { type: "string" } },
-            escalationRules: { type: "array", items: { type: "object", properties: { trigger: { type: "string" }, escalateTo: { type: "string" }, priority: { type: "string", enum: ["P1", "P2", "P3"] } }, required: ["trigger", "escalateTo"] } },
-            successCriteria: { type: "array", items: { type: "object", properties: { text: { type: "string" }, checked: { type: "boolean" } }, required: ["text"] } },
+            applicability: { type: "string" },
+            prerequisites: { type: "object", description: "{ conditions: [{text,checked}], required_tools: [string], required_permissions: [string], safety_warnings: [string] }" },
+            procedure_steps: { type: "array", description: "Also accepts 'steps'", items: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, action: { type: "string" }, owner: { type: "string" }, output: { type: "string" }, decision_logic: { type: "string" }, failure_state: { type: "string" }, fallback_action: { type: "string" }, estimated_duration: { type: "string" } }, required: ["name", "action"] } },
+            expected_outputs: { type: "array", description: "Also accepts 'deliverables'", items: { type: "string" } },
+            escalation_rules: { type: "array", description: "Also accepts 'escalationRules'", items: { type: "object", properties: { trigger: { type: "string" }, escalateTo: { type: "string" }, priority: { type: "string", enum: ["P1", "P2", "P3"] } }, required: ["trigger", "escalateTo"] } },
+            acceptance_criteria: { type: "array", description: "Also accepts 'successCriteria'", items: { type: "object", properties: { text: { type: "string" }, checked: { type: "boolean" } }, required: ["text"] } },
+            rollback_procedure: { type: "string" },
             notes: { type: "string" },
           },
         },
@@ -4928,56 +4932,74 @@ async function handleSOPCreate(
     const title = params.title as string;
     if (!title) return err("Missing required field: title");
 
-    // Build the SOPData JSON
+    // Build the SOPData JSON (new schema, backward-compat with old field names)
     const sopDataRaw = params.sop_data as Record<string, unknown> | undefined;
     let sopContent: string;
 
     if (sopDataRaw) {
-      // Ensure each step has an id
-      const steps = Array.isArray(sopDataRaw.steps)
-        ? (sopDataRaw.steps as any[]).map((s: any, i: number) => ({
+      // Accept both old (steps) and new (procedure_steps) field names
+      const rawSteps = sopDataRaw.procedure_steps || sopDataRaw.steps;
+      const procedure_steps = Array.isArray(rawSteps)
+        ? (rawSteps as any[]).map((s: any, i: number) => ({
             id: s.id || `step-${Date.now()}-${i}`,
-            name: s.name || "",
-            action: s.action || "",
-            owner: s.owner || "",
-            output: s.output || "",
+            name: s.name || "", action: s.action || "", owner: s.owner || "", output: s.output || "",
+            decision_logic: s.decision_logic || "", failure_state: s.failure_state || "",
+            fallback_action: s.fallback_action || "", estimated_duration: s.estimated_duration || "",
           }))
         : [];
-      const prerequisites = Array.isArray(sopDataRaw.prerequisites)
-        ? (sopDataRaw.prerequisites as any[]).map((p: any) => ({ text: p.text || "", checked: !!p.checked }))
-        : [];
-      const successCriteria = Array.isArray(sopDataRaw.successCriteria)
-        ? (sopDataRaw.successCriteria as any[]).map((c: any) => ({ text: c.text || "", checked: !!c.checked }))
+      // Prerequisites: accept old array or new object format
+      const rawPrereqs = sopDataRaw.prerequisites;
+      let prerequisites: any;
+      if (rawPrereqs && typeof rawPrereqs === 'object' && !Array.isArray(rawPrereqs)) {
+        const rp = rawPrereqs as any;
+        prerequisites = {
+          conditions: Array.isArray(rp.conditions) ? rp.conditions.map((p: any) => ({ text: p.text || "", checked: !!p.checked })) : [],
+          required_tools: Array.isArray(rp.required_tools) ? rp.required_tools : [],
+          required_permissions: Array.isArray(rp.required_permissions) ? rp.required_permissions : [],
+          safety_warnings: Array.isArray(rp.safety_warnings) ? rp.safety_warnings : [],
+        };
+      } else {
+        prerequisites = {
+          conditions: Array.isArray(rawPrereqs) ? (rawPrereqs as any[]).map((p: any) => ({ text: p.text || "", checked: !!p.checked })) : [],
+          required_tools: [], required_permissions: [], safety_warnings: [],
+        };
+      }
+      const rawCriteria = sopDataRaw.acceptance_criteria || sopDataRaw.successCriteria;
+      const acceptance_criteria = Array.isArray(rawCriteria)
+        ? (rawCriteria as any[]).map((c: any) => ({ text: c.text || "", checked: !!c.checked }))
         : [];
-      const escalationRules = Array.isArray(sopDataRaw.escalationRules)
-        ? (sopDataRaw.escalationRules as any[]).map((r: any) => ({
-            trigger: r.trigger || "",
-            escalateTo: r.escalateTo || r.escalate_to || "",
+      const rawEsc = sopDataRaw.escalation_rules || sopDataRaw.escalationRules;
+      const escalation_rules = Array.isArray(rawEsc)
+        ? (rawEsc as any[]).map((r: any) => ({
+            trigger: r.trigger || "", escalateTo: r.escalateTo || r.escalate_to || "",
             priority: (r.priority || "P2") as "P1" | "P2" | "P3",
           }))
         : [];
-      const deliverables = Array.isArray(sopDataRaw.deliverables)
-        ? (sopDataRaw.deliverables as string[])
-        : [];
+      const rawOutputs = sopDataRaw.expected_outputs || sopDataRaw.deliverables;
+      const expected_outputs = Array.isArray(rawOutputs) ? (rawOutputs as string[]) : [];
 
       const sopData = {
         title: (sopDataRaw.title as string) || title,
-        objective: (sopDataRaw.objective as string) || "",
+        sop_id: (sopDataRaw.sop_id as string) || "", version: (sopDataRaw.version as string) || "1.0.0",
+        effective_date: "", review_date: "", author: "", approver: "", category: "", tags: [],
+        purpose: (sopDataRaw.purpose as string) || (sopDataRaw.objective as string) || "",
         scope: (sopDataRaw.scope as string) || "",
-        prerequisites,
-        steps,
-        deliverables,
-        escalationRules,
-        successCriteria,
+        applicability: (sopDataRaw.applicability as string) || "",
+        prerequisites, procedure_steps, expected_outputs,
+        acceptance_criteria, escalation_rules,
+        rollback_procedure: (sopDataRaw.rollback_procedure as string) || "",
+        related_sops: [], references: [], change_log: [],
         notes: (sopDataRaw.notes as string) || "",
       };
       sopContent = JSON.stringify(sopData);
     } else {
-      // Create empty SOP data
       sopContent = JSON.stringify({
-        title, objective: "", scope: "", prerequisites: [],
-        steps: [{ id: `step-${Date.now()}-0`, name: "", action: "", owner: "", output: "" }],
-        deliverables: [], escalationRules: [], successCriteria: [], notes: "",
+        title, sop_id: "", version: "1.0.0", effective_date: "", review_date: "", author: "", approver: "", category: "", tags: [],
+        purpose: "", scope: "", applicability: "",
+        prerequisites: { conditions: [], required_tools: [], required_permissions: [], safety_warnings: [] },
+        procedure_steps: [{ id: `step-${Date.now()}-0`, name: "", action: "", owner: "", output: "", decision_logic: "", failure_state: "", fallback_action: "", estimated_duration: "" }],
+        expected_outputs: [], acceptance_criteria: [], escalation_rules: [],
+        rollback_procedure: "", related_sops: [], references: [], change_log: [], notes: "",
       });
     }
 
@@ -5044,20 +5066,38 @@ async function handleSOPUpdate(supabase: SupabaseClient, userId: string, params:
 
     if (params.sop_data) {
       const sopDataRaw = params.sop_data as Record<string, unknown>;
-      const steps = Array.isArray(sopDataRaw.steps)
-        ? (sopDataRaw.steps as any[]).map((s: any, i: number) => ({
+      const rawSteps = sopDataRaw.procedure_steps || sopDataRaw.steps;
+      const procedure_steps = Array.isArray(rawSteps)
+        ? (rawSteps as any[]).map((s: any, i: number) => ({
             id: s.id || `step-${Date.now()}-${i}`,
             name: s.name || "", action: s.action || "", owner: s.owner || "", output: s.output || "",
+            decision_logic: s.decision_logic || "", failure_state: s.failure_state || "",
+            fallback_action: s.fallback_action || "", estimated_duration: s.estimated_duration || "",
           }))
         : [];
-      const prerequisites = Array.isArray(sopDataRaw.prerequisites)
-        ? (sopDataRaw.prerequisites as any[]).map((p: any) => ({ text: p.text || "", checked: !!p.checked }))
-        : [];
-      const successCriteria = Array.isArray(sopDataRaw.successCriteria)
-        ? (sopDataRaw.successCriteria as any[]).map((c: any) => ({ text: c.text || "", checked: !!c.checked }))
+      const rawPrereqs = sopDataRaw.prerequisites;
+      let prerequisites: any;
+      if (rawPrereqs && typeof rawPrereqs === 'object' && !Array.isArray(rawPrereqs)) {
+        const rp = rawPrereqs as any;
+        prerequisites = {
+          conditions: Array.isArray(rp.conditions) ? rp.conditions.map((p: any) => ({ text: p.text || "", checked: !!p.checked })) : [],
+          required_tools: Array.isArray(rp.required_tools) ? rp.required_tools : [],
+          required_permissions: Array.isArray(rp.required_permissions) ? rp.required_permissions : [],
+          safety_warnings: Array.isArray(rp.safety_warnings) ? rp.safety_warnings : [],
+        };
+      } else {
+        prerequisites = {
+          conditions: Array.isArray(rawPrereqs) ? (rawPrereqs as any[]).map((p: any) => ({ text: p.text || "", checked: !!p.checked })) : [],
+          required_tools: [], required_permissions: [], safety_warnings: [],
+        };
+      }
+      const rawCriteria = sopDataRaw.acceptance_criteria || sopDataRaw.successCriteria;
+      const acceptance_criteria = Array.isArray(rawCriteria)
+        ? (rawCriteria as any[]).map((c: any) => ({ text: c.text || "", checked: !!c.checked }))
         : [];
-      const escalationRules = Array.isArray(sopDataRaw.escalationRules)
-        ? (sopDataRaw.escalationRules as any[]).map((r: any) => ({
+      const rawEsc = sopDataRaw.escalation_rules || sopDataRaw.escalationRules;
+      const escalation_rules = Array.isArray(rawEsc)
+        ? (rawEsc as any[]).map((r: any) => ({
             trigger: r.trigger || "", escalateTo: r.escalateTo || r.escalate_to || "",
             priority: (r.priority || "P2") as "P1" | "P2" | "P3",
           }))
@@ -5065,11 +5105,16 @@ async function handleSOPUpdate(supabase: SupabaseClient, userId: string, params:
 
       updates.content = JSON.stringify({
         title: (sopDataRaw.title as string) || (params.title as string) || "",
-        objective: (sopDataRaw.objective as string) || "",
+        sop_id: (sopDataRaw.sop_id as string) || "", version: (sopDataRaw.version as string) || "1.0.0",
+        effective_date: "", review_date: "", author: "", approver: "", category: "", tags: [],
+        purpose: (sopDataRaw.purpose as string) || (sopDataRaw.objective as string) || "",
         scope: (sopDataRaw.scope as string) || "",
-        prerequisites, steps,
-        deliverables: Array.isArray(sopDataRaw.deliverables) ? sopDataRaw.deliverables : [],
-        escalationRules, successCriteria,
+        applicability: (sopDataRaw.applicability as string) || "",
+        prerequisites, procedure_steps,
+        expected_outputs: Array.isArray(sopDataRaw.expected_outputs || sopDataRaw.deliverables) ? (sopDataRaw.expected_outputs || sopDataRaw.deliverables) : [],
+        acceptance_criteria, escalation_rules,
+        rollback_procedure: (sopDataRaw.rollback_procedure as string) || "",
+        related_sops: [], references: [], change_log: [],
         notes: (sopDataRaw.notes as string) || "",
       });
     }
@@ -5152,6 +5197,182 @@ async function handleSOPApplyTemplate(
 }
 
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 16: OFIERE_FRAMEWORK_OPS — Corporate Frameworks
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerFrameworkOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+): void {
+  api.registerTool({
+    name: "OFIERE_FRAMEWORK_OPS",
+    label: "Ofiere Framework Operations",
+    description:
+      `Create and manage Corporate Frameworks — strategic mandates, KPIs, risk governance, and operational boundaries.\n\n` +
+      `Actions:\n` +
+      `- "create": Create a new framework. Required: agent_id, title. Provide framework body via 'content' (JSON string). Optional: department, category, status\n` +
+      `- "list": List frameworks. Optional: agent_id to filter\n` +
+      `- "get": Get full framework details. Required: framework_id\n` +
+      `- "update": Modify framework. Required: framework_id. Optional: title, content, status, department, category\n` +
+      `- "delete": Remove framework. Required: framework_id\n\n` +
+      `content: A JSON string containing the full framework body. Example:\n` +
+      `"{\\"mission\\":\\"Drive brand growth\\",\\"vision\\":\\"Market leader by 2027\\",\\"core_principles\\":[\\"Data-driven\\",\\"Customer-first\\"],` +
+      `\\"decision_authority\\":\\"CMO approves >$10k spend\\",\\"budget_constraints\\":\\"$50k monthly cap\\",` +
+      `\\"strategic_objectives\\":[{\\"objective\\":\\"Grow MRR\\",\\"target\\":\\"$100k\\",\\"measurement\\":\\"Revenue dashboard\\"}],` +
+      `\\"risk_appetite\\":\\"moderate\\",\\"escalation_matrix\\":[{\\"trigger\\":\\"Budget >80%\\",\\"escalate_to\\":\\"CEO\\",\\"priority\\":\\"P1\\"}],` +
+      `\\"notes\\":\\"Quarterly review\\"}"\n\n` +
+      `Supported content fields: mission, vision, core_principles, decision_authority, budget_constraints, ` +
+      `resource_limits, tool_stack, strategic_objectives, risk_appetite, compliance_requirements, ` +
+      `escalation_matrix, team_composition, integration_points, review_frequency, notes — or any custom fields.\n\n` +
+      `Status values: "draft", "active", "under_review", "archived"`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: { type: "string", enum: ["create", "list", "get", "update", "delete"], description: "Framework action" },
+        framework_id: { type: "string", description: "Framework ID (required for get, update, delete)" },
+        agent_id: { type: "string", description: "Agent ID (required for create, optional filter for list)" },
+        title: { type: "string", description: "Framework title" },
+        content: { type: "string", description: "Framework body as a JSON string containing mission, vision, core_principles, decision_authority, budget_constraints, strategic_objectives, risk_appetite, escalation_matrix, and any other fields. Pass as stringified JSON." },
+        department: { type: "string" },
+        category: { type: "string" },
+        status: { type: "string", enum: ["draft", "active", "under_review", "archived"] },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+      switch (action) {
+        case "create": return handleFWCreate(supabase, userId, resolveAgent, params);
+        case "list": return handleFWList(supabase, userId, params);
+        case "get": return handleFWGet(supabase, userId, params);
+        case "update": return handleFWUpdate(supabase, userId, params);
+        case "delete": return handleFWDelete(supabase, userId, params);
+        default: return err(`Unknown action "${action}". Valid: create, list, get, update, delete`);
+      }
+    },
+  });
+}
+
+// ── Framework action handlers ────────────────────────────────────────────────
+
+async function handleFWCreate(
+  supabase: SupabaseClient, userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const agentIdRaw = params.agent_id as string;
+    if (!agentIdRaw) return err("Missing required field: agent_id");
+    const title = params.title as string;
+    if (!title) return err("Missing required field: title");
+
+    // Accept content via: (1) 'content' string param (preferred, matches SOP pattern)
+    //                      (2) 'framework_data' object param (legacy, kept for compat)
+    let content: string;
+    if (typeof params.content === "string" && params.content.trim()) {
+      // Already a JSON string — merge with title
+      try {
+        const parsed = JSON.parse(params.content);
+        content = JSON.stringify({ title, ...parsed });
+      } catch {
+        // Not valid JSON — wrap as notes
+        content = JSON.stringify({ title, notes: params.content });
+      }
+    } else if (params.framework_data && typeof params.framework_data === "object") {
+      content = JSON.stringify({ title, ...(params.framework_data as Record<string, unknown>) });
+    } else {
+      content = JSON.stringify({ title });
+    }
+
+    const row = {
+      user_id: userId, agent_id: agentIdRaw, title, content,
+      status: (params.status as string) || "draft",
+      department: (params.department as string) || null,
+      category: (params.category as string) || null,
+    };
+
+    const { data, error } = await supabase.from("frameworks").insert(row).select().single();
+    if (error) return err(error.message);
+    return ok({
+      message: `Framework "${title}" created for agent ${agentIdRaw}`,
+      framework: { id: data.id, title: data.title, status: data.status, agent_id: data.agent_id },
+    });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleFWList(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    let query = supabase.from("frameworks")
+      .select("id, agent_id, title, status, department, category, created_at, updated_at")
+      .eq("user_id", userId).order("updated_at", { ascending: false });
+    if (params.agent_id) query = query.eq("agent_id", params.agent_id as string);
+    const { data, error } = await query;
+    if (error) return err(error.message);
+    return ok({ frameworks: data || [], count: (data || []).length });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleFWGet(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.framework_id) return err("Missing required field: framework_id");
+    const { data, error } = await supabase.from("frameworks").select("*")
+      .eq("id", params.framework_id as string).eq("user_id", userId);
+    if (error) return err(error.message);
+    if (!data || data.length === 0) return err("Framework not found");
+    const fw = data[0];
+    let parsed: any = {};
+    try { parsed = JSON.parse(fw.content || "{}"); } catch { /* leave empty */ }
+    return ok({ framework: { ...fw, content: parsed } });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleFWUpdate(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.framework_id) return err("Missing required field: framework_id");
+    const updates: Record<string, any> = { updated_at: new Date().toISOString() };
+    if (params.title !== undefined) updates.title = params.title;
+    if (params.status !== undefined) updates.status = params.status;
+    if (params.department !== undefined) updates.department = params.department;
+    if (params.category !== undefined) updates.category = params.category;
+
+    // Accept content via: (1) 'content' string param (preferred)
+    //                      (2) 'framework_data' object param (legacy compat)
+    if (typeof params.content === "string" && params.content.trim()) {
+      try {
+        const parsed = JSON.parse(params.content);
+        updates.content = JSON.stringify({ title: parsed.title || (params.title as string) || "", ...parsed });
+      } catch {
+        updates.content = JSON.stringify({ title: (params.title as string) || "", notes: params.content });
+      }
+    } else if (params.framework_data && typeof params.framework_data === "object") {
+      const raw = params.framework_data as Record<string, unknown>;
+      updates.content = JSON.stringify({ title: (raw.title as string) || (params.title as string) || "", ...raw });
+    }
+
+    const { data, error } = await supabase.from("frameworks").update(updates)
+      .eq("id", params.framework_id as string).eq("user_id", userId)
+      .select("id, title, status").maybeSingle();
+    if (error) return err(error.message);
+    if (!data) return err("Framework not found");
+    return ok({ message: `Framework "${data.title}" updated`, framework: data });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleFWDelete(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.framework_id) return err("Missing required field: framework_id");
+    const { data, error } = await supabase.from("frameworks").delete()
+      .eq("id", params.framework_id as string).eq("user_id", userId)
+      .select("id, title").maybeSingle();
+    if (error) return err(error.message);
+    if (!data) return err("Framework not found — nothing deleted");
+    return ok({ message: `Framework "${data.title}" deleted`, deleted: true });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // META-TOOL 14: OFIERE_BRAIN_OPS — Agent Memory + Self-Improvement
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -5849,6 +6070,7 @@ export function registerTools(
   registerSOPOps(api, supabase, userId, resolveAgent);        // 13
   registerBrainOps(api, supabase, userId, resolveAgent);      // 14
   registerTalentOps(api, supabase, userId);                   // 15
+  registerFrameworkOps(api, supabase, userId, resolveAgent);   // 16
 
   // ── Register dynamic brain context hook ──
   registerBrainContextHook(api, supabase, userId, fallbackAgentId);
@@ -5860,7 +6082,7 @@ export function registerTools(
   registerBrainExtractionHook(api, supabase, userId, fallbackAgentId);
 
   // ── Count and log ──
-  const toolCount = 15;
+  const toolCount = 16;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);