ofiere-openclaw-plugin 4.16.0 → 4.18.0

package/README.md

@@ -5,7 +5,7 @@ Manage your Ofiere PM dashboard directly from OpenClaw agents. Create tasks, man
 ## Quick Install (One-Click)
 
 ```bash
-curl -sSL https://raw.githubusercontent.com/gilanggemar/Ofiere/main/ofiere-openclaw-plugin/install.sh | bash -s -- \
+curl -sSL https://ofiere.com/scripts/install.sh | bash -s -- \
   --supabase-url "https://xxx.supabase.co" \
   --service-key "eyJ..." \
   --user-id "your-uuid"
@@ -16,7 +16,7 @@ Only 3 parameters needed. All agents get the plugin automatically.
 ## Uninstall
 
 ```bash
-curl -sSL https://raw.githubusercontent.com/gilanggemar/Ofiere/main/ofiere-openclaw-plugin/uninstall.sh | bash
+curl -sSL https://ofiere.com/scripts/uninstall.sh | bash
 ```
 
 ## How It Works

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.16.0",
+  "version": "4.18.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM - 11 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, and space file management",
+  "description": "OpenClaw plugin for Ofiere PM - 12 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, and execution plan builder",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/prompt.ts

@@ -62,10 +62,19 @@ const TOOL_DOCS: Record<string, string> = {
     - Edge handles: condition edges use sourceHandle "condition-true"/"condition-false". Loop edges use "loop_body"/"done"
     - Variables: Use {{prev.nodeId.outputText}} for prior outputs, {{variables.key}} for stored variables`,
 
-  OFIERE_NOTIFY_OPS: `- **OFIERE_NOTIFY_OPS** — Notifications (action: "list", "mark_read", "mark_all_read", "delete")
+  OFIERE_NOTIFY_OPS: `- **OFIERE_NOTIFY_OPS** — Notifications & Channel Reports (action: "list", "mark_read", "mark_all_read", "delete", "send_report", "schedule_report", "list_schedules", "delete_schedule")
     - list: Recent notifications. unread_only=true for unread only
     - mark_read: Mark one notification read by ID
-    - mark_all_read: Mark all as read`,
+    - mark_all_read: Mark all as read
+    - send_report: Send a PM progress report to YOUR connected channels (Telegram, Discord, Slack, etc.)
+      - Required: scope_type (space|folder|project|task|all)
+      - Optional: scope_id, channel_types[] (filter to specific channels), include_completed
+      - The report is automatically generated from current PM data and sent through YOUR channel bindings ONLY
+    - schedule_report: Create a recurring/scheduled report
+      - Required: scope_type, recurrence_type (hourly|daily|weekly|monthly)
+      - Optional: scope_id, scope_label, channel_types[], recurrence_time (HH:MM UTC, default 09:00), recurrence_interval, recurrence_days_of_week (e.g. "mon,wed,fri"), include_completed
+    - list_schedules: View all your active report schedules
+    - delete_schedule: Remove a scheduled report by schedule_id`,
 
   OFIERE_MEMORY_OPS: `- **OFIERE_MEMORY_OPS** — Conversation history & knowledge memory (action: "list_conversations", "get_messages", "search_messages", "add_knowledge", "search_knowledge")
     - list_conversations: Recent chats, filter by agent_id
@@ -107,6 +116,20 @@ const TOOL_DOCS: Record<string, string> = {
     - delete_folder: Remove folder + all nested files recursively. Required: folder_id
     - share_file / unshare_file: Toggle shared status. Required: file_id
     - Files created here appear in the PM Space Files tab immediately`,
+
+  OFIERE_PLAN_OPS: `- **OFIERE_PLAN_OPS** — Visual execution plan builder (action: "list", "get", "create", "update", "delete", "add_nodes", "execute")
+    - list: All saved plans. Optional: space_id filter
+    - get: Full plan with complete node tree. Required: plan_id
+    - create: New plan. Required: name. Optional: description, space_id, nodes[] (initial tree)
+    - update: Modify plan. Required: plan_id. Optional: name, description, nodes[] (full tree replace)
+    - delete: Remove plan. Required: plan_id
+    - add_nodes: Add nodes to existing plan. Required: plan_id, nodes[]. Optional: parent_node_id (null = add as root)
+    - execute: Deploy plan into real PM tasks/folders/dependencies. Required: plan_id. Optional: create_folder (default true), create_scheduler (default true), space_id, folder_id
+    - Node types: task, gate, milestone
+    - Node fields: type, title, description, agent_id, priority (0-3), status (PENDING/IN_PROGRESS/DONE/FAILED), start_date, due_date, tags[], execution_steps[{text}], goals[{label, type?}], constraints[{label, type?}], system_prompt, children[], parallel (boolean)
+    - Plans are visual DAG drafts — they don't become real tasks until you call "execute"
+    - Execution maps ALL node fields into real tasks: execution_steps → custom_fields.execution_plan, goals → custom_fields.goals, constraints → custom_fields.constraints, system_prompt → custom_fields.system_prompt
+    - The user can see and edit your plans in the Planning Tab of the dashboard in real-time`,
 };
 
 export function getSystemPrompt(state: {
@@ -165,6 +188,13 @@ ${toolDocs}
 - When task instructions or system prompts contain file references like @[filename](file:FILE_ID), use OFIERE_FILE_OPS action:"read_text_file" file_id:"FILE_ID" to read the file content. Do NOT ask the user for the file — retrieve it yourself.
 - Use OFIERE_FILE_OPS to create output files (reports, data, configs) in the Space Files explorer. Prefer create_text_file for text-based outputs.
 - To save task output as a file, call OFIERE_FILE_OPS action:"create_text_file" with the space_id from the task context.
+- CHANNEL REPORTS: When the user asks you to "send a report", "send progress", "update me on Telegram/Discord/Slack/WhatsApp", use OFIERE_NOTIFY_OPS action:"send_report". The report is generated from live PM data and sent through YOUR connected channels ONLY — not other agents' channels.
+- To set up recurring reports (e.g. "send me a daily report at 9am"), use OFIERE_NOTIFY_OPS action:"schedule_report" with scope_type and recurrence_type.
+- If a report is too long for the channel's message limit, save the full report as a markdown file using OFIERE_FILE_OPS action:"create_text_file" and send a summary to the channel instead.
+- PLANNING WORKFLOW: Use OFIERE_PLAN_OPS to build complex multi-step execution flows BEFORE creating individual tasks. Build the plan → let the user review in the Planning Tab → execute when approved.
+- When creating a plan with nodes, nest children inside each node's children[] array. Sequential children execute in order; set parallel: true on a parent node to fork its children into parallel branches.
+- Always call OFIERE_PLAN_OPS action:"get" before action:"add_nodes" or action:"update" to see the current tree structure and node IDs.
+- Execution ("execute") maps plan nodes 1:1 into real PM tasks with ALL enrichment fields preserved: execution_steps, goals, constraints, system_prompt. No data is lost in the handoff.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -2144,24 +2144,51 @@ function registerNotifyOps(
   supabase: SupabaseClient,
   userId: string,
 ): void {
+  // Helper: resolve the agent's own ID for agent-scoped operations
+  const resolveAgentId = (): string => {
+    try {
+      const state = api.getState?.() || {};
+      return state.agentId || process.env.OFIERE_AGENT_ID || "";
+    } catch { return process.env.OFIERE_AGENT_ID || ""; }
+  };
+
   api.registerTool({
     name: "OFIERE_NOTIFY_OPS",
-    label: "Ofiere Notification Operations",
+    label: "Ofiere Notification & Report Operations",
     description:
-      `Read and manage notifications.\n\n` +
+      `Read/manage notifications and send PM reports to your connected channels.\n\n` +
       `Actions:\n` +
       `- "list": List notifications. Optional: unread_only (true/false), limit\n` +
       `- "mark_read": Mark one as read. Required: id\n` +
       `- "mark_all_read": Mark all as read\n` +
-      `- "delete": Delete a notification. Required: id`,
+      `- "delete": Delete a notification. Required: id\n` +
+      `- "send_report": Send a PM progress report to YOUR connected channels (Telegram, Discord, etc.)\n` +
+      `    Required: scope_type (space|folder|project|task|all)\n` +
+      `    Optional: scope_id, channel_types[] (filter specific channels), include_completed (default true)\n` +
+      `- "schedule_report": Create a recurring/scheduled report\n` +
+      `    Required: scope_type, recurrence_type (hourly|daily|weekly|monthly)\n` +
+      `    Optional: scope_id, scope_label, channel_types[], recurrence_time (HH:MM UTC, default 09:00),\n` +
+      `             recurrence_interval (default 1), recurrence_days_of_week (e.g. "mon,wed,fri"), include_completed\n` +
+      `- "list_schedules": List your active report schedules\n` +
+      `- "delete_schedule": Delete a scheduled report. Required: schedule_id`,
     parameters: {
       type: "object",
       required: ["action"],
       properties: {
-        action: { type: "string", enum: ["list", "mark_read", "mark_all_read", "delete"] },
+        action: { type: "string", enum: ["list", "mark_read", "mark_all_read", "delete", "send_report", "schedule_report", "list_schedules", "delete_schedule"] },
         id: { type: "string", description: "Notification ID" },
+        schedule_id: { type: "string", description: "Schedule ID (for delete_schedule)" },
         unread_only: { type: "boolean", description: "Only show unread" },
         limit: { type: "number", description: "Max results (default 50)" },
+        scope_type: { type: "string", enum: ["space", "folder", "project", "task", "all"], description: "Report scope" },
+        scope_id: { type: "string", description: "ID of the space/folder/project/task" },
+        scope_label: { type: "string", description: "Human-readable label for the scope" },
+        channel_types: { type: "array", items: { type: "string" }, description: "Filter to specific channels (e.g. ['telegram'])" },
+        include_completed: { type: "boolean", description: "Include completed tasks in report" },
+        recurrence_type: { type: "string", enum: ["hourly", "daily", "weekly", "monthly"], description: "How often to send" },
+        recurrence_interval: { type: "number", description: "Interval multiplier (default 1)" },
+        recurrence_time: { type: "string", description: "Time in HH:MM UTC (default 09:00)" },
+        recurrence_days_of_week: { type: "string", description: "Comma-separated days for weekly (e.g. mon,wed,fri)" },
       },
     },
     async execute(_id: string, params: Record<string, unknown>) {
@@ -2194,13 +2221,267 @@ function registerNotifyOps(
           if (error) return err(error.message);
           return ok({ message: "Notification deleted", ok: true });
         }
+
+        // ── SEND REPORT — Dispatch PM report to agent's channels ──
+        case "send_report": {
+          const scopeType = (params.scope_type as string) || "all";
+          const scopeId = params.scope_id as string | undefined;
+          const channelTypes = (params.channel_types as string[]) || [];
+          const includeCompleted = params.include_completed !== false;
+          const agentId = resolveAgentId();
+          if (!agentId) return err("Cannot resolve your agent ID. Ensure OFIERE_AGENT_ID is configured.");
+
+          // Call the dashboard API to generate + dispatch
+          const supabaseUrl = (supabase as any).supabaseUrl || process.env.OFIERE_SUPABASE_URL || process.env.SUPABASE_URL || "";
+          const serviceRoleKey = (supabase as any).supabaseKey || process.env.OFIERE_SERVICE_ROLE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY || "";
+
+          // Generate report directly from DB (we have service-role access)
+          const reportResult = await generatePMReportDirect(supabase, userId, scopeType, scopeId, agentId, includeCompleted);
+
+          // Dispatch to channels
+          const delivery = await dispatchReportDirect(supabase, userId, agentId, reportResult.report, channelTypes);
+
+          // Create audit notification
+          await supabase.from("notifications").insert({
+            id: crypto.randomUUID(),
+            user_id: userId,
+            title: `Report sent: ${reportResult.scopeLabel}`,
+            message: `Dispatched via ${delivery.sent.join(", ") || "no channels"}. ${reportResult.taskCount} tasks.`,
+            type: "system",
+            category: "project_management",
+            read: false,
+          });
+
+          return ok({
+            message: `Report sent to ${delivery.sent.length} channel(s)`,
+            channels_sent: delivery.sent,
+            channels_failed: delivery.failed,
+            task_count: reportResult.taskCount,
+            scope: reportResult.scopeLabel,
+            report_preview: reportResult.report.slice(0, 500),
+          });
+        }
+
+        // ── SCHEDULE REPORT — Create recurring report ──
+        case "schedule_report": {
+          const scopeType = (params.scope_type as string) || "all";
+          const recurrenceType = (params.recurrence_type as string) || "daily";
+          const agentId = resolveAgentId();
+          if (!agentId) return err("Cannot resolve your agent ID.");
+
+          const recurrenceTime = (params.recurrence_time as string) || "09:00";
+          const recurrenceInterval = (params.recurrence_interval as number) || 1;
+          const recurrenceDaysOfWeek = (params.recurrence_days_of_week as string) || null;
+
+          // Compute next run
+          const [hours, minutes] = recurrenceTime.split(":").map(Number);
+          const next = new Date();
+          next.setUTCHours(hours, minutes, 0, 0);
+          if (next.getTime() <= Date.now()) next.setUTCDate(next.getUTCDate() + 1);
+
+          const { data, error } = await supabase.from("pm_report_schedules").insert({
+            user_id: userId,
+            agent_id: agentId,
+            scope_type: scopeType,
+            scope_id: (params.scope_id as string) || null,
+            scope_label: (params.scope_label as string) || null,
+            channel_types: (params.channel_types as string[]) || [],
+            recurrence_type: recurrenceType,
+            recurrence_interval: recurrenceInterval,
+            recurrence_time: recurrenceTime,
+            recurrence_days_of_week: recurrenceDaysOfWeek,
+            include_completed: params.include_completed !== false,
+            next_run_at: next.toISOString(),
+          }).select().single();
+
+          if (error) return err(error.message);
+          return ok({
+            message: `Scheduled ${recurrenceType} report created`,
+            schedule_id: data.id,
+            next_run: next.toISOString(),
+            recurrence: `${recurrenceType} at ${recurrenceTime} UTC`,
+          });
+        }
+
+        // ── LIST SCHEDULES ──
+        case "list_schedules": {
+          const { data, error } = await supabase.from("pm_report_schedules")
+            .select("*")
+            .eq("user_id", userId)
+            .order("created_at", { ascending: false });
+          if (error) return err(error.message);
+          return ok({ schedules: data || [], count: (data || []).length });
+        }
+
+        // ── DELETE SCHEDULE ──
+        case "delete_schedule": {
+          const scheduleId = (params.schedule_id || params.id) as string;
+          if (!scheduleId) return err("Missing required: schedule_id");
+          const { error } = await supabase.from("pm_report_schedules")
+            .delete().eq("id", scheduleId).eq("user_id", userId);
+          if (error) return err(error.message);
+          return ok({ message: "Schedule deleted", ok: true });
+        }
+
         default:
-          return err(`Unknown action "${action}".`);
+          return err(`Unknown action "${action}". Valid: list, mark_read, mark_all_read, delete, send_report, schedule_report, list_schedules, delete_schedule`);
       }
     },
   });
 }
 
+// ── Inline report generation for plugin (avoids HTTP roundtrip) ──
+
+async function generatePMReportDirect(
+  supabase: SupabaseClient,
+  userId: string,
+  scopeType: string,
+  scopeId: string | undefined,
+  agentId: string,
+  includeCompleted: boolean,
+): Promise<{ report: string; scopeLabel: string; taskCount: number }> {
+  let scopeLabel = "All Projects";
+  let query = supabase.from("tasks").select("id, title, status, priority, progress, completed_at, due_date")
+    .eq("user_id", userId).is("parent_task_id", null);
+
+  if (scopeType === "space" && scopeId) {
+    query = query.eq("space_id", scopeId);
+    const { data: s } = await supabase.from("pm_spaces").select("name").eq("id", scopeId).single();
+    scopeLabel = s?.name || "Space";
+  } else if (scopeType === "folder" && scopeId) {
+    query = query.eq("folder_id", scopeId);
+    const { data: f } = await supabase.from("pm_folders").select("name").eq("id", scopeId).single();
+    scopeLabel = f?.name || "Folder";
+  } else if (scopeType === "project" && scopeId) {
+    query = query.eq("project_id", scopeId);
+    const { data: p } = await supabase.from("pm_folders").select("name").eq("id", scopeId).single();
+    scopeLabel = p?.name || "Project";
+  }
+
+  const { data: tasks } = await query.order("priority", { ascending: false }).limit(40);
+  const all = tasks || [];
+
+  // Agent name
+  let agentName = agentId;
+  const { data: agentRow } = await supabase.from("agents").select("name, codename")
+    .eq("user_id", userId)
+    .or(`id.eq.${agentId},name.ilike.${agentId},codename.ilike.${agentId}`)
+    .limit(1).single();
+  if (agentRow) agentName = agentRow.name || agentRow.codename || agentId;
+
+  const completed = all.filter((t: any) => t.status === "DONE");
+  const inProgress = all.filter((t: any) => t.status === "IN_PROGRESS" || t.status === "RUNNING");
+  const pending = all.filter((t: any) => t.status === "PENDING" || t.status === "NEW");
+  const failed = all.filter((t: any) => t.status === "FAILED");
+
+  const lines: string[] = [];
+  lines.push(`📊 Project Report — ${scopeLabel}`);
+  lines.push(`Agent: ${agentName}`);
+  lines.push("");
+  lines.push("━━━ Summary ━━━");
+  lines.push(`✅ ${completed.length}  |  🔄 ${inProgress.length}  |  ⏳ ${pending.length}  |  ❌ ${failed.length}`);
+
+  if (inProgress.length > 0) {
+    lines.push("");
+    lines.push("━━━ Active ━━━");
+    for (const t of inProgress.slice(0, 8)) {
+      const pl = t.priority === 3 ? "CRIT" : t.priority === 2 ? "HIGH" : t.priority === 1 ? "MED" : "LOW";
+      lines.push(`🔄 [${pl}] ${t.title}${t.progress ? ` — ${t.progress}%` : ""}`);
+    }
+    if (inProgress.length > 8) lines.push(`... +${inProgress.length - 8} more`);
+  }
+
+  if (pending.length > 0) {
+    lines.push("");
+    lines.push("━━━ Pending ━━━");
+    for (const t of pending.slice(0, 6)) {
+      const pl = t.priority === 3 ? "CRIT" : t.priority === 2 ? "HIGH" : t.priority === 1 ? "MED" : "LOW";
+      lines.push(`⏳ [${pl}] ${t.title}`);
+    }
+    if (pending.length > 6) lines.push(`... +${pending.length - 6} more`);
+  }
+
+  if (includeCompleted && completed.length > 0) {
+    lines.push("");
+    lines.push("━━━ Done ━━━");
+    const recent = completed.filter((t: any) => t.completed_at)
+      .sort((a: any, b: any) => new Date(b.completed_at).getTime() - new Date(a.completed_at).getTime())
+      .slice(0, 5);
+    for (const t of recent) {
+      const diff = Date.now() - new Date(t.completed_at).getTime();
+      const mins = Math.floor(diff / 60000);
+      const ago = mins < 60 ? `${mins}m ago` : mins < 1440 ? `${Math.floor(mins / 60)}h ago` : `${Math.floor(mins / 1440)}d ago`;
+      lines.push(`✅ ${t.title} (${ago})`);
+    }
+  }
+
+  const now = new Date();
+  lines.push("");
+  lines.push(`Generated: ${now.toISOString().replace("T", " ").slice(0, 16)} UTC`);
+
+  return { report: lines.join("\n"), scopeLabel, taskCount: all.length };
+}
+
+async function dispatchReportDirect(
+  supabase: SupabaseClient,
+  userId: string,
+  agentId: string,
+  report: string,
+  channelTypes: string[],
+): Promise<{ sent: string[]; failed: string[] }> {
+  // Query agent's active channel bindings
+  let query = supabase.from("channel_bindings").select("channel_type, channel_account_id, channel_config")
+    .eq("user_id", userId)
+    .eq("agent_id", agentId)
+    .eq("notifications_enabled", true)
+    .eq("is_active", true);
+
+  if (channelTypes.length > 0) {
+    query = query.in("channel_type", channelTypes);
+  }
+
+  const { data: bindings } = await query;
+  if (!bindings || bindings.length === 0) {
+    return { sent: [], failed: ["No active channel bindings found for this agent"] };
+  }
+
+  const LIMITS: Record<string, number> = { telegram: 4096, discord: 2000, slack: 40000, whatsapp: 65536 };
+  const sent: string[] = [];
+  const failed: string[] = [];
+
+  for (const b of bindings) {
+    const limit = LIMITS[b.channel_type] || 4000;
+    let msg = report;
+    if (msg.length > limit) {
+      msg = msg.substring(0, limit - 80) + "\n\n... [Full report on dashboard]";
+    }
+
+    // Use the Ofiere dashboard API to send via gateway
+    // The dashboard URL is derived from the Supabase URL
+    const dashboardUrl = process.env.OFIERE_DASHBOARD_URL || "https://ofiere.com";
+    const dispatchSecret = process.env.DISPATCH_SECRET || "";
+
+    try {
+      const res = await fetch(`${dashboardUrl}/api/channels/gateway-send`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "x-dispatch-secret": dispatchSecret },
+        body: JSON.stringify({
+          userId,
+          channelType: b.channel_type,
+          accountId: b.channel_account_id || null,
+          message: msg,
+        }),
+      });
+      if (res.ok) sent.push(b.channel_type);
+      else failed.push(`${b.channel_type}: HTTP ${res.status}`);
+    } catch (e: any) {
+      failed.push(`${b.channel_type}: ${e.message || "fetch error"}`);
+    }
+  }
+
+  return { sent, failed };
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // META-TOOL 8: OFIERE_MEMORY_OPS — Conversations & Knowledge Fragments
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -3763,6 +4044,417 @@ async function handleShareFile(
   } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 12: OFIERE_PLAN_OPS — Execution Plan Builder
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerPlanOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+): void {
+  api.registerTool({
+    name: "OFIERE_PLAN_OPS",
+    label: "Ofiere Plan Operations",
+    description:
+      `Build and deploy visual execution plans (DAGs) in the Ofiere Planning Tab.\n\n` +
+      `Actions:\n` +
+      `- "list": List saved plans. Optional: space_id\n` +
+      `- "get": Get full plan with node tree. Required: plan_id\n` +
+      `- "create": New plan. Required: name. Optional: description, space_id, nodes[]\n` +
+      `- "update": Modify plan. Required: plan_id. Optional: name, description, nodes[]\n` +
+      `- "delete": Remove plan. Required: plan_id\n` +
+      `- "add_nodes": Add nodes to plan. Required: plan_id, nodes[]. Optional: parent_node_id\n` +
+      `- "execute": Deploy plan to real PM tasks. Required: plan_id. Optional: create_folder, create_scheduler, space_id, folder_id\n\n` +
+      `Node structure: { type, title, description?, agent_id?, priority?, status?, start_date?, due_date?, tags?, execution_steps?[{text}], goals?[{label,type?}], constraints?[{label,type?}], system_prompt?, children?[], parallel? }`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: { type: "string", enum: ["list", "get", "create", "update", "delete", "add_nodes", "execute"] },
+        plan_id: { type: "string", description: "Plan ID (required for get, update, delete, add_nodes, execute)" },
+        name: { type: "string", description: "Plan name (required for create)" },
+        description: { type: "string", description: "Plan description" },
+        space_id: { type: "string", description: "PM Space ID" },
+        folder_id: { type: "string", description: "PM Folder ID (for execute)" },
+        parent_node_id: { type: "string", description: "Parent node ID to attach new nodes to (add_nodes). Null = root level" },
+        create_folder: { type: "boolean", description: "Create a project folder on execute (default true)" },
+        create_scheduler: { type: "boolean", description: "Create scheduler events for dated tasks on execute (default true)" },
+        nodes: {
+          type: "array",
+          description: "Array of plan nodes. Each node can have children[] for nesting.",
+          items: {
+            type: "object",
+            properties: {
+              type: { type: "string", enum: ["task", "gate", "milestone"] },
+              title: { type: "string" },
+              description: { type: "string" },
+              agent_id: { type: "string" },
+              priority: { type: "number" },
+              status: { type: "string", enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"] },
+              start_date: { type: "string" },
+              due_date: { type: "string" },
+              tags: { type: "array", items: { type: "string" } },
+              execution_steps: { type: "array", items: { type: "object", properties: { text: { type: "string" } }, required: ["text"] } },
+              goals: { type: "array", items: { type: "object", properties: { label: { type: "string" }, type: { type: "string" } }, required: ["label"] } },
+              constraints: { type: "array", items: { type: "object", properties: { label: { type: "string" }, type: { type: "string" } }, required: ["label"] } },
+              system_prompt: { type: "string" },
+              parallel: { type: "boolean" },
+              children: { type: "array", description: "Nested child nodes (recursive)" },
+            },
+            required: ["title"],
+          },
+        },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+      switch (action) {
+        case "list": return handleListPlans(supabase, userId, params);
+        case "get": return handleGetPlan(supabase, userId, params);
+        case "create": return handleCreatePlan(supabase, userId, params);
+        case "update": return handleUpdatePlan(supabase, userId, params);
+        case "delete": return handleDeletePlan(supabase, userId, params);
+        case "add_nodes": return handleAddNodes(supabase, userId, params);
+        case "execute": return handleExecutePlan(supabase, userId, resolveAgent, params);
+        default: return err(`Unknown action "${action}". Valid: list, get, create, update, delete, add_nodes, execute`);
+      }
+    },
+  });
+}
+
+// ── Plan helpers ─────────────────────────────────────────────────────────────
+
+function generatePlanNodeId(): string {
+  return `pn-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+}
+
+function generatePlanId(): string {
+  return `plan-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+}
+
+/** Normalize agent-provided node into the PlanNode shape stored in plan_data */
+function normalizeNode(raw: any): any {
+  const id = raw.id || generatePlanNodeId();
+  const children = Array.isArray(raw.children) ? raw.children.map(normalizeNode) : [];
+  return {
+    id,
+    type: raw.type || "task",
+    title: raw.title || "Untitled",
+    description: raw.description || undefined,
+    agentId: raw.agent_id || raw.agentId || undefined,
+    assignees: raw.agent_id ? [{ id: raw.agent_id, type: "agent" }] : undefined,
+    priority: raw.priority ?? 1,
+    status: raw.status || "PENDING",
+    startDate: raw.start_date || raw.startDate || undefined,
+    dueDate: raw.due_date || raw.dueDate || undefined,
+    tags: raw.tags || [],
+    executionSteps: Array.isArray(raw.execution_steps)
+      ? raw.execution_steps.map((s: any, i: number) => ({ id: `step-${Date.now()}-${i}`, text: typeof s === "string" ? s : s.text || String(s), order: i }))
+      : undefined,
+    goals: Array.isArray(raw.goals)
+      ? raw.goals.map((g: any, i: number) => ({ id: `goal-${Date.now()}-${i}`, type: g.type || "custom", label: typeof g === "string" ? g : g.label || String(g) }))
+      : undefined,
+    constraints: Array.isArray(raw.constraints)
+      ? raw.constraints.map((c: any, i: number) => ({ id: `cstr-${Date.now()}-${i}`, type: c.type || "custom", label: typeof c === "string" ? c : c.label || String(c) }))
+      : undefined,
+    systemPrompt: raw.system_prompt || raw.systemPrompt || undefined,
+    gateCondition: raw.gate_condition || raw.gateCondition || (raw.type === "gate" ? "all_predecessors_complete" : undefined),
+    children,
+    parallel: raw.parallel || false,
+    collapsed: false,
+  };
+}
+
+/** Count all nodes in a tree (BFS) */
+function countAllNodes(nodes: any[]): number {
+  let count = 0;
+  const queue = [...nodes];
+  while (queue.length > 0) {
+    const n = queue.shift()!;
+    count++;
+    if (Array.isArray(n.children)) queue.push(...n.children);
+  }
+  return count;
+}
+
+/** Collect unique agent IDs from tree */
+function collectAgents(nodes: any[]): string[] {
+  const ids = new Set<string>();
+  const queue = [...nodes];
+  while (queue.length > 0) {
+    const n = queue.shift()!;
+    if (n.agentId) ids.add(n.agentId);
+    if (Array.isArray(n.assignees)) n.assignees.forEach((a: any) => { if (a.id) ids.add(a.id); });
+    if (Array.isArray(n.children)) queue.push(...n.children);
+  }
+  return Array.from(ids);
+}
+
+/** Build a full ExecutionPlan JSON from metadata + nodes */
+function buildPlanJson(id: string, name: string, description: string | undefined, rootNodes: any[]): string {
+  const plan = {
+    id,
+    name,
+    description,
+    rootNodes,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    metadata: { totalTasks: countAllNodes(rootNodes), totalAgents: collectAgents(rootNodes) },
+  };
+  return JSON.stringify(plan, null, 2);
+}
+
+/** Find a node by ID in a tree */
+function findNodeInTree(nodes: any[], nodeId: string): any | null {
+  for (const n of nodes) {
+    if (n.id === nodeId) return n;
+    if (Array.isArray(n.children)) {
+      const found = findNodeInTree(n.children, nodeId);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+// ── Plan action handlers ─────────────────────────────────────────────────────
+
+async function handleListPlans(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    let query = supabase.from("pm_plans").select("id, name, description, space_id, is_deployed, deployed_at, 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);
+    const { data, error } = await query;
+    if (error) return err(error.message);
+    return ok({ plans: data || [], count: (data || []).length });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleGetPlan(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.plan_id) return err("Missing required field: plan_id");
+    const { data, error } = await supabase.from("pm_plans").select("*").eq("id", params.plan_id as string).eq("user_id", userId).single();
+    if (error) return err(error.message);
+    let parsed: any = null;
+    try { parsed = JSON.parse(data.plan_data || "{}"); } catch { parsed = {}; }
+    return ok({ plan: { ...data, plan_data: parsed } });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleCreatePlan(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.name) return err("Missing required field: name");
+    const planId = generatePlanId();
+    const rootNodes = Array.isArray(params.nodes) ? (params.nodes as any[]).map(normalizeNode) : [];
+    const planData = buildPlanJson(planId, params.name as string, params.description as string | undefined, rootNodes);
+    const row = {
+      id: planId, user_id: userId, space_id: (params.space_id as string) || null,
+      name: params.name as string, description: (params.description as string) || null,
+      plan_data: planData, is_deployed: false, deployed_at: null, updated_at: new Date().toISOString(),
+    };
+    const { error } = await supabase.from("pm_plans").insert(row);
+    if (error) return err(error.message);
+    return ok({ id: planId, message: `Plan "${params.name}" created with ${countAllNodes(rootNodes)} nodes`, node_count: countAllNodes(rootNodes) });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleUpdatePlan(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.plan_id) return err("Missing required field: plan_id");
+    const updates: Record<string, any> = { updated_at: new Date().toISOString() };
+    if (params.name !== undefined) updates.name = params.name;
+    if (params.description !== undefined) updates.description = params.description;
+    if (params.nodes !== undefined) {
+      const rootNodes = Array.isArray(params.nodes) ? (params.nodes as any[]).map(normalizeNode) : [];
+      updates.plan_data = buildPlanJson(params.plan_id as string, (params.name as string) || "Plan", params.description as string | undefined, rootNodes);
+    }
+    const { error } = await supabase.from("pm_plans").update(updates).eq("id", params.plan_id as string).eq("user_id", userId);
+    if (error) return err(error.message);
+    return ok({ message: `Plan updated` });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleDeletePlan(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.plan_id) return err("Missing required field: plan_id");
+    const { error } = await supabase.from("pm_plans").delete().eq("id", params.plan_id as string).eq("user_id", userId);
+    if (error) return err(error.message);
+    return ok({ message: `Plan deleted`, deleted: true });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleAddNodes(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.plan_id) return err("Missing required field: plan_id");
+    if (!params.nodes || !Array.isArray(params.nodes)) return err("Missing required field: nodes[]");
+    const { data, error: fetchErr } = await supabase.from("pm_plans").select("plan_data, name").eq("id", params.plan_id as string).eq("user_id", userId).single();
+    if (fetchErr || !data) return err("Plan not found");
+    let plan: any;
+    try { plan = JSON.parse(data.plan_data || "{}"); } catch { return err("Invalid plan data"); }
+    const newNodes = (params.nodes as any[]).map(normalizeNode);
+    const parentId = params.parent_node_id as string | undefined;
+    if (parentId) {
+      const parent = findNodeInTree(plan.rootNodes || [], parentId);
+      if (!parent) return err(`Parent node "${parentId}" not found in plan`);
+      if (!Array.isArray(parent.children)) parent.children = [];
+      parent.children.push(...newNodes);
+    } else {
+      if (!Array.isArray(plan.rootNodes)) plan.rootNodes = [];
+      plan.rootNodes.push(...newNodes);
+    }
+    plan.updatedAt = new Date().toISOString();
+    plan.metadata = { totalTasks: countAllNodes(plan.rootNodes), totalAgents: collectAgents(plan.rootNodes) };
+    const { error } = await supabase.from("pm_plans").update({ plan_data: JSON.stringify(plan, null, 2), updated_at: new Date().toISOString() }).eq("id", params.plan_id as string).eq("user_id", userId);
+    if (error) return err(error.message);
+    return ok({ message: `Added ${newNodes.length} nodes${parentId ? ` under ${parentId}` : " as roots"}`, total_nodes: countAllNodes(plan.rootNodes) });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleExecutePlan(
+  supabase: SupabaseClient, userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.plan_id) return err("Missing required field: plan_id");
+    const { data, error: fetchErr } = await supabase.from("pm_plans").select("*").eq("id", params.plan_id as string).eq("user_id", userId).single();
+    if (fetchErr || !data) return err("Plan not found");
+    let plan: any;
+    try { plan = JSON.parse(data.plan_data || "{}"); } catch { return err("Invalid plan data"); }
+    const rootNodes: any[] = plan.rootNodes || [];
+    if (rootNodes.length === 0) return err("Plan has no nodes to execute");
+
+    const createFolder = params.create_folder !== false;
+    const createScheduler = params.create_scheduler !== false;
+    const spaceId = (params.space_id as string) || data.space_id || null;
+    let folderId = (params.folder_id as string) || null;
+
+    // Step 1: Create project folder
+    if (createFolder && spaceId) {
+      const folderRow = {
+        id: `folder-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        user_id: userId, space_id: spaceId, name: plan.name || "Untitled Plan",
+        type: "project", parent_folder_id: folderId, sort_order: 0,
+        created_at: new Date().toISOString(), updated_at: new Date().toISOString(),
+      };
+      const { error: folderErr } = await supabase.from("pm_folders").insert(folderRow);
+      if (!folderErr) folderId = folderRow.id;
+    }
+
+    // Step 2: BFS — create tasks with full field mapping
+    const idMap = new Map<string, string>();
+    const queue: { node: any; parentTaskId: string | null }[] = rootNodes.map((n: any) => ({ node: n, parentTaskId: null }));
+    let tasksCreated = 0;
+
+    while (queue.length > 0) {
+      const { node, parentTaskId } = queue.shift()!;
+      if (node.type === "task" || node.type === "milestone") {
+        const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const now = new Date().toISOString();
+        const agentId = node.agentId ? await resolveAgent(node.agentId) : null;
+
+        // Build custom_fields — the seamless handoff
+        const cf: Record<string, any> = { pm_only: true };
+        if (node.executionSteps && node.executionSteps.length > 0) cf.execution_plan = node.executionSteps;
+        if (node.goals && node.goals.length > 0) cf.goals = node.goals;
+        if (node.constraints && node.constraints.length > 0) cf.constraints = node.constraints;
+        if (node.systemPrompt) cf.system_prompt = node.systemPrompt;
+        if (agentId) cf.assignees = [{ id: agentId, type: "agent" }];
+
+        const taskRow = {
+          id: taskId, user_id: userId, title: node.title, description: node.description || null,
+          agent_id: agentId, assignee_type: agentId ? "agent" : "auto",
+          priority: node.priority ?? 1, status: node.status || "PENDING",
+          start_date: node.startDate || null, due_date: node.dueDate || null,
+          tags: node.tags || [], space_id: spaceId, folder_id: folderId,
+          parent_task_id: parentTaskId, progress: 0, sort_order: 0,
+          custom_fields: cf, created_at: now, updated_at: now,
+        };
+
+        const { error: taskErr } = await supabase.from("tasks").insert(taskRow);
+        if (!taskErr) {
+          idMap.set(node.id, taskId);
+          tasksCreated++;
+
+          // Scheduler event for dated tasks
+          if (createScheduler && node.startDate && agentId) {
+            try {
+              const parsedDate = new Date(node.startDate);
+              const scheduledDate = parsedDate.toISOString().split("T")[0];
+              const hasTime = /[T ]\d{2}:\d{2}/.test(node.startDate);
+              const scheduledTime = hasTime
+                ? `${String(parsedDate.getUTCHours()).padStart(2, "0")}:${String(parsedDate.getUTCMinutes()).padStart(2, "0")}`
+                : "09:00";
+              let nextRunAt = Math.floor(parsedDate.getTime() / 1000);
+              if (nextRunAt <= Math.floor(Date.now() / 1000)) nextRunAt = Math.floor(Date.now() / 1000) + 60;
+
+              await supabase.from("scheduler_events").insert({
+                id: crypto.randomUUID(), user_id: userId, task_id: taskId, agent_id: agentId,
+                title: node.title, description: node.description || null,
+                scheduled_date: scheduledDate, scheduled_time: scheduledTime,
+                duration_minutes: 30, recurrence_type: "none", recurrence_interval: 1,
+                status: "scheduled", next_run_at: nextRunAt, run_count: 0, priority: node.priority ?? 1,
+              });
+            } catch { /* scheduler is best-effort */ }
+          }
+        }
+      }
+
+      // Enqueue children
+      const realId = idMap.get(node.id) || null;
+      if (Array.isArray(node.children)) {
+        for (const child of node.children) {
+          queue.push({ node: child, parentTaskId: node.parallel ? parentTaskId : realId });
+        }
+      }
+    }
+
+    // Step 3: Create dependencies (sequential chain)
+    const depsQueue = [...rootNodes];
+    let depsCreated = 0;
+    while (depsQueue.length > 0) {
+      const node = depsQueue.shift()!;
+      const nodeRealId = idMap.get(node.id);
+      if (nodeRealId && !node.parallel && node.children?.length > 0) {
+        const firstChildId = idMap.get(node.children[0].id);
+        if (firstChildId) {
+          await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: nodeRealId, successor_id: firstChildId, dependency_type: "finish_to_start", lag_days: 0 });
+          depsCreated++;
+        }
+        for (let i = 1; i < node.children.length; i++) {
+          const prevId = idMap.get(node.children[i - 1].id);
+          const currId = idMap.get(node.children[i].id);
+          if (prevId && currId) {
+            await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: prevId, successor_id: currId, dependency_type: "finish_to_start", lag_days: 0 });
+            depsCreated++;
+          }
+        }
+      }
+      if (nodeRealId && node.parallel && node.children?.length > 0) {
+        for (const child of node.children) {
+          const childId = idMap.get(child.id);
+          if (childId) {
+            await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: nodeRealId, successor_id: childId, dependency_type: "finish_to_start", lag_days: 0 });
+            depsCreated++;
+          }
+        }
+      }
+      if (Array.isArray(node.children)) depsQueue.push(...node.children);
+    }
+
+    // Mark plan as deployed
+    await supabase.from("pm_plans").update({ is_deployed: true, deployed_at: new Date().toISOString(), updated_at: new Date().toISOString() }).eq("id", params.plan_id as string).eq("user_id", userId);
+
+    return ok({
+      message: `Plan "${plan.name}" executed successfully`,
+      tasks_created: tasksCreated,
+      dependencies_created: depsCreated,
+      folder_id: folderId,
+      space_id: spaceId,
+    });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -3791,9 +4483,10 @@ export function registerTools(
   registerPromptOps(api, supabase, userId);                   // 9
   registerConstellationOps(api, supabase, userId);            // 10
   registerFileOps(api, supabase, userId);                     // 11
+  registerPlanOps(api, supabase, userId, resolveAgent);       // 12
 
   // ── Count and log ──
-  const toolCount = 11;
+  const toolCount = 12;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);