@jiggai/recipes 0.4.19 → 0.4.21

package/src/lib/workflows/workflow-queue.ts

@@ -43,6 +43,30 @@ function claimPathFor(teamDir: string, agentId: string, taskId: string) {
   return path.join(claimsDir(teamDir), `${agentId}.${taskId}.json`);
 }
 
+async function loadClaim(teamDir: string, agentId: string, taskId: string) {
+  const p = claimPathFor(teamDir, agentId, taskId);
+  try {
+    const raw = await fs.readFile(p, 'utf8');
+    return JSON.parse(raw) as { workerId?: string; claimedAt?: string; leaseSeconds?: number };
+  } catch {
+    return null;
+  }
+}
+
+function isExpiredClaim(claim: { claimedAt?: string; leaseSeconds?: number } | null | undefined, fallbackLeaseSeconds?: number) {
+  if (!claim) return false;
+  const effectiveLease = typeof claim.leaseSeconds === 'number' ? claim.leaseSeconds : fallbackLeaseSeconds;
+  const claimedAtMs = claim.claimedAt ? Date.parse(String(claim.claimedAt)) : NaN;
+  return typeof effectiveLease === 'number' && Number.isFinite(claimedAtMs) && Date.now() - claimedAtMs > effectiveLease * 1000;
+}
+
+export async function releaseTaskClaim(teamDir: string, agentId: string, taskId: string) {
+  try {
+    await fs.unlink(claimPathFor(teamDir, agentId, taskId));
+  } catch {
+    // ignore missing claims
+  }
+}
 
 export function queuePathFor(teamDir: string, agentId: string) {
   return path.join(queueDir(teamDir), `${agentId}.jsonl`);
@@ -150,109 +174,116 @@ export async function dequeueNextTask(
   }
 
   const st = await loadState(teamDir, agentId);
+  const workerId = String(opts?.workerId ?? `worker:${process.pid}`);
+  const leaseSeconds = typeof opts?.leaseSeconds === 'number' ? opts.leaseSeconds : undefined;
+
+  async function tryClaimTask(t: QueueTask, startOffsetBytes: number, endOffsetBytes: number, advanceState: boolean) {
+    await ensureDir(claimsDir(teamDir));
+    const claimPath = claimPathFor(teamDir, agentId, t.id);
+
+    async function writeClaim(overwrite: boolean) {
+      const claim = {
+        taskId: t.id,
+        agentId,
+        workerId,
+        claimedAt: new Date().toISOString(),
+        leaseSeconds,
+      };
+      await fs.writeFile(claimPath, JSON.stringify(claim, null, 2), { encoding: 'utf8', flag: overwrite ? 'w' : 'wx' });
+    }
+
+    try {
+      await writeClaim(false);
+    } catch {
+      const existing = await loadClaim(teamDir, agentId, t.id);
+      if (String(existing?.workerId ?? '') !== workerId) {
+        if (!isExpiredClaim(existing, leaseSeconds)) {
+          if (advanceState) {
+            await writeState(teamDir, agentId, { offsetBytes: endOffsetBytes, updatedAt: new Date().toISOString() });
+          }
+          return null;
+        }
+        await writeClaim(true);
+      }
+    }
+
+    if (advanceState) {
+      await writeState(teamDir, agentId, { offsetBytes: endOffsetBytes, updatedAt: new Date().toISOString() });
+    }
+    return {
+      ok: true as const,
+      task: { task: t, startOffsetBytes, endOffsetBytes },
+    };
+  }
+
   const fh = await fs.open(qPath, 'r');
   try {
     const stat = await fh.stat();
-    if (st.offsetBytes >= stat.size) {
-      return { ok: true as const, task: null as DequeuedTask | null, message: 'No new tasks.' };
-    }
+    if (st.offsetBytes < stat.size) {
+      const toRead = Math.min(stat.size - st.offsetBytes, 256 * 1024);
+      const buf = Buffer.alloc(toRead);
+      const { bytesRead } = await fh.read(buf, 0, toRead, st.offsetBytes);
+      const chunk = buf.subarray(0, bytesRead).toString('utf8');
+
+      const lines = chunk.split('\n');
+      const fullLines = lines.slice(0, -1);
+      let cursor = st.offsetBytes;
+
+      for (const line of fullLines) {
+        const lineBytes = Buffer.byteLength(line + '\n');
+        const startOffsetBytes = cursor;
+        const endOffsetBytes = cursor + lineBytes;
+        cursor = endOffsetBytes;
+
+        if (!line.trim()) {
+          await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
+          continue;
+        }
 
-    const toRead = Math.min(stat.size - st.offsetBytes, 256 * 1024);
-    const buf = Buffer.alloc(toRead);
-    const { bytesRead } = await fh.read(buf, 0, toRead, st.offsetBytes);
-    const chunk = buf.subarray(0, bytesRead).toString('utf8');
+        let t: QueueTask | null = null;
+        try {
+          t = JSON.parse(line) as QueueTask;
+        } catch {
+          await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
+          continue;
+        }
 
-    const lines = chunk.split('\n');
-    const fullLines = lines.slice(0, -1);
-    let cursor = st.offsetBytes;
+        if (!t || !t.id || !t.runId || !t.nodeId) {
+          await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
+          continue;
+        }
 
-    for (const line of fullLines) {
+        const claimed = await tryClaimTask(t, startOffsetBytes, endOffsetBytes, true);
+        if (claimed) return claimed;
+      }
+    }
+
+    // Recovery scan: if the cursor has already advanced, revisit older tasks that still have
+    // a live claim file and whose lease has expired. This prevents claimed-then-crashed workers
+    // from permanently orphaning tasks behind offsetBytes.
+    const fullRaw = await fs.readFile(qPath, 'utf8');
+    let cursor = 0;
+    for (const line of fullRaw.split('\n')) {
       const lineBytes = Buffer.byteLength(line + '\n');
       const startOffsetBytes = cursor;
       const endOffsetBytes = cursor + lineBytes;
       cursor = endOffsetBytes;
-
-      if (!line.trim()) {
-        await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
-        continue;
-      }
-
+      if (!line.trim()) continue;
       let t: QueueTask | null = null;
       try {
         t = JSON.parse(line) as QueueTask;
       } catch {
-        // Malformed: skip it so we don't get stuck.
-        await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
         continue;
       }
-
-      if (!t || !t.id || !t.runId || !t.nodeId) {
-        await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
-        continue;
-      }
-
-      await ensureDir(claimsDir(teamDir));
-      const claimPath = claimPathFor(teamDir, agentId, t.id);
-
-      // Claim behavior:
-      // - If unclaimed: create claim file.
-      // - If already claimed by *this* workerId: allow re-processing (idempotent recovery).
-      // - If claimed by another workerId:
-      //    - if lease is expired: allow this worker to steal the claim
-      //    - otherwise: skip
-      const workerId = String(opts?.workerId ?? `worker:${process.pid}`);
-      const leaseSeconds = typeof opts?.leaseSeconds === 'number' ? opts.leaseSeconds : undefined;
-      const now = Date.now();
-
-      async function writeClaim(overwrite: boolean) {
-        const claim = {
-          taskId: t!.id,
-          agentId,
-          workerId,
-          claimedAt: new Date().toISOString(),
-          leaseSeconds,
-        };
-        await fs.writeFile(claimPath, JSON.stringify(claim, null, 2), { encoding: 'utf8', flag: overwrite ? 'w' : 'wx' });
-      }
-
-      try {
-        await writeClaim(false);
-      } catch {
-        try {
-          const raw = await fs.readFile(claimPath, 'utf8');
-          const existing = JSON.parse(raw) as { workerId?: string; claimedAt?: string; leaseSeconds?: number };
-
-          // Same worker: allow idempotent re-processing.
-          if (String(existing?.workerId ?? '') === workerId) {
-            // proceed
-          } else {
-            const existingLease = typeof existing?.leaseSeconds === 'number' ? existing.leaseSeconds : undefined;
-            const effectiveLease = typeof leaseSeconds === 'number' ? leaseSeconds : existingLease;
-            const claimedAtMs = existing?.claimedAt ? Date.parse(String(existing.claimedAt)) : NaN;
-            const expired = typeof effectiveLease === 'number' && Number.isFinite(claimedAtMs) && now - claimedAtMs > effectiveLease * 1000;
-
-            if (!expired) {
-              await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
-              continue;
-            }
-
-            // Lease expired: steal.
-            await writeClaim(true);
-          }
-        } catch {
-          await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
-          continue;
-        }
-      }
-
-      await writeState(teamDir, agentId, { offsetBytes: cursor, updatedAt: new Date().toISOString() });
-      return {
-        ok: true as const,
-        task: { task: t, startOffsetBytes, endOffsetBytes },
-      };
+      if (!t || !t.id || !t.runId || !t.nodeId) continue;
+      const existing = await loadClaim(teamDir, agentId, t.id);
+      if (!existing) continue;
+      if (String(existing.workerId ?? '') !== workerId && !isExpiredClaim(existing, leaseSeconds)) continue;
+      const claimed = await tryClaimTask(t, startOffsetBytes, endOffsetBytes, false);
+      if (claimed) return claimed;
     }
 
-    return { ok: true as const, task: null as DequeuedTask | null, message: 'No full line available yet.' };
+    return { ok: true as const, task: null as DequeuedTask | null, message: 'No new or recoverable tasks.' };
   } finally {
     await fh.close();
   }

package/src/lib/workflows/workflow-runner.ts

@@ -2,12 +2,12 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
-import { resolveWorkspaceRoot } from '../workspace';
+import { resolveTeamDir } from '../workspace';
 import type { ToolTextResult } from '../../toolsInvoke';
 import { toolsInvoke } from '../../toolsInvoke';
 import { loadOpenClawConfig } from '../recipes-config';
 import type { Workflow, WorkflowEdge, WorkflowLane, WorkflowNode } from './workflow-types';
-import { dequeueNextTask, enqueueTask } from './workflow-queue';
+import { dequeueNextTask, enqueueTask, releaseTaskClaim } from './workflow-queue';
 import { outboundPublish, type OutboundApproval, type OutboundMedia, type OutboundPlatform } from './outbound-client';
 import { sanitizeOutboundPostText } from './outbound-sanitize';
 import { loadPriorLlmInput, loadProposedPostTextFromPriorNode } from './workflow-node-output-readers';
@@ -870,8 +870,7 @@ export async function enqueueWorkflowRun(api: OpenClawPluginApi, opts: {
   trigger?: { kind: string; at?: string };
 }) {
   const teamId = String(opts.teamId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const sharedContextDir = path.join(teamDir, 'shared-context');
   const workflowsDir = path.join(sharedContextDir, 'workflows');
   const runsDir = path.join(sharedContextDir, 'workflow-runs');
@@ -968,8 +967,7 @@ export async function runWorkflowRunnerOnce(api: OpenClawPluginApi, opts: {
   leaseSeconds?: number;
 }) {
   const teamId = String(opts.teamId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const sharedContextDir = path.join(teamDir, 'shared-context');
   const runsDir = path.join(sharedContextDir, 'workflow-runs');
   const workflowsDir = path.join(sharedContextDir, 'workflows');
@@ -1121,8 +1119,7 @@ export async function runWorkflowRunnerTick(api: OpenClawPluginApi, opts: {
   leaseSeconds?: number;
 }) {
   const teamId = String(opts.teamId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const sharedContextDir = path.join(teamDir, 'shared-context');
   const runsDir = path.join(sharedContextDir, 'workflow-runs');
   const workflowsDir = path.join(sharedContextDir, 'workflows');
@@ -1304,8 +1301,7 @@ export async function runWorkflowOnce(api: OpenClawPluginApi, opts: {
   trigger?: { kind: string; at?: string };
 }) {
   const teamId = String(opts.teamId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const sharedContextDir = path.join(teamDir, 'shared-context');
   const workflowsDir = path.join(sharedContextDir, 'workflows');
   const runsDir = path.join(sharedContextDir, 'workflow-runs');
@@ -1422,8 +1418,7 @@ export async function pollWorkflowApprovals(api: OpenClawPluginApi, opts: {
   limit?: number;
 }) {
   const teamId = String(opts.teamId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const runsDir = path.join(teamDir, 'shared-context', 'workflow-runs');
 
   if (!(await fileExists(runsDir))) {
@@ -1501,8 +1496,7 @@ export async function approveWorkflowRun(api: OpenClawPluginApi, opts: {
 }) {
   const teamId = String(opts.teamId);
   const runId = String(opts.runId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
 
   const approvalPath = await approvalsPathFor(teamDir, runId);
   if (!(await fileExists(approvalPath))) {
@@ -1527,8 +1521,7 @@ export async function resumeWorkflowRun(api: OpenClawPluginApi, opts: {
 }) {
   const teamId = String(opts.teamId);
   const runId = String(opts.runId);
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const sharedContextDir = path.join(teamDir, 'shared-context');
   const runsDir = path.join(sharedContextDir, 'workflow-runs');
   const workflowsDir = path.join(sharedContextDir, 'workflows');
@@ -1559,10 +1552,9 @@ export async function resumeWorkflowRun(api: OpenClawPluginApi, opts: {
 
   const ticketPath = path.join(teamDir, runLog.ticket.file);
 
-  // Find the approval node index; resume after it.
+  // Find the approval node index.
   const approvalIdx = workflow.nodes.findIndex((n) => n.kind === 'human_approval' && String(n.id) === String(approval.nodeId));
   if (approvalIdx < 0) throw new Error(`Approval node not found in workflow: nodeId=${approval.nodeId}`);
-  const startNodeIndex = approvalIdx + 1;
 
   if (approval.status === 'rejected') {
     // Denial flow: mark run as needs_revision and loop back to the draft step (or closest prior llm node).
@@ -1571,9 +1563,6 @@ export async function resumeWorkflowRun(api: OpenClawPluginApi, opts: {
     const approvalNote = String(approval.note ?? '').trim();
 
     // Find a reasonable "revise" node: prefer a node with id=draft_assets, else the closest prior llm node.
-    const approvalIdx = workflow.nodes.findIndex((n) => n.kind === 'human_approval' && String(n.id) === String(approval.nodeId));
-    if (approvalIdx < 0) throw new Error(`Approval node not found in workflow: nodeId=${approval.nodeId}`);
-
     let reviseIdx = workflow.nodes.findIndex((n, idx) => idx < approvalIdx && String(n.id) === 'draft_assets');
     if (reviseIdx < 0) {
       for (let i = approvalIdx - 1; i >= 0; i--) {
@@ -1667,9 +1656,28 @@ export async function resumeWorkflowRun(api: OpenClawPluginApi, opts: {
       : [...cur.events, { ts: approvedTs, type: 'node.approved', nodeId: approval.nodeId }],
   }));
 
-  // Pull-based execution: enqueue the next node and return.
-  const idx0 = Math.max(0, Number(startNodeIndex ?? 0));
-  if (idx0 >= (workflow.nodes?.length ?? 0)) {
+  // Pull-based execution: enqueue the next runnable node and return.
+  let updated = (await loadRunFile(teamDir, runsDir, runId)).run;
+  let enqueueIdx = pickNextRunnableNodeIndex({ workflow, run: updated });
+
+  // Auto-complete start/end nodes.
+  while (enqueueIdx !== null) {
+    const n = workflow.nodes[enqueueIdx]!;
+    const k = String(n.kind ?? '');
+    if (k !== 'start' && k !== 'end') break;
+    const ts = new Date().toISOString();
+    await appendRunLog(runLogPath, (cur) => ({
+      ...cur,
+      nextNodeIndex: enqueueIdx! + 1,
+      nodeStates: { ...(cur.nodeStates ?? {}), [n.id]: { status: 'success', ts } },
+      events: [...cur.events, { ts, type: 'node.completed', nodeId: n.id, kind: k, noop: true }],
+      nodeResults: [...(cur.nodeResults ?? []), { nodeId: n.id, kind: k, noop: true }],
+    }));
+    updated = (await loadRunFile(teamDir, runsDir, runId)).run;
+    enqueueIdx = pickNextRunnableNodeIndex({ workflow, run: updated });
+  }
+
+  if (enqueueIdx === null) {
     await writeRunFile(runLogPath, (cur) => ({
       ...cur,
       updatedAt: new Date().toISOString(),
@@ -1679,9 +1687,10 @@ export async function resumeWorkflowRun(api: OpenClawPluginApi, opts: {
     return { ok: true as const, runId, status: 'completed' as const, ticketPath, runLogPath };
   }
 
-  const node = workflow.nodes[idx0]!;
+  const node = workflow.nodes[enqueueIdx]!;
+  const nextKind = String(node.kind ?? '');
   const nextAgentId = String(node?.assignedTo?.agentId ?? '').trim();
-  if (!nextAgentId) throw new Error(`Node ${node.id} missing assignedTo.agentId (required for pull-based execution)`);
+  if (!nextAgentId) throw new Error(`Next runnable node ${node.id} (${nextKind}) missing assignedTo.agentId (required for pull-based execution)`);
 
   await enqueueTask(teamDir, nextAgentId, {
     teamId,
@@ -1694,7 +1703,7 @@ export async function resumeWorkflowRun(api: OpenClawPluginApi, opts: {
     ...cur,
     updatedAt: new Date().toISOString(),
     status: 'waiting_workers',
-    nextNodeIndex: idx0,
+    nextNodeIndex: enqueueIdx,
     events: [...cur.events, { ts: new Date().toISOString(), type: 'node.enqueued', nodeId: node.id, agentId: nextAgentId }],
   }));
 
@@ -1712,8 +1721,7 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
   if (!teamId) throw new Error('--team-id is required');
   if (!agentId) throw new Error('--agent-id is required');
 
-  const workspaceRoot = resolveWorkspaceRoot(api);
-  const teamDir = path.resolve(workspaceRoot, '..', `workspace-${teamId}`);
+  const teamDir = resolveTeamDir(api, teamId);
   const sharedContextDir = path.join(teamDir, 'shared-context');
   const workflowsDir = path.join(sharedContextDir, 'workflows');
   const runsDir = path.join(sharedContextDir, 'workflow-runs');
@@ -1728,56 +1736,60 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
     if (!dq.ok || !dq.task) break;
 
     const { task } = dq.task;
-    if (task.kind !== 'execute_node') continue;
-
     const runPath = runFilePathFor(runsDir, task.runId);
     const runDir = path.dirname(runPath);
     const lockDir = path.join(runDir, 'locks');
-    await ensureDir(lockDir);
-
-    // Node-level lock to prevent double execution.
     const lockPath = path.join(lockDir, `${task.nodeId}.lock`);
+    let lockHeld = false;
+
     try {
-      await fs.writeFile(lockPath, JSON.stringify({ workerId, taskId: task.id, claimedAt: new Date().toISOString() }, null, 2), { encoding: 'utf8', flag: 'wx' });
-    } catch {
-      // Lock exists. Treat it as contention unless it looks stale.
-      // (If a worker crashed, the lock file can stick around and block retries/revisions forever.)
-      let unlocked = false;
+      if (task.kind !== 'execute_node') continue;
+
+      await ensureDir(lockDir);
+
+      // Node-level lock to prevent double execution.
       try {
-        const raw = await readTextFile(lockPath);
-        const parsed = JSON.parse(raw) as { claimedAt?: string };
-        const claimedAtMs = parsed?.claimedAt ? Date.parse(String(parsed.claimedAt)) : NaN;
-        const ageMs = Number.isFinite(claimedAtMs) ? Date.now() - claimedAtMs : NaN;
-        const stale = Number.isFinite(ageMs) && ageMs > 10 * 60 * 1000;
-        if (stale) {
-          await fs.unlink(lockPath);
-          unlocked = true;
-        }
+        await fs.writeFile(lockPath, JSON.stringify({ workerId, taskId: task.id, claimedAt: new Date().toISOString() }, null, 2), { encoding: 'utf8', flag: 'wx' });
+        lockHeld = true;
       } catch {
-        // ignore
-      }
-
-      if (unlocked) {
+        // Lock exists. Treat it as contention unless it looks stale.
+        // (If a worker crashed, the lock file can stick around and block retries/revisions forever.)
+        let unlocked = false;
         try {
-          await fs.writeFile(lockPath, JSON.stringify({ workerId, taskId: task.id, claimedAt: new Date().toISOString() }, null, 2), { encoding: 'utf8', flag: 'wx' });
+          const raw = await readTextFile(lockPath);
+          const parsed = JSON.parse(raw) as { claimedAt?: string };
+          const claimedAtMs = parsed?.claimedAt ? Date.parse(String(parsed.claimedAt)) : NaN;
+          const ageMs = Number.isFinite(claimedAtMs) ? Date.now() - claimedAtMs : NaN;
+          const stale = Number.isFinite(ageMs) && ageMs > 10 * 60 * 1000;
+          if (stale) {
+            await fs.unlink(lockPath);
+            unlocked = true;
+          }
         } catch {
+          // ignore
+        }
+
+        if (unlocked) {
+          try {
+            await fs.writeFile(lockPath, JSON.stringify({ workerId, taskId: task.id, claimedAt: new Date().toISOString() }, null, 2), { encoding: 'utf8', flag: 'wx' });
+            lockHeld = true;
+          } catch {
+            results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_locked' });
+            continue;
+          }
+        } else {
+          // Requeue to avoid task loss since dequeueNextTask already advanced the queue cursor.
+          await enqueueTask(teamDir, agentId, {
+            teamId,
+            runId: task.runId,
+            nodeId: task.nodeId,
+            kind: 'execute_node',
+          });
           results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_locked' });
           continue;
         }
-      } else {
-        // Requeue to avoid task loss since dequeueNextTask already advanced the queue cursor.
-        await enqueueTask(teamDir, agentId, {
-          teamId,
-          runId: task.runId,
-          nodeId: task.nodeId,
-          kind: 'execute_node',
-        });
-        results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_locked' });
-        continue;
       }
-    }
 
-    try {
       const runId = task.runId;
 
       const { run } = await loadRunFile(teamDir, runsDir, runId);
@@ -1790,6 +1802,25 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
     if (nodeIdx < 0) throw new Error(`Node not found in workflow: ${task.nodeId}`);
     const node = workflow.nodes[nodeIdx]!;
 
+    // Stale-task guard: expired claim recovery can surface older queue entries from behind the
+    // cursor. Before executing a dequeued task, verify that this node is still actually runnable
+    // for the current run state. Otherwise we can resurrect pre-approval work and overwrite
+    // canonical node outputs for runs that already advanced.
+    const currentRun = (await loadRunFile(teamDir, runsDir, task.runId)).run;
+    const currentNodeStates = loadNodeStatesFromRun(currentRun);
+    const currentStatus = currentNodeStates[String(node.id)]?.status;
+    const currentlyRunnableIdx = pickNextRunnableNodeIndex({ workflow, run: currentRun });
+    if (
+      currentStatus === 'success' ||
+      currentStatus === 'error' ||
+      currentStatus === 'waiting' ||
+      currentlyRunnableIdx === null ||
+      String(workflow.nodes[currentlyRunnableIdx]?.id ?? '') !== String(node.id)
+    ) {
+      results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_stale' });
+      continue;
+    }
+
     // Determine current lane + ticket path.
     const laneRaw = String(run.ticket.lane);
     assertLane(laneRaw);
@@ -2069,62 +2100,11 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
 
 
         } else if (toolName === 'marketing.post_all') {
-          // Local-only controller patch for RJ: re-enable X posting via xurl. Supports args.dryRun=true.
-          const { execFile } = await import('node:child_process');
-          const { promisify } = await import('node:util');
-          const execFileP = promisify(execFile);
-
-          const platforms = Array.isArray((toolArgs as Record<string, unknown>)?.['platforms'])
-            ? (((toolArgs as Record<string, unknown>)['platforms'] as unknown[]) ?? []).map(String)
-            : ['x'];
-          if (!platforms.includes('x')) {
-            throw new Error('marketing.post_all currently supports X-only on this controller.');
-          }
-
-          const nodeOutputsDir = path.join(runDir, 'node-outputs');
-          const draftsFromNode = String((toolArgs as Record<string, unknown>)?.['draftsFromNode'] ?? '').trim() || 'qc_brand';
-          let text = await loadProposedPostTextFromPriorNode({ runDir, nodeOutputsDir, priorNodeId: draftsFromNode });
-          if (!text?.trim()) throw new Error('marketing.post_all: missing draft text');
-
-          const dryRun = Boolean((toolArgs as Record<string, unknown>)?.['dryRun']);
-
-          // Never publish internal draft/instruction/disclaimer copy.
-          text = text
-            .split(/\r?\n/)
-            .filter((line) => !/draft\s*only/i.test(line))
-            .filter((line) => !/do\s+not\s+post\s+without\s+approval/i.test(line))
-            .filter((line) => !/clawrecipes\s+before\s+openclaw/i.test(line))
-            .filter((line) => !/nothing\s+posts\s+without\s+approval/i.test(line))
-            .join('\n')
-            .trim();
-
-          if (dryRun) {
-            const logRel = path.join('shared-context', 'marketing', 'POST_LOG.md');
-            const logAbs = path.join(teamDir, logRel);
-            await ensureDir(path.dirname(logAbs));
-            await fs.appendFile(
-              logAbs,
-              `- ${new Date().toISOString()} [DRY_RUN] run=${runId} node=${node.id} tool=${toolName} platforms=x\n  - text: ${JSON.stringify(text)}\n`,
-              'utf8',
-            );
-
-            const result = { dryRun: true, platformsWouldPost: ['x'], draftText: text, logPath: logRel };
-            await fs.writeFile(artifactPath, JSON.stringify({ ok: true, tool: toolName, args: toolArgs, result }, null, 2) + '\n', 'utf8');
-          } else {
-            const who = await execFileP('xurl', ['whoami'], { timeout: 60_000, env: { ...process.env, NO_COLOR: '1' } });
-            const whoJson = JSON.parse(String((who as { stdout?: string }).stdout ?? ''));
-            const username = String((whoJson as { data?: { username?: string } })?.data?.username ?? '').trim();
-            if (!username) throw new Error('marketing.post_all: could not resolve X username');
-
-            const postRes = await execFileP('xurl', ['post', text], { timeout: 60_000, env: { ...process.env, NO_COLOR: '1' } });
-            const postJson = JSON.parse(String((postRes as { stdout?: string }).stdout ?? ''));
-            const postId = String((postJson as { data?: { id?: string } })?.data?.id ?? '').trim();
-            if (!postId) throw new Error('marketing.post_all: xurl post did not return an id');
-
-            const url = `https://x.com/${username}/status/${postId}`;
-            const result = { platformsPosted: ['x'], x: { postId, url, username } };
-            await fs.writeFile(artifactPath, JSON.stringify({ ok: true, tool: toolName, args: toolArgs, result }, null, 2) + '\n', 'utf8');
-          }
+          // Disabled by default: do not ship plugins that spawn local processes for posting.
+          // Use an approval-gated workflow node that calls a dedicated posting tool/plugin instead.
+          throw new Error(
+            'marketing.post_all is disabled in this build (install safety). Use an external posting tool/plugin (approval-gated) instead.'
+          );
         } else {
           const toolRes = await toolsInvoke<unknown>(api, {
             tool: toolName,
@@ -2257,10 +2237,17 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
       events: [...cur.events, { ts: new Date().toISOString(), type: 'node.enqueued', nodeId: nextNode.id, agentId: nextAgentId }],
     }));
 
-    results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'ok' });
+      results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'ok' });
     } finally {
+      if (lockHeld) {
+        try {
+          await fs.unlink(lockPath);
+        } catch {
+          // ignore
+        }
+      }
       try {
-        await fs.unlink(lockPath);
+        await releaseTaskClaim(teamDir, agentId, task.id);
       } catch {
         // ignore
       }

package/src/lib/workspace.ts

@@ -22,6 +22,26 @@ export function resolveWorkspaceRoot(api: OpenClawPluginApi): string {
   return path.join(os.homedir(), ".openclaw", "workspace");
 }
 
+/**
+ * Resolve the canonical OpenClaw workspace root even when the current agent workspace
+ * is nested under `workspace-<teamId>/roles/<role>`.
+ */
+export function resolveCanonicalWorkspaceRoot(api: OpenClawPluginApi): string {
+  const candidate = api.config.agents?.defaults?.workspace;
+  if (candidate) {
+    const abs = path.resolve(candidate);
+    const parts = abs.split(path.sep).filter(Boolean);
+    const idx = [...parts].reverse().findIndex((p) => p.startsWith('workspace-'));
+    if (idx >= 0) {
+      const segIdx = parts.length - 1 - idx;
+      const teamDir = path.isAbsolute(abs) ? path.sep + path.join(...parts.slice(0, segIdx + 1)) : path.join(...parts.slice(0, segIdx + 1));
+      return path.resolve(teamDir, '..', 'workspace');
+    }
+  }
+
+  return resolveWorkspaceRoot(api);
+}
+
 function tryResolveTeamDirFromAnyDir(dir: string, teamId: string): string | undefined {
   const seg = `workspace-${teamId}`;
   const abs = path.resolve(dir);