ofiere-openclaw-plugin 4.54.2 → 4.56.0

package/dist/src/gateOps.js

@@ -0,0 +1,169 @@
+// src/gateOps.ts — OFIERE_GATE_OPS meta-tool
+// Approve / reject manual gates blocking task dispatch in the Planning Tab.
+//
+// Phase 0 finding: plugin factory carries no implicit agentId in closure.
+// The CALLING chief / staff agent MUST pass `agent_id` explicitly for approve/reject
+// so the audit trail records "agent:<id>" in approved_by / rejected_by.
+// Fallback order: args.agent_id → fallbackAgentId (gateway OFIERE_AGENT_ID env) → "user:<userId>".
+function ok(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function err(message) {
+    return { content: [{ type: "text", text: `Error: ${message}` }] };
+}
+// Bounded BFS — collect transitive successors so the agent sees cascade impact
+// before rejecting. Mirrors dashboard/lib/ofie/tool-executor.ts _collectTransitiveSuccessors.
+async function collectTransitiveSuccessors(supabase, userId, rootTaskId) {
+    const visited = new Set([rootTaskId]);
+    const out = [];
+    let frontier = [rootTaskId];
+    for (let depth = 0; depth < 20 && frontier.length > 0; depth++) {
+        const { data: deps } = await supabase
+            .from("pm_dependencies")
+            .select("successor_id")
+            .in("predecessor_id", frontier)
+            .eq("user_id", userId);
+        const next = [];
+        for (const d of (deps || [])) {
+            const sid = d.successor_id;
+            if (!sid || visited.has(sid))
+                continue;
+            visited.add(sid);
+            next.push(sid);
+        }
+        if (next.length === 0)
+            break;
+        const { data: tasks } = await supabase
+            .from("tasks")
+            .select("id, title")
+            .in("id", next)
+            .eq("user_id", userId);
+        for (const t of (tasks || []))
+            out.push({ id: t.id, title: t.title });
+        frontier = next;
+    }
+    return out;
+}
+export function registerGateOps(api, supabase, userId, fallbackAgentId) {
+    api.registerTool({
+        name: "OFIERE_GATE_OPS",
+        label: "Ofiere Gate Operations",
+        description: `Approve or reject manual gates blocking task dispatch in the Planning Tab.\n\n` +
+            `Actions:\n` +
+            `- "list_pending": List manual gates pending approval. Optional: agent_id (filter to gates whose blocked task is assigned to this agent).\n` +
+            `- "get": Inspect a specific gate + see the cascade impact of rejecting. Required: gate_id. ALWAYS call before "reject" so you understand what will fail.\n` +
+            `- "approve": Approve a gate so the blocked task can dispatch. Required: gate_id, agent_id (the calling chief/staff). Optional: comment.\n` +
+            `- "reject": Reject a gate — FAILS the blocked task and BLOCKS all transitive successors (cascade). Required: gate_id, agent_id, reason (min 5 chars).\n\n` +
+            `Why agent_id is required: plugin runtime has no implicit agent identity. The agent invoking this tool MUST pass its own id so approval audit trail records 'agent:<id>' instead of 'user:<owner_uuid>'. Falls back to gateway OFIERE_AGENT_ID env when absent.`,
+        parameters: {
+            type: "object",
+            required: ["action"],
+            properties: {
+                action: { type: "string", enum: ["list_pending", "get", "approve", "reject"], description: "list_pending | get | approve | reject" },
+                gate_id: { type: "string", description: "Gate UUID (required for get, approve, reject)" },
+                agent_id: { type: "string", description: "Calling agent id (required for approve, reject — recorded as 'agent:<id>' in approved_by / rejected_by). Also optional filter for list_pending." },
+                comment: { type: "string", description: "Optional approval comment" },
+                reason: { type: "string", description: "Rejection reason (required for reject, min 5 chars)" },
+            },
+        },
+        async execute(_id, params) {
+            try {
+                const action = params.action;
+                const resolveActor = () => {
+                    const id = params.agent_id || fallbackAgentId;
+                    return id ? `agent:${id}` : `user:${userId}`;
+                };
+                switch (action) {
+                    case "list_pending": {
+                        let q = supabase
+                            .from("pm_gates")
+                            .select("id, plan_id, plan_node_id, gate_label, task_id_blocked, created_at, tasks!inner(title, agent_id)")
+                            .eq("user_id", userId)
+                            .is("approved_at", null)
+                            .is("rejected_at", null)
+                            .order("created_at", { ascending: true });
+                        if (params.agent_id)
+                            q = q.eq("tasks.agent_id", params.agent_id);
+                        const { data, error } = await q;
+                        if (error)
+                            return err(error.message);
+                        return ok({ pending: data || [], count: (data || []).length });
+                    }
+                    case "get": {
+                        if (!params.gate_id)
+                            return err("Missing required: gate_id");
+                        const { data: gate, error } = await supabase
+                            .from("pm_gates")
+                            .select("*, tasks!inner(id, title, agent_id, status)")
+                            .eq("id", params.gate_id)
+                            .eq("user_id", userId)
+                            .maybeSingle();
+                        if (error)
+                            return err(error.message);
+                        if (!gate)
+                            return err("Gate not found");
+                        const blockedTaskId = gate.task_id_blocked;
+                        const downstream = await collectTransitiveSuccessors(supabase, userId, blockedTaskId);
+                        const blockedTitle = gate.tasks?.title || "blocked task";
+                        return ok({
+                            gate,
+                            impact_on_reject: {
+                                failed_task: { id: blockedTaskId, title: blockedTitle },
+                                blocked_downstream: downstream,
+                                summary: `Rejecting will FAIL '${blockedTitle}' and BLOCK ${downstream.length} downstream task${downstream.length === 1 ? "" : "s"}.`,
+                            },
+                        });
+                    }
+                    case "approve": {
+                        if (!params.gate_id)
+                            return err("Missing required: gate_id");
+                        if (!params.agent_id && !fallbackAgentId)
+                            return err("Missing required: agent_id (calling agent identity — plugin has no implicit agent context)");
+                        const actor = resolveActor();
+                        const { data, error } = await supabase
+                            .from("pm_gates")
+                            .update({
+                            approved_at: new Date().toISOString(),
+                            approved_by: actor,
+                            approval_comment: params.comment ?? null,
+                        })
+                            .eq("id", params.gate_id)
+                            .eq("user_id", userId)
+                            .is("approved_at", null)
+                            .is("rejected_at", null)
+                            .select("id");
+                        if (error)
+                            return err(error.message);
+                        if (!data || data.length === 0)
+                            return err("Gate not found or already resolved");
+                        return ok({ approved: true, gate_id: params.gate_id, approved_by: actor });
+                    }
+                    case "reject": {
+                        if (!params.gate_id)
+                            return err("Missing required: gate_id");
+                        if (!params.agent_id && !fallbackAgentId)
+                            return err("Missing required: agent_id (calling agent identity — plugin has no implicit agent context)");
+                        const reason = (params.reason || "").trim();
+                        if (reason.length < 5)
+                            return err("Missing required: reason (min 5 chars) — rejection requires explanation");
+                        const actor = resolveActor();
+                        const { data, error } = await supabase.rpc("cascade_reject_gate", {
+                            p_gate_id: params.gate_id,
+                            p_user_id: userId,
+                            p_reason: reason,
+                            p_actor: actor,
+                        });
+                        if (error)
+                            return err(error.message);
+                        return ok({ rejected: true, gate_id: params.gate_id, rejected_by: actor, result: data });
+                    }
+                    default:
+                        return err(`Unknown gate action: ${action}`);
+                }
+            }
+            catch (e) {
+                return err(e instanceof Error ? e.message : String(e));
+            }
+        },
+    });
+}

package/dist/src/planExecute.js

@@ -0,0 +1,145 @@
+// MIRROR — sync manually with dashboard/lib/pm/planExecute.ts
+// Plugin is a separate npm package and cannot import from dashboard/.
+// If you edit either file, update both. Helper algorithm must stay byte-identical
+// across runtimes so pm_dependencies + pm_gates rows have the same shape regardless
+// of whether the plan was executed via dashboard / native ofiere_plan_ops / plugin OFIERE_PLAN_OPS.
+/**
+ * Walk plan tree → emit concrete predecessor edges + manual-gate rows.
+ *
+ * Predecessor resolution (per task/milestone node, walking UP from succ):
+ *   - Root + idx=0                            → no predecessor
+ *   - Root + idx>0                            → leaves of rootSibling[idx-1]
+ *   - Parent.parallel = true + parent is task → predecessor = parent
+ *   - Parent.parallel = true + parent is gate → recurse upward through gate
+ *   - Non-parallel parent + idx>0             → leaves of parent.children[idx-1]
+ *   - Non-parallel parent + idx=0             → parent (recurse if gate)
+ *
+ * Group-id rule: if any gate on the traversal path has
+ * `gateCondition='any_predecessor_complete'`, all resolved sources for this
+ * successor share one UUID-flavored group_id (dispatcher treats as OR-join).
+ *
+ * Manual-gate emission: for each task/milestone, walk UP through `parentOf`
+ * chain and emit one pm_gates row for every `manual` gate ancestor. Nested
+ * manual gates produce N rows; dispatcher AND-joins them.
+ */
+export function expandPlanToDependencyEdges(rootNodes, idMap) {
+    const edges = [];
+    const gates = [];
+    const emptyGates = [];
+    const seenEdgeKey = new Set();
+    const seenGateKey = new Set();
+    const parentOf = new Map();
+    const indexInParent = new Map();
+    const allNodes = [];
+    function indexTree(nodes, parent) {
+        nodes.forEach((n, i) => {
+            parentOf.set(n.id, parent);
+            indexInParent.set(n.id, i);
+            allNodes.push(n);
+            if (Array.isArray(n.children) && n.children.length > 0)
+                indexTree(n.children, n);
+        });
+    }
+    indexTree(rootNodes, null);
+    // Resolve a node (possibly a gate) to its task-leaf set, tracking gates traversed.
+    function leavesOf(n, gatesAbove) {
+        if (n.type === 'task' || n.type === 'milestone') {
+            const tid = idMap.get(n.id);
+            return tid ? [{ taskId: tid, gateChain: gatesAbove }] : [];
+        }
+        if (n.type === 'gate') {
+            const nextGates = [...gatesAbove, n];
+            const out = [];
+            for (const c of (n.children || []))
+                out.push(...leavesOf(c, nextGates));
+            if (out.length === 0)
+                emptyGates.push(n.id);
+            return out;
+        }
+        return [];
+    }
+    // Walk UP from succ to find predecessor leaves + whether any gate on the path is OR-join.
+    function predecessorsFor(succ) {
+        let orJoin = false;
+        let cursor = succ;
+        while (cursor) {
+            const parent = parentOf.get(cursor.id) ?? null;
+            const idx = indexInParent.get(cursor.id) ?? 0;
+            if (!parent) {
+                // root-level sibling chain
+                if (idx === 0)
+                    return { sources: [], orJoin };
+                return { sources: leavesOf(rootNodes[idx - 1], []), orJoin };
+            }
+            // OR-detection happens whenever we traverse into a gate ancestor
+            if (parent.type === 'gate' && parent.gateCondition === 'any_predecessor_complete') {
+                orJoin = true;
+            }
+            if (parent.parallel) {
+                // parallel fan-out: predecessor IS the parent
+                if (parent.type === 'gate') {
+                    cursor = parent;
+                    continue;
+                }
+                const pid = idMap.get(parent.id);
+                return pid ? { sources: [{ taskId: pid, gateChain: [] }], orJoin } : { sources: [], orJoin };
+            }
+            if (idx > 0) {
+                // non-parallel: pred is the previous sibling (may itself be a gate)
+                return { sources: leavesOf(parent.children[idx - 1], []), orJoin };
+            }
+            // first child of non-parallel parent → pred is the parent (recurse if gate)
+            if (parent.type === 'gate') {
+                cursor = parent;
+                continue;
+            }
+            const pid = idMap.get(parent.id);
+            return pid ? { sources: [{ taskId: pid, gateChain: [] }], orJoin } : { sources: [], orJoin };
+        }
+        return { sources: [], orJoin };
+    }
+    for (const node of allNodes) {
+        if (node.type !== 'task' && node.type !== 'milestone')
+            continue;
+        const succTaskId = idMap.get(node.id);
+        if (!succTaskId)
+            continue;
+        const { sources, orJoin: orJoinFromWalk } = predecessorsFor(node);
+        // OR-join also fires if the resolved leaves passed THROUGH an OR gate on their way up
+        // (e.g., succ is a root-sibling downstream of an OR gate — leavesOf walks INTO the gate).
+        const orJoinFromLeaves = sources.some(s => s.gateChain.some(g => g.type === 'gate' && g.gateCondition === 'any_predecessor_complete'));
+        const orJoin = orJoinFromWalk || orJoinFromLeaves;
+        const groupId = (orJoin && sources.length > 1) ? `grp-${succTaskId}-${node.id.slice(-6)}` : null;
+        for (const s of sources) {
+            const key = `${s.taskId}->${succTaskId}|${groupId ?? ''}`;
+            if (seenEdgeKey.has(key))
+                continue;
+            seenEdgeKey.add(key);
+            edges.push({
+                predTaskId: s.taskId,
+                succTaskId,
+                groupId,
+                lagDays: 0,
+                dependencyType: 'finish_to_start',
+            });
+        }
+        // Manual-gate rows: walk UP through every ancestor gate; emit one row per manual gate.
+        let cur = parentOf.get(node.id) || null;
+        while (cur) {
+            if (cur.type === 'gate' && cur.gateCondition === 'manual') {
+                const k = `${cur.id}::${succTaskId}`;
+                if (!seenGateKey.has(k)) {
+                    seenGateKey.add(k);
+                    gates.push({
+                        planNodeId: cur.id,
+                        gateLabel: cur.title || 'Manual gate',
+                        gateCondition: 'manual',
+                        taskIdBlocked: succTaskId,
+                    });
+                }
+            }
+            cur = parentOf.get(cur.id) || null;
+        }
+    }
+    return { edges, gates, emptyGates };
+}

package/dist/src/staffPersona.js

@@ -36,7 +36,7 @@ export async function loadDispatchContextBySession(supabase, userId, sessionKey)
         return null;
     const { data, error } = await supabase
         .from("dispatch_context")
-        .select("subagent_id, attached_sop_ids, attached_framework_ids, task_id, conversation_id")
+        .select("subagent_id, attached_sop_ids, attached_framework_ids, task_id, conversation_id, source_agent_id, a2a_pair_id")
         .eq("user_id", userId)
         .eq("session_key", sessionKey)
         .order("created_at", { ascending: false })
@@ -54,6 +54,8 @@ export async function loadDispatchContextBySession(supabase, userId, sessionKey)
             : [],
         task_id: data.task_id ?? null,
         conversation_id: data.conversation_id ?? null,
+        source_agent_id: data.source_agent_id ?? null,
+        a2a_pair_id: data.a2a_pair_id ?? null,
     };
 }
 const SLOTS = [

package/dist/src/tools.js

@@ -16,6 +16,8 @@ import { resolveAgentId } from "./agent-resolver.js";
 import { handleProposeAttach, handleCommitAttach, registerAttachmentContextHook, } from "./attachments.js";
 import { invalidateAgentTier } from "./agent-tier.js";
 import { loadSubagentRow, readDispatchSubagentId, loadDispatchContextBySession } from "./staffPersona.js";
+import { expandPlanToDependencyEdges } from "./planExecute.js";
+import { registerGateOps } from "./gateOps.js";
 function ok(data) {
     return {
         content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
@@ -4867,7 +4869,7 @@ async function handleExecutePlan(supabase, userId, resolveAgent, params) {
         let tasksCreated = 0;
         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;
@@ -4928,76 +4930,45 @@ async function handleExecutePlan(supabase, userId, resolveAgent, params) {
                 }
             }
         }
-        // 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, idMap);
         let depsCreated = 0;
-        // Helper: resolve a node to its nearest task ID (skip gates/milestones)
-        function resolveTaskId(n) {
-            return idMap.get(n.id);
-        }
-        // Helper: insert a dependency row into pm_dependencies
-        async function insertDep(predId, succId) {
+        let gatesCreated = 0;
+        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 = [];
-                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);
-        }
-        // Chain root-level siblings (sequential root nodes)
-        const rootTaskIds = [];
-        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]))
+            if (!error)
                 depsCreated++;
         }
+        for (const g of gateRows) {
+            const { error } = await supabase.from("pm_gates").insert({
+                user_id: userId,
+                plan_id: params.plan_id,
+                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
         await supabase.from("pm_plans").update({ is_deployed: true, deployed_at: new Date().toISOString(), updated_at: new Date().toISOString() }).eq("id", params.plan_id).eq("user_id", userId);
         return ok({
             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" } : {}),
@@ -6927,6 +6898,7 @@ supabase, config) {
     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);
     // ── Register talent context hook ──
@@ -6936,7 +6908,7 @@ supabase, config) {
     // ── Register agent_end hook for server-side brain extraction ──
     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})`);
@@ -7214,6 +7186,117 @@ function registerBrainExtractionHook(api, supabase, userId, fallbackAgentId) {
                     // not the chief's. The chief gets a single L4 report entry above.
                     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 = null;
+                            try {
+                                const { data: agentRow } = await supabase
+                                    .from("agents")
+                                    .select("name")
+                                    .eq("id", resolvedAgentId)
+                                    .eq("user_id", userId)
+                                    .maybeSingle();
+                                responderName = agentRow?.name ?? 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.

package/package.json

@@ -1,15 +1,24 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.54.2",
+  "version": "4.56.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM - 17 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, agent brain, talent management, corporate frameworks, and agent office canvas",
-  "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
+  "description": "OpenClaw plugin for Ofiere PM - 18 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, agent brain, talent management, corporate frameworks, agent office canvas, and PM gate approvals",
+  "keywords": [
+    "openclaw",
+    "ofiere",
+    "project-management",
+    "agents",
+    "plugin"
+  ],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {
     "type": "git",
     "url": "https://github.com/gilanggemar/Ofiere.git"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
   "main": "./dist/index.js",
   "files": [
     "index.ts",
@@ -45,6 +54,7 @@
     "zod": "^3.25.11"
   },
   "devDependencies": {
+    "@types/node": "^25.8.0",
     "typescript": "^5.6.0"
   }
 }