ofiere-openclaw-plugin 4.54.2 → 4.56.0

package/src/tools.ts

@@ -23,6 +23,8 @@ import {
 } from "./attachments.js";
 import { invalidateAgentTier } from "./agent-tier.js";
 import { loadSubagentRow, readDispatchSubagentId, loadDispatchContextBySession, type DispatchContextRow } from "./staffPersona.js";
+import { expandPlanToDependencyEdges, type PlanNode } from "./planExecute.js";
+import { registerGateOps } from "./gateOps.js";
 
 // ─── Tool result shape (matches OpenClaw SDK) ────────────────────────────────
 
@@ -5033,7 +5035,7 @@ async function handleExecutePlan(
 
     while (queue.length > 0) {
       const { node, parentTaskId } = queue.shift()!;
-      if (node.type === "task") {
+      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;
@@ -5094,70 +5096,36 @@ async function handleExecutePlan(
       }
     }
 
-    // Step 3: Create dependencies — sibling chaining + parent→child
-    const depsQueue = [...rootNodes];
+    // Step 3: Build dependencies + manual-gate rows via shared helper.
+    // The helper handles gate-skip-through (Option A), OR-join via group_id (Option B),
+    // and manual gates via pm_gates rows (Option C). See dashboard/lib/pm/planExecute.ts.
+    const { edges, gates: gateRows, emptyGates } = expandPlanToDependencyEdges(rootNodes as PlanNode[], idMap);
     let depsCreated = 0;
+    let gatesCreated = 0;
 
-    // Helper: resolve a node to its nearest task ID (skip gates/milestones)
-    function resolveTaskId(n: any): string | undefined {
-      return idMap.get(n.id);
-    }
-
-    // Helper: insert a dependency row into pm_dependencies
-    async function insertDep(predId: string, succId: string): Promise<boolean> {
+    for (const e of edges) {
       const { error } = await supabase.from("pm_dependencies").insert({
         id: `dep-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-        user_id: userId, predecessor_id: predId, successor_id: succId,
-        dependency_type: "finish_to_start", lag_days: 0,
+        user_id: userId,
+        predecessor_id: e.predTaskId,
+        successor_id: e.succTaskId,
+        dependency_type: e.dependencyType,
+        lag_days: e.lagDays,
+        group_id: e.groupId,
       });
-      return !error;
-    }
-
-    while (depsQueue.length > 0) {
-      const node = depsQueue.shift()!;
-      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) {
-        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++) {
-          if (await insertDep(taskChildren[i - 1], taskChildren[i])) depsCreated++;
-        }
-      }
-
-      // Parent → first child link (sequential only)
-      if (nodeRealId && !node.parallel && node.children?.length > 0) {
-        const firstChildId = resolveTaskId(node.children[0]);
-        if (firstChildId) {
-          if (await insertDep(nodeRealId, firstChildId)) depsCreated++;
-        }
-      }
-
-      // Parallel fan-out: parent → each child
-      if (nodeRealId && node.parallel && node.children?.length > 0) {
-        for (const child of node.children) {
-          const childId = resolveTaskId(child);
-          if (childId) {
-            if (await insertDep(nodeRealId, childId)) depsCreated++;
-          }
-        }
-      }
-
-      if (Array.isArray(node.children)) depsQueue.push(...node.children);
+      if (!error) depsCreated++;
     }
 
-    // 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++) {
-      if (await insertDep(rootTaskIds[i - 1], rootTaskIds[i])) depsCreated++;
+    for (const g of gateRows) {
+      const { error } = await supabase.from("pm_gates").insert({
+        user_id: userId,
+        plan_id: params.plan_id as string,
+        plan_node_id: g.planNodeId,
+        gate_label: g.gateLabel,
+        gate_condition: g.gateCondition,
+        task_id_blocked: g.taskIdBlocked,
+      });
+      if (!error) gatesCreated++;
     }
 
     // Mark plan as deployed
@@ -5167,6 +5135,8 @@ async function handleExecutePlan(
       message: `Plan "${data.name || plan.name}" executed successfully`,
       tasks_created: tasksCreated,
       dependencies_created: depsCreated,
+      gates_created: gatesCreated,
+      empty_gates: emptyGates,
       folder_id: folderId,
       space_id: spaceId,
       ...(folderSkipped ? { folder_skipped_reason: "No space_id provided — assign the plan to a space to enable folder creation" } : {}),
@@ -7088,6 +7058,7 @@ export function registerTools(
   registerTalentOps(api, supabase, userId);                   // 15
   registerFrameworkOps(api, supabase, userId, resolveAgent);  // 16
   registerOfficeOps(api, supabase, userId, resolveAgent);     // 17
+  registerGateOps(api, supabase, userId, fallbackAgentId);    // 18
 
   // ── Register dynamic brain context hook ──
   registerBrainContextHook(api, supabase, userId, fallbackAgentId);
@@ -7102,7 +7073,7 @@ export function registerTools(
   registerBrainExtractionHook(api, supabase, userId, fallbackAgentId);
 
   // ── Count and log ──
-  const toolCount = 17;
+  const toolCount = 18;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);
@@ -7395,6 +7366,118 @@ function registerBrainExtractionHook(
           return;
         }
 
+        // FIX-A2A-LATE-REPLY — direct chief↔chief A2A late reply.
+        // Dashboard's relayToOpenClaw caps the synchronous wait at 45s; when
+        // the responding chief takes longer (e.g. while running its own tool
+        // calls), the dashboard WS closes and the eventual reply is dropped.
+        // dispatch_context was pre-written with { conversation_id,
+        // source_agent_id, a2a_pair_id } so we can route the late reply back:
+        //   1. Insert the assistant turn into conversation_messages for the
+        //      A2A conversation so reloading the page shows the reply.
+        //   2. POST a `chief_reply` webhook so the dashboard SSE can swap the
+        //      "still processing" placeholder bubble in the active chat UI.
+        // Guarded by: a2a_pair_id is set AND subagent_id is null AND task_id
+        // is null — so neither the staff nor the scheduled branches above
+        // can collide with this path.
+        const a2aPairId = dispatchCtxRow?.a2a_pair_id ?? null;
+        const a2aSourceAgentId = dispatchCtxRow?.source_agent_id ?? null;
+        const a2aConversationId = dispatchCtxRow?.conversation_id ?? null;
+        if (
+          a2aPairId &&
+          !staffDispatchSubagentId &&
+          !dispatchTaskIdFromCtx &&
+          a2aConversationId
+        ) {
+          (async () => {
+            try {
+              const excerpt = lastAssistant.slice(0, 4000);
+              if (!excerpt) {
+                api.logger.warn?.(`[ofiere-a2a-reply] empty assistant text — skipping late-reply persistence`);
+                return;
+              }
+
+              // Insert assistant turn into the A2A conversation. The
+              // dashboard's synchronous path also writes the assistant row
+              // when the reply lands in-window — UI dedup is by content +
+              // a2a_conversation_id so a duplicate from a race is benign.
+              try {
+                await supabase.from("conversation_messages").insert({
+                  conversation_id: a2aConversationId,
+                  user_id: userId,
+                  role: "assistant",
+                  content: excerpt,
+                  metadata: {
+                    sender_agent_id: resolvedAgentId,
+                    target_agent_id: a2aSourceAgentId,
+                    late_reply: true,
+                  },
+                  branch_id: "main",
+                });
+                await supabase.from("conversations")
+                  .update({ updated_at: new Date().toISOString() })
+                  .eq("id", a2aConversationId)
+                  .eq("user_id", userId);
+                // Best-effort message-count bump. RPC may not exist on older
+                // schemas — swallow the error if it 404s.
+                try {
+                  await supabase.rpc("increment_conversation_message_count", {
+                    conv_id: a2aConversationId,
+                  });
+                } catch { /* RPC missing — count drift is acceptable */ }
+              } catch (cmErr) {
+                api.logger.warn?.(`[ofiere-a2a-reply] conversation_messages insert failed: ${cmErr instanceof Error ? cmErr.message : String(cmErr)}`);
+              }
+
+              // Resolve responder agent name for the webhook payload so the
+              // UI bubble can be attributed correctly without another DB hit.
+              let responderName: string | null = null;
+              try {
+                const { data: agentRow } = await supabase
+                  .from("agents")
+                  .select("name")
+                  .eq("id", resolvedAgentId)
+                  .eq("user_id", userId)
+                  .maybeSingle();
+                responderName = (agentRow?.name as string | undefined) ?? null;
+              } catch { /* fall back to agent id */ }
+
+              const webhookUrl = process.env.OFIERE_DASHBOARD_WEBHOOK_URL || "";
+              const webhookSecret = process.env.OPENCLAW_WEBHOOK_SECRET || "";
+              if (webhookUrl && webhookSecret) {
+                try {
+                  await fetch(webhookUrl, {
+                    method: "POST",
+                    headers: {
+                      "content-type": "application/json",
+                      authorization: `Bearer ${webhookSecret}`,
+                    },
+                    body: JSON.stringify({
+                      type: "chief_reply",
+                      payload: {
+                        user_id: userId,
+                        source_agent_id: a2aSourceAgentId,
+                        target_agent_id: resolvedAgentId,
+                        target_agent_name: responderName,
+                        conversation_id: a2aConversationId,
+                        a2a_pair_id: a2aPairId,
+                        response: excerpt,
+                      },
+                    }),
+                  });
+                  api.logger.info?.(`[ofiere-a2a-reply] chief_reply webhook posted (conv=${a2aConversationId})`);
+                } catch (wErr) {
+                  api.logger.debug?.(`[ofiere-a2a-reply] webhook post failed: ${wErr instanceof Error ? wErr.message : String(wErr)}`);
+                }
+              }
+            } catch (aErr) {
+              api.logger.warn?.(`[ofiere-a2a-reply] failed: ${aErr instanceof Error ? aErr.message : String(aErr)}`);
+            }
+          })();
+          // Continue to brain extraction below — A2A late-reply is purely
+          // additive bookkeeping; the responding chief still owns the L1/L2
+          // memory writes for its own turn.
+        }
+
         // BUG 9 fix (BUGSHOOT-2): mark task_dispatch_log row complete for
         // non-staff scheduled dispatches too. Without this the log row stays
         // at 'dispatched' even after the chief finished the run.