ofiere-openclaw-plugin 4.17.0 → 4.18.1

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.17.0",
+  "version": "4.18.1",
   "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

@@ -116,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: {
@@ -177,6 +191,10 @@ ${toolDocs}
 - 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

@@ -4044,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)", items: { type: "object", properties: { title: { type: "string" }, type: { type: "string", enum: ["task", "gate", "milestone"] }, description: { type: "string" }, agent_id: { type: "string" }, priority: { type: "number" }, status: { type: "string" }, start_date: { type: "string" }, due_date: { type: "string" }, parallel: { type: "boolean" } }, required: ["title"] } },
+            },
+            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
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -4072,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})`);