ofiere-openclaw-plugin 1.1.0 → 2.0.0

package/README.md

@@ -40,15 +40,27 @@ Once configured, the plugin connects to your Supabase database at gateway startu
 
 Changes made by the agent are immediately visible on the Ofiere dashboard (Vercel) via Supabase real-time subscriptions.
 
-## AI Tools
-
-| Tool | Description |
-|---|---|
-| `OFIERE_LIST_TASKS` | List and filter PM tasks |
-| `OFIERE_CREATE_TASK` | Create a new task (auto-assigns to calling agent) |
-| `OFIERE_UPDATE_TASK` | Update task fields (status, priority, progress, etc.) |
-| `OFIERE_DELETE_TASK` | Delete a task and its subtasks |
-| `OFIERE_LIST_AGENTS` | List available agents for task assignment |
+## AI Meta-Tools
+
+The plugin uses a scalable meta-tool architecture. Each tool handles one domain with an `action` parameter to select the operation.
+
+| Tool | Actions | Description |
+|---|---|---|
+| `OFIERE_TASK_OPS` | `list`, `create`, `update`, `delete` | Manage PM tasks — list, create, update status/priority, delete |
+| `OFIERE_AGENT_OPS` | `list` | Query available agents for task assignment |
+
+### Example
+
+```
+// Create a task
+OFIERE_TASK_OPS({ action: "create", title: "Deploy v2", agent_id: "ivy" })
+
+// List tasks
+OFIERE_TASK_OPS({ action: "list", status: "PENDING", limit: 10 })
+
+// Update a task
+OFIERE_TASK_OPS({ action: "update", task_id: "task-123", status: "DONE" })
+```
 
 ## CLI Commands
 

package/index.ts

@@ -74,12 +74,13 @@ const ofierePlugin = {
       // Probe the api object for any agent identity info (for debugging + fallback)
       probeApiForAgentName(api, api.logger);
 
-      registerTools(api, supabase, config);
-      promptState.toolCount = 5;
+      // registerTools now returns the count — no more hardcoding
+      const toolCount = registerTools(api, supabase, config);
+      promptState.toolCount = toolCount;
       promptState.ready = true;
       const agentLabel = config.agentId || "auto-detect";
       api.logger.info(
-        `[ofiere] Ready — 5 tools registered (agent: ${agentLabel})`,
+        `[ofiere] Ready — ${toolCount} meta-tools registered (agent: ${agentLabel})`,
       );
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM — manage tasks, agents, and projects from your agent",
+  "description": "OpenClaw plugin for Ofiere PM — scalable meta-tool architecture for task, agent, and project management",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/prompt.ts

@@ -1,3 +1,41 @@
+// src/prompt.ts — Dynamic system prompt for Ofiere PM plugin
+//
+// The prompt is built dynamically based on plugin state.
+// Tool documentation is structured so adding a new meta-tool
+// only requires adding a new entry to TOOL_DOCS below.
+
+// ─── Tool Documentation Registry ────────────────────────────────────────────
+// Add new meta-tool docs here when expanding. Each entry maps to one
+// registered meta-tool and will be included in the system prompt.
+
+const TOOL_DOCS: Record<string, string> = {
+  OFIERE_TASK_OPS: `- **OFIERE_TASK_OPS** — Manage tasks (action: "list", "create", "update", "delete")
+    - list: Filter by status, agent_id, space_id, folder_id, limit
+    - create: Requires title + agent_id. Pass your name to self-assign, 'none' for unassigned
+    - update: Requires task_id. Change title, status, priority, progress, etc.
+    - delete: Requires task_id. Removes task and subtasks`,
+
+  OFIERE_AGENT_OPS: `- **OFIERE_AGENT_OPS** — Query agents (action: "list")
+    - list: See all agents with IDs, names, roles for task assignment`,
+
+  // ── Future meta-tools — uncomment when registered ──
+  // OFIERE_PROJECT_OPS: `- **OFIERE_PROJECT_OPS** — Manage projects (action: "list", "create", "update", "delete")
+  //   - list: List spaces, folders, and projects
+  //   - create: Create a new space or folder
+  //   - update: Rename, move, or archive
+  //   - delete: Remove space/folder and reassign tasks`,
+  //
+  // OFIERE_SCHEDULE_OPS: `- **OFIERE_SCHEDULE_OPS** — Calendar & timeline (action: "list", "schedule", "reschedule")
+  //   - list: View scheduled events for a date range
+  //   - schedule: Assign a task to a time slot
+  //   - reschedule: Move an event to a new time`,
+  //
+  // OFIERE_KNOWLEDGE_OPS: `- **OFIERE_KNOWLEDGE_OPS** — Knowledge base (action: "search", "create", "update")
+  //   - search: Find knowledge entries by query
+  //   - create: Add a new knowledge entry
+  //   - update: Edit an existing entry`,
+};
+
 export function getSystemPrompt(state: {
   ready: boolean;
   toolCount: number;
@@ -13,28 +51,28 @@ export function getSystemPrompt(state: {
       ? `When you create a task without specifying agent_id, it is assigned to YOU (${state.agentId}).`
       : `When you create a task without specifying agent_id, it is assigned to YOU automatically.`;
 
+    // Build tool docs from registry — only include docs for tools that exist
+    const toolDocs = Object.values(TOOL_DOCS).join("\n");
+
     return `<ofiere-pm>
 You are connected to the Ofiere Project Management dashboard via the Ofiere PM plugin.
 ${agentLine}
 
-## Your Ofiere PM Capabilities
-You have ${state.toolCount} tools to manage the PM dashboard:
+## Your Ofiere PM Tools (${state.toolCount} meta-tools)
+
+Each tool uses an "action" parameter to select the operation. Always include action.
 
-- **OFIERE_LIST_TASKS** — List and filter tasks from the PM dashboard
-- **OFIERE_CREATE_TASK** — Create new tasks (auto-assigned to you if no agent_id given)
-- **OFIERE_UPDATE_TASK** — Update task status, priority, progress, etc.
-- **OFIERE_DELETE_TASK** — Delete tasks
-- **OFIERE_LIST_AGENTS** — See all available agents for task assignment
+${toolDocs}
 
 ## Rules
 - ${assignRule}
 - To create an unassigned task, pass agent_id as "none" or "unassigned".
-- When the user says "create a task for [agent name]", use OFIERE_LIST_AGENTS to find the agent ID, then pass it as agent_id.
+- When the user says "create a task for [agent name]", use OFIERE_AGENT_OPS action:"list" to find the agent ID, then use OFIERE_TASK_OPS action:"create" with that agent_id.
 - Always confirm task creation/updates by reporting back what was done.
-- Task statuses are: PENDING, IN_PROGRESS, DONE, FAILED.
+- Task statuses: PENDING, IN_PROGRESS, DONE, FAILED.
 - Priority levels: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL.
-- Changes you make appear in the Ofiere dashboard immediately in real time.
-- Do NOT fabricate task IDs — always use OFIERE_LIST_TASKS to look up real IDs.
+- Changes appear in the Ofiere dashboard immediately via real-time sync.
+- Do NOT fabricate task IDs — use OFIERE_TASK_OPS action:"list" to look up real IDs.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -1,10 +1,14 @@
-// src/tools.ts — Tool registration for Ofiere PM plugin
-// Uses api.registerTool(tool, opts?) as documented:
-//   https://docs.openclaw.ai/plugins/sdk-overview#tools-and-commands
-//   https://docs.openclaw.ai/plugins/building-plugins#registering-agent-tools
+// src/tools.ts — Meta-tool registration for Ofiere PM plugin
+// Architecture: Each meta-tool handles one domain (tasks, agents, etc.)
+// with an "action" parameter that routes to the correct handler.
 //
-// - Required tools: always available (no opts)
-// - Optional tools: { optional: true } — user must allowlist or allowlist the plugin id
+// To add a new domain:
+//   1. Create a handler function (e.g. registerProjectOps)
+//   2. Add it to the registerAllTools() call at the bottom
+//   3. Update prompt.ts to document the new meta-tool
+//
+// This pattern keeps the tool count low (1 tool per domain)
+// while supporting unlimited operations within each domain.
 
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { OfiereConfig } from "./types.js";
@@ -100,21 +104,19 @@ export function probeApiForAgentName(api: any, logger?: any): string {
   return "";
 }
 
-// ─── Tool Registration ───────────────────────────────────────────────────────
+// ─── Shared: Agent ID Resolution ─────────────────────────────────────────────
 
-export function registerTools(
-  api: any, // OpenClawPluginApi — typed as any to avoid import-path issues at install time
+function createAgentResolver(
+  api: any,
   supabase: SupabaseClient,
-  config: OfiereConfig,
-): void {
-  const userId = config.userId;
-  const fallbackAgentId = config.agentId; // May be empty — that's fine
-
+  userId: string,
+  fallbackAgentId: string,
+) {
   /**
    * Resolve the agent ID for the calling agent.
    * Priority: explicit param > runtime context > registration-time detection > env var > DB fallback
    */
-  async function resolveAgent(explicitId?: string): Promise<string | null> {
+  return async function resolveAgent(explicitId?: string): Promise<string | null> {
     // 1. Explicit agent_id passed by the LLM (e.g. "ivy", "daisy", or a UUID)
     if (explicitId && explicitId.trim()) {
       const trimmed = explicitId.trim();
@@ -167,327 +169,357 @@ export function registerTools(
     }
 
     return null;
-  }
+  };
+}
 
-  // ── OFIERE_LIST_TASKS — Required (read-only, no side effects) ────────
+// ─── META-TOOL: OFIERE_TASK_OPS ──────────────────────────────────────────────
 
+function registerTaskOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+): void {
   api.registerTool({
-    name: "OFIERE_LIST_TASKS",
-    label: "List Ofiere Tasks",
+    name: "OFIERE_TASK_OPS",
+    label: "Ofiere Task Operations",
     description:
-      "List tasks from the Ofiere PM dashboard. " +
-      "Optionally filter by space_id, folder_id, agent_id, or status. " +
-      "Returns an array of task objects with their details.",
+      `Manage tasks in the Ofiere PM dashboard. All task operations go through this tool.\n\n` +
+      `Actions:\n` +
+      `- "list": List/filter tasks. Optional params: status, agent_id, space_id, folder_id, limit\n` +
+      `- "create": Create a new task. Required: title, agent_id. Optional: description, status, priority, space_id, folder_id, start_date, due_date, tags\n` +
+      `- "update": Update an existing task. Required: task_id. Optional: title, description, status, priority, progress, agent_id, start_date, due_date, tags\n` +
+      `- "delete": Delete a task and its subtasks. Required: task_id\n\n` +
+      `agent_id for create: Pass your own name (e.g. 'ivy') to self-assign, another agent's name to assign to them, or 'none'/'unassigned' for no assignee.\n` +
+      `Status values: PENDING, IN_PROGRESS, DONE, FAILED\n` +
+      `Priority values: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL`,
     parameters: {
       type: "object",
+      required: ["action"],
       properties: {
-        space_id: { type: "string", description: "Filter by PM space ID" },
-        folder_id: { type: "string", description: "Filter by PM folder ID" },
-        agent_id: { type: "string", description: "Filter by assigned agent ID" },
+        action: {
+          type: "string",
+          description: "The operation to perform",
+          enum: ["list", "create", "update", "delete"],
+        },
+        // ── Shared / contextual params ──
+        task_id: { type: "string", description: "Task ID (required for update, delete)" },
+        title: { type: "string", description: "Task title (required for create)" },
+        description: { type: "string", description: "Task description" },
+        agent_id: {
+          type: "string",
+          description:
+            "Agent name or ID. For create: your name to self-assign, another name to delegate, 'none' for unassigned. For list: filter by agent.",
+        },
         status: {
           type: "string",
-          description: "Filter by status: PENDING, IN_PROGRESS, DONE, FAILED",
+          description: "Task status",
           enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"],
         },
-        limit: { type: "number", description: "Max results (default 50)" },
+        priority: { type: "number", description: "Priority: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL" },
+        progress: { type: "number", description: "Progress percentage 0-100 (update only)" },
+        space_id: { type: "string", description: "PM Space ID" },
+        folder_id: { type: "string", description: "PM Folder ID" },
+        start_date: { type: "string", description: "Start date (ISO 8601)" },
+        due_date: { type: "string", description: "Due date (ISO 8601)" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for the task",
+        },
+        limit: { type: "number", description: "Max results for list (default 50)" },
       },
     },
     async execute(_id: string, params: Record<string, unknown>) {
-      try {
-        let query = supabase
-          .from("tasks")
-          .select(
-            "id, title, description, status, priority, agent_id, space_id, folder_id, " +
-            "start_date, due_date, progress, created_at, updated_at",
-          )
-          .eq("user_id", userId)
-          .order("updated_at", { ascending: false });
-
-        if (params.space_id) query = query.eq("space_id", params.space_id as string);
-        if (params.folder_id) query = query.eq("folder_id", params.folder_id as string);
-        if (params.agent_id) query = query.eq("agent_id", params.agent_id as string);
-        if (params.status) query = query.eq("status", params.status as string);
-        query = query.limit((params.limit as number) || 50);
-
-        const { data, error } = await query;
-        if (error) return err(error.message);
-        return ok({ tasks: data || [], count: (data || []).length });
-      } catch (e) {
-        return err(e instanceof Error ? e.message : String(e));
+      const action = params.action as string;
+
+      switch (action) {
+        case "list":
+          return handleListTasks(supabase, userId, params);
+        case "create":
+          return handleCreateTask(supabase, userId, resolveAgent, params);
+        case "update":
+          return handleUpdateTask(supabase, userId, params);
+        case "delete":
+          return handleDeleteTask(supabase, userId, params);
+        default:
+          return err(
+            `Unknown action "${action}". Valid actions: list, create, update, delete`,
+          );
       }
     },
   });
+}
 
-  // ── OFIERE_CREATE_TASK — Optional (has side effects: writes to DB) ───
-
-  api.registerTool(
-    {
-      name: "OFIERE_CREATE_TASK",
-      label: "Create Ofiere Task",
-      description:
-        "Create a new task in the Ofiere PM dashboard. " +
-        "IMPORTANT: You MUST always pass your own name as agent_id (e.g. 'ivy', 'daisy') to assign the task to yourself. " +
-        "If you want to assign to a different agent, pass their name instead. " +
-        "Pass agent_id as 'none' or 'unassigned' to create an unassigned task. " +
-        "The task will appear in the dashboard immediately via real-time sync.",
-      parameters: {
-        type: "object",
-        required: ["title", "agent_id"],
-        properties: {
-          title: { type: "string", description: "Task title (required)" },
-          description: { type: "string", description: "Task description" },
-          agent_id: {
-            type: "string",
-            description:
-              "REQUIRED. Your own agent name (e.g. 'ivy', 'daisy', 'celia') to self-assign, " +
-              "or another agent's name to assign to them. " +
-              "Pass 'none' or 'unassigned' to create a task with no assignee.",
-          },
-          status: {
-            type: "string",
-            description: "Initial status (default: PENDING)",
-            enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"],
-          },
-          priority: {
-            type: "number",
-            description: "Priority: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL (default: 1)",
-          },
-          space_id: { type: "string", description: "PM Space ID to place the task in" },
-          folder_id: { type: "string", description: "PM Folder ID to place the task in" },
-          start_date: { type: "string", description: "Start date (ISO 8601 format)" },
-          due_date: { type: "string", description: "Due date (ISO 8601 format)" },
-          tags: {
-            type: "array",
-            items: { type: "string" },
-            description: "Tags for the task",
-          },
-        },
-      },
-      async execute(_id: string, params: Record<string, unknown>) {
-        try {
-          if (!params.title) return err("Missing required field: title");
-
-          const id = `task-${Date.now()}`;
-          const now = new Date().toISOString();
-
-          // Handle explicit "none"/"unassigned"
-          const rawAgentId = params.agent_id as string | undefined;
-          const isUnassigned =
-            rawAgentId &&
-            ["none", "unassigned", "null", ""].includes(rawAgentId.toLowerCase().trim());
-
-          const assignee = isUnassigned ? null : await resolveAgent(rawAgentId);
-
-          const insertData: Record<string, unknown> = {
-            id,
-            user_id: userId,
-            title: params.title,
-            description: (params.description as string) || null,
-            agent_id: assignee,
-            assignee_type: "agent",
-            status: (params.status as string) || "PENDING",
-            priority: params.priority !== undefined ? params.priority : 1,
-            space_id: (params.space_id as string) || null,
-            folder_id: (params.folder_id as string) || null,
-            start_date: (params.start_date as string) || null,
-            due_date: (params.due_date as string) || null,
-            tags: (params.tags as string[]) || [],
-            progress: 0,
-            sort_order: 0,
-            custom_fields: {},
-            created_at: now,
-            updated_at: now,
-          };
-
-          const { error } = await supabase.from("tasks").insert(insertData);
-
-          if (error) {
-            if (error.message?.includes("agent_id") || error.message?.includes("foreign key")) {
-              insertData.agent_id = null;
-              const retry = await supabase.from("tasks").insert(insertData);
-              if (retry.error) return err(retry.error.message);
-              return ok({
-                id,
-                message: `Task "${params.title}" created (agent_id "${assignee}" was invalid, assigned to none)`,
-                task: insertData,
-              });
-            }
-            return err(error.message);
-          }
-
-          return ok({
-            id,
-            message: `Task "${params.title}" created and assigned to ${assignee || "no one"}`,
-            task: insertData,
-          });
-        } catch (e) {
-          return err(e instanceof Error ? e.message : String(e));
-        }
-      },
-    },
-  );
-
-  // ── OFIERE_UPDATE_TASK — Optional (has side effects) ─────────────────
-
-  api.registerTool(
-    {
-      name: "OFIERE_UPDATE_TASK",
-      label: "Update Ofiere Task",
-      description:
-        "Update an existing task in the Ofiere PM dashboard. Only provided fields are changed. " +
-        "Changes appear in the dashboard immediately via real-time sync.",
-      parameters: {
-        type: "object",
-        required: ["task_id"],
-        properties: {
-          task_id: { type: "string", description: "The task ID to update (required)" },
-          title: { type: "string", description: "New title" },
-          description: { type: "string", description: "New description" },
-          status: {
-            type: "string",
-            description: "New status",
-            enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"],
-          },
-          priority: { type: "number", description: "New priority (0-3)" },
-          progress: { type: "number", description: "Progress percentage (0-100)" },
-          agent_id: { type: "string", description: "Reassign to a different agent" },
-          start_date: { type: "string", description: "New start date (ISO 8601)" },
-          due_date: { type: "string", description: "New due date (ISO 8601)" },
-          tags: {
-            type: "array",
-            items: { type: "string" },
-            description: "New tags",
-          },
-        },
-      },
-      async execute(_id: string, params: Record<string, unknown>) {
-        try {
-          if (!params.task_id) return err("Missing required field: task_id");
-
-          const updates: Record<string, unknown> = { updated_at: new Date().toISOString() };
-          const fields = [
-            "title", "description", "status", "priority", "progress",
-            "agent_id", "start_date", "due_date", "tags",
-          ];
-          for (const f of fields) {
-            if (params[f] !== undefined) updates[f] = params[f];
-          }
-          if (params.status === "DONE") updates.completed_at = new Date().toISOString();
-
-          const { data, error } = await supabase
-            .from("tasks")
-            .update(updates)
-            .eq("id", params.task_id as string)
-            .eq("user_id", userId)
-            .select("id, title, status, priority, agent_id")
-            .single();
-
-          if (error) return err(error.message);
-          return ok({ message: `Task "${data?.title}" updated`, task: data });
-        } catch (e) {
-          return err(e instanceof Error ? e.message : String(e));
-        }
-      },
-    },
-  );
-
-  // ── OFIERE_DELETE_TASK — Optional (destructive side effect) ──────────
-
-  api.registerTool(
-    {
-      name: "OFIERE_DELETE_TASK",
-      label: "Delete Ofiere Task",
-      description:
-        "Delete a task from the Ofiere PM dashboard. Also removes subtasks and linked scheduler events.",
-      parameters: {
-        type: "object",
-        required: ["task_id"],
-        properties: {
-          task_id: { type: "string", description: "The task ID to delete (required)" },
-        },
-      },
-      async execute(_id: string, params: Record<string, unknown>) {
-        try {
-          if (!params.task_id) return err("Missing required field: task_id");
-          const taskId = params.task_id as string;
-
-          await supabase.from("scheduler_events").delete().eq("task_id", taskId);
-
-          const { data: subtasks } = await supabase
-            .from("tasks")
-            .select("id")
-            .eq("parent_task_id", taskId)
-            .eq("user_id", userId);
-
-          if (subtasks && subtasks.length > 0) {
-            for (const sub of subtasks) {
-              await supabase.from("scheduler_events").delete().eq("task_id", sub.id);
-            }
-            await supabase
-              .from("tasks")
-              .delete()
-              .in("id", subtasks.map((s: { id: string }) => s.id))
-              .eq("user_id", userId);
-          }
-
-          const { error } = await supabase
-            .from("tasks")
-            .delete()
-            .eq("id", taskId)
-            .eq("user_id", userId);
-
-          if (error) return err(error.message);
-          return ok({ message: `Task ${taskId} deleted`, deleted: true });
-        } catch (e) {
-          return err(e instanceof Error ? e.message : String(e));
-        }
-      },
-    },
-  );
+// ── Task action handlers ─────────────────────────────────────────────────────
+
+async function handleListTasks(
+  supabase: SupabaseClient,
+  userId: string,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    let query = supabase
+      .from("tasks")
+      .select(
+        "id, title, description, status, priority, agent_id, space_id, folder_id, " +
+        "start_date, due_date, progress, created_at, updated_at",
+      )
+      .eq("user_id", userId)
+      .order("updated_at", { ascending: false });
+
+    if (params.space_id) query = query.eq("space_id", params.space_id as string);
+    if (params.folder_id) query = query.eq("folder_id", params.folder_id as string);
+    if (params.agent_id) query = query.eq("agent_id", params.agent_id as string);
+    if (params.status) query = query.eq("status", params.status as string);
+    query = query.limit((params.limit as number) || 50);
+
+    const { data, error } = await query;
+    if (error) return err(error.message);
+    return ok({ tasks: data || [], count: (data || []).length });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+async function handleCreateTask(
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.title) return err("Missing required field: title");
+
+    const id = `task-${Date.now()}`;
+    const now = new Date().toISOString();
+
+    // Handle explicit "none"/"unassigned"
+    const rawAgentId = params.agent_id as string | undefined;
+    const isUnassigned =
+      rawAgentId &&
+      ["none", "unassigned", "null", ""].includes(rawAgentId.toLowerCase().trim());
+
+    const assignee = isUnassigned ? null : await resolveAgent(rawAgentId);
+
+    const insertData: Record<string, unknown> = {
+      id,
+      user_id: userId,
+      title: params.title,
+      description: (params.description as string) || null,
+      agent_id: assignee,
+      assignee_type: "agent",
+      status: (params.status as string) || "PENDING",
+      priority: params.priority !== undefined ? params.priority : 1,
+      space_id: (params.space_id as string) || null,
+      folder_id: (params.folder_id as string) || null,
+      start_date: (params.start_date as string) || null,
+      due_date: (params.due_date as string) || null,
+      tags: (params.tags as string[]) || [],
+      progress: 0,
+      sort_order: 0,
+      custom_fields: {},
+      created_at: now,
+      updated_at: now,
+    };
+
+    const { error } = await supabase.from("tasks").insert(insertData);
+
+    if (error) {
+      if (error.message?.includes("agent_id") || error.message?.includes("foreign key")) {
+        insertData.agent_id = null;
+        const retry = await supabase.from("tasks").insert(insertData);
+        if (retry.error) return err(retry.error.message);
+        return ok({
+          id,
+          message: `Task "${params.title}" created (agent_id "${assignee}" was invalid, assigned to none)`,
+          task: insertData,
+        });
+      }
+      return err(error.message);
+    }
+
+    return ok({
+      id,
+      message: `Task "${params.title}" created and assigned to ${assignee || "no one"}`,
+      task: insertData,
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+async function handleUpdateTask(
+  supabase: SupabaseClient,
+  userId: string,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.task_id) return err("Missing required field: task_id");
 
-  // ── OFIERE_LIST_AGENTS — Required (read-only, no side effects) ───────
+    const updates: Record<string, unknown> = { updated_at: new Date().toISOString() };
+    const fields = [
+      "title", "description", "status", "priority", "progress",
+      "agent_id", "start_date", "due_date", "tags",
+    ];
+    for (const f of fields) {
+      if (params[f] !== undefined) updates[f] = params[f];
+    }
+    if (params.status === "DONE") updates.completed_at = new Date().toISOString();
+
+    const { data, error } = await supabase
+      .from("tasks")
+      .update(updates)
+      .eq("id", params.task_id as string)
+      .eq("user_id", userId)
+      .select("id, title, status, priority, agent_id")
+      .single();
+
+    if (error) return err(error.message);
+    return ok({ message: `Task "${data?.title}" updated`, task: data });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+async function handleDeleteTask(
+  supabase: SupabaseClient,
+  userId: string,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.task_id) return err("Missing required field: task_id");
+    const taskId = params.task_id as string;
+
+    await supabase.from("scheduler_events").delete().eq("task_id", taskId);
+
+    const { data: subtasks } = await supabase
+      .from("tasks")
+      .select("id")
+      .eq("parent_task_id", taskId)
+      .eq("user_id", userId);
+
+    if (subtasks && subtasks.length > 0) {
+      for (const sub of subtasks) {
+        await supabase.from("scheduler_events").delete().eq("task_id", sub.id);
+      }
+      await supabase
+        .from("tasks")
+        .delete()
+        .in("id", subtasks.map((s: { id: string }) => s.id))
+        .eq("user_id", userId);
+    }
+
+    const { error } = await supabase
+      .from("tasks")
+      .delete()
+      .eq("id", taskId)
+      .eq("user_id", userId);
 
+    if (error) return err(error.message);
+    return ok({ message: `Task ${taskId} deleted`, deleted: true });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+// ─── META-TOOL: OFIERE_AGENT_OPS ────────────────────────────────────────────
+
+function registerAgentOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  fallbackAgentId: string,
+): void {
   api.registerTool({
-    name: "OFIERE_LIST_AGENTS",
-    label: "List Ofiere Agents",
+    name: "OFIERE_AGENT_OPS",
+    label: "Ofiere Agent Operations",
     description:
-      "List all available agents in the Ofiere system. " +
-      "Shows agent IDs, names, roles, and current status. " +
-      "Use this to find the right agent_id for task assignment.",
+      `Query agents in the Ofiere PM system.\n\n` +
+      `Actions:\n` +
+      `- "list": List all available agents with their IDs, names, roles, and status. Use this to find the correct agent_id for task assignment.`,
     parameters: {
       type: "object",
-      properties: {},
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          description: "The operation to perform",
+          enum: ["list"],
+        },
+      },
     },
-    async execute(_id: string, _params: Record<string, unknown>) {
-      try {
-        // Resolve calling agent's ID for the "your_agent_id" hint
-        const callerName = getCallingAgentName(api);
-        let yourAgentId = fallbackAgentId || "";
-        if (callerName && !yourAgentId) {
-          try {
-            yourAgentId = await resolveAgentId(callerName, userId, supabase);
-          } catch { /* ignore */ }
-        }
-
-        const { data, error } = await supabase
-          .from("agents")
-          .select("id, name, codename, role, status")
-          .eq("user_id", userId)
-          .order("name");
-
-        if (error) return err(error.message);
-        return ok({
-          agents: data || [],
-          count: (data || []).length,
-          your_agent_id: yourAgentId,
-        });
-      } catch (e) {
-        return err(e instanceof Error ? e.message : String(e));
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+
+      switch (action) {
+        case "list":
+          return handleListAgents(api, supabase, userId, fallbackAgentId);
+        default:
+          return err(`Unknown action "${action}". Valid actions: list`);
       }
     },
   });
+}
+
+async function handleListAgents(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  fallbackAgentId: string,
+): Promise<ToolResult> {
+  try {
+    // Resolve calling agent's ID for the "your_agent_id" hint
+    const callerName = getCallingAgentName(api);
+    let yourAgentId = fallbackAgentId || "";
+    if (callerName && !yourAgentId) {
+      try {
+        yourAgentId = await resolveAgentId(callerName, userId, supabase);
+      } catch { /* ignore */ }
+    }
+
+    const { data, error } = await supabase
+      .from("agents")
+      .select("id, name, codename, role, status")
+      .eq("user_id", userId)
+      .order("name");
+
+    if (error) return err(error.message);
+    return ok({
+      agents: data || [],
+      count: (data || []).length,
+      your_agent_id: yourAgentId,
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
 
+// ─── Public: Register All Meta-Tools ─────────────────────────────────────────
+// This is the single entry point called by index.ts.
+// Returns the number of tools registered for dynamic prompt generation.
+//
+// To expand: add new register*Ops() calls here and increment the count.
+
+export function registerTools(
+  api: any, // OpenClawPluginApi — typed as any to avoid import-path issues at install time
+  supabase: SupabaseClient,
+  config: OfiereConfig,
+): number {
+  const userId = config.userId;
+  const fallbackAgentId = config.agentId; // May be empty — that's fine
+
+  const resolveAgent = createAgentResolver(api, supabase, userId, fallbackAgentId);
+
+  // ── Register each domain meta-tool ──
+  registerTaskOps(api, supabase, userId, resolveAgent);
+  registerAgentOps(api, supabase, userId, fallbackAgentId);
+
+  // ── Count and log ──
+  const toolCount = 2; // Update this when adding new meta-tools
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
-  api.logger.info(`[ofiere] 5 tools registered (agent: ${agentLabel})`);
+  api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);
+
+  return toolCount;
 }