ofiere-openclaw-plugin 4.18.2 → 4.18.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.18.2",
+  "version": "4.18.4",
   "type": "module",
   "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"],

package/src/tools.ts

@@ -4269,6 +4269,18 @@ async function handleUpdatePlan(supabase: SupabaseClient, userId: string, params
     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);
+    } else if (params.name !== undefined || params.description !== undefined) {
+      // Sync plan_data inner name/description without replacing nodes
+      const { data: existing } = await supabase.from("pm_plans").select("plan_data").eq("id", params.plan_id as string).eq("user_id", userId);
+      if (existing && existing.length > 0) {
+        try {
+          const pd = JSON.parse(existing[0].plan_data || "{}");
+          if (params.name !== undefined) pd.name = params.name;
+          if (params.description !== undefined) pd.description = params.description;
+          pd.updatedAt = new Date().toISOString();
+          updates.plan_data = JSON.stringify(pd, null, 2);
+        } catch { /* plan_data parse failure — skip inner sync */ }
+      }
     }
     const { data, error } = await supabase.from("pm_plans").update(updates).eq("id", params.plan_id as string).eq("user_id", userId).select("id");
     if (error) return err(error.message);
@@ -4334,15 +4346,23 @@ async function handleExecutePlan(
     let folderId = (params.folder_id as string) || null;
 
     // Step 1: Create project folder
+    let folderSkipped = false;
+    let folderError: string | null = null;
     if (createFolder && spaceId) {
       const folderRow = {
         id: crypto.randomUUID(),
-        user_id: userId, space_id: spaceId, name: plan.name || "Untitled Plan",
-        type: "project", parent_folder_id: folderId, sort_order: 0,
+        user_id: userId, space_id: spaceId, name: data.name || plan.name || "Untitled Plan",
+        folder_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;
+      if (!folderErr) {
+        folderId = folderRow.id;
+      } else {
+        folderError = folderErr.message;
+      }
+    } else if (createFolder && !spaceId) {
+      folderSkipped = true;
     }
 
     // Step 2: BFS — create tasks with full field mapping
@@ -4352,7 +4372,7 @@ async function handleExecutePlan(
 
     while (queue.length > 0) {
       const { node, parentTaskId } = queue.shift()!;
-      if (node.type === "task" || node.type === "milestone") {
+      if (node.type === "task") {
         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;
@@ -4413,48 +4433,78 @@ async function handleExecutePlan(
       }
     }
 
-    // Step 3: Create dependencies (sequential chain)
+    // Step 3: Create dependencies — sibling chaining + parent→child
     const depsQueue = [...rootNodes];
     let depsCreated = 0;
+
+    // Helper: resolve a node to its nearest task ID (skip gates/milestones)
+    function resolveTaskId(n: any): string | undefined {
+      return idMap.get(n.id);
+    }
+
     while (depsQueue.length > 0) {
       const node = depsQueue.shift()!;
-      const nodeRealId = idMap.get(node.id);
+      const nodeRealId = resolveTaskId(node);
+
+      // Chain siblings: sequential children of this node get chained left-to-right
+      if (Array.isArray(node.children) && node.children.length > 1 && !node.parallel) {
+        // Collect task-type children in order for chaining
+        const taskChildren: string[] = [];
+        for (const child of node.children) {
+          const cid = resolveTaskId(child);
+          if (cid) taskChildren.push(cid);
+        }
+        for (let i = 1; i < taskChildren.length; i++) {
+          await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: taskChildren[i - 1], successor_id: taskChildren[i], dependency_type: "finish_to_start", lag_days: 0 });
+          depsCreated++;
+        }
+      }
+
+      // Parent → first child link (sequential only)
       if (nodeRealId && !node.parallel && node.children?.length > 0) {
-        const firstChildId = idMap.get(node.children[0].id);
+        const firstChildId = resolveTaskId(node.children[0]);
         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++;
-          }
-        }
       }
+
+      // Parallel fan-out: parent → each child
       if (nodeRealId && node.parallel && node.children?.length > 0) {
         for (const child of node.children) {
-          const childId = idMap.get(child.id);
+          const childId = resolveTaskId(child);
           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);
     }
 
+    // Chain root-level siblings (sequential root nodes)
+    const rootTaskIds: string[] = [];
+    for (const rn of rootNodes) {
+      const rid = resolveTaskId(rn);
+      if (rid) rootTaskIds.push(rid);
+    }
+    for (let i = 1; i < rootTaskIds.length; i++) {
+      await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: rootTaskIds[i - 1], successor_id: rootTaskIds[i], dependency_type: "finish_to_start", lag_days: 0 });
+      depsCreated++;
+    }
+
     // 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`,
+      message: `Plan "${data.name || plan.name}" executed successfully`,
       tasks_created: tasksCreated,
       dependencies_created: depsCreated,
       folder_id: folderId,
       space_id: spaceId,
+      ...(folderSkipped ? { folder_skipped_reason: "No space_id provided — assign the plan to a space to enable folder creation" } : {}),
+      ...(folderError ? { folder_error: folderError } : {}),
     });
   } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
 }