@jiggai/recipes 0.4.28 → 0.4.30

package/docs/WORKFLOW_RUNS_FILE_FIRST.md

@@ -765,7 +765,8 @@ See: [OUTBOUND_POSTING.md](OUTBOUND_POSTING.md)
 If you rely on a controller-local custom posting patch:
 - you may need to reapply that patch after install/update
 - you may need to tell your assistant to turn workflow posting back on
-- RJ's current public gist for the `marketing.post_all` patch is: <https://gist.github.com/rjdjohnston/7a8824ae16f347a4642fc7782fe66219>
+- RJ's current public gist for the `marketing.post_all` patch is: <https://gist.github.com/rjdjohnston/2440a776529829e7d1c0d5d949f6e631>
+  - Note: Updated for current file structure (`workflow-worker.ts` vs old `workflow-runner.ts`)
 
 So if a workflow runs but does not actually post, check your posting path before blaming the runner.
 

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "recipes",
   "name": "Recipes",
   "description": "Markdown recipes that scaffold agents and teams (workspace-local).",
-  "version": "0.4.28",
+  "version": "0.4.30",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiggai/recipes",
-  "version": "0.4.28",
+  "version": "0.4.30",
   "description": "ClawRecipes plugin for OpenClaw (markdown recipes -> scaffold agents/teams)",
   "main": "index.ts",
   "type": "commonjs",

package/src/handlers/team.ts

@@ -262,9 +262,9 @@ async function scaffoldTeamAgents(
       agentName,
       update: overwrite,
       filesRootDir: roleDir,
-      // IMPORTANT: non-lead roles use per-role workspaces so the Kitchen UI / agent files panel reads role files.
-      // Lead uses the team root so the lead heartbeat reads team-root HEARTBEAT.md.
-      workspaceRootDir: role === "lead" ? teamDir : roleDir,
+      // IMPORTANT: All roles (including lead) use per-role workspaces so they get role-specific bootstrap files.
+      // This ensures leads get their role-specific AGENTS.md, SOUL.md, MEMORY.md for proper identity context.
+      workspaceRootDir: roleDir,
       vars: { teamId, teamDir, role, agentId, agentName, roleDir },
     });
 
@@ -308,9 +308,9 @@ Recommended:
     }
 
 
-    // Heartbeat scaffold (opt-in for non-lead roles): drop a minimal HEARTBEAT.md in the role workspace.
-    // The lead uses the team-root HEARTBEAT.md.
-    if (role !== "lead" && heartbeatEnabledRoles.has(String(role))) {
+    // Heartbeat scaffold (opt-in): drop a minimal HEARTBEAT.md in each role workspace.
+    // All roles now use role-specific workspaces for consistent bootstrap file access.
+    if (heartbeatEnabledRoles.has(String(role))) {
       const mode = overwrite ? "overwrite" : "createOnly";
       const hb = `# HEARTBEAT — ${teamId} (${role})
 

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

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import { execSync } from 'node:child_process';
 import path from 'node:path';
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 import type { ToolTextResult } from '../../toolsInvoke';
@@ -19,6 +20,155 @@ import {
   sanitizeDraftOnlyText, templateReplace,
 } from './workflow-utils';
 
+/**
+ * Build memory context for LLM nodes by reading team memory files
+ */
+async function buildMemoryContext(teamDir: string): Promise<string> {
+  try {
+    const memoryDir = path.join(teamDir, 'shared-context', 'memory');
+    
+    // Check if memory directory exists
+    if (!await fileExists(memoryDir)) {
+      return '';
+    }
+
+    const memoryParts: string[] = [];
+    const maxTokens = 2000; // Rough token budget
+    let currentTokens = 0;
+
+    // Read pinned items first (highest priority)
+    const pinnedPath = path.join(memoryDir, 'pinned.jsonl');
+    if (await fileExists(pinnedPath)) {
+      const pinnedContent = await fs.readFile(pinnedPath, 'utf8');
+      const pinnedItems = pinnedContent.trim().split('\n').filter(Boolean);
+      
+      if (pinnedItems.length > 0) {
+        memoryParts.push('[Team Memory — Pinned]');
+        for (const line of pinnedItems.slice(-5)) { // Last 5 pinned items
+          try {
+            const item = JSON.parse(line);
+            if (item.content || item.text) {
+              const summary = `- ${item.content || item.text} (${item.type || 'note'}, ${(item.ts || '').slice(0, 10)})`;
+              if (currentTokens + summary.length * 0.25 < maxTokens) { // Rough token estimate
+                memoryParts.push(summary);
+                currentTokens += summary.length * 0.25;
+              }
+            }
+          } catch {
+            // Skip malformed JSON lines
+          }
+        }
+      }
+    }
+
+    // Read recent items from other JSONL files  
+    const files = await fs.readdir(memoryDir);
+    const jsonlFiles = files.filter(f => f.endsWith('.jsonl') && f !== 'pinned.jsonl');
+    
+    for (const filename of jsonlFiles) {
+      if (currentTokens > maxTokens * 0.8) break; // Leave room for recent items
+      
+      const filePath = path.join(memoryDir, filename);
+      const content = await fs.readFile(filePath, 'utf8');
+      const items = content.trim().split('\n').filter(Boolean);
+      
+      if (items.length > 0) {
+        const recentItems = items.slice(-3); // Last 3 items from each file
+        for (const line of recentItems) {
+          try {
+            const item = JSON.parse(line);
+            if (item.content || item.text) {
+              const summary = `- ${item.content || item.text} (${item.type || 'note'}, ${(item.ts || '').slice(0, 10)})`;
+              if (currentTokens + summary.length * 0.25 < maxTokens) {
+                if (memoryParts.length === 1) { // Only pinned section exists
+                  memoryParts.push('', '[Team Memory — Recent]');
+                }
+                memoryParts.push(summary);
+                currentTokens += summary.length * 0.25;
+              }
+            }
+          } catch {
+            // Skip malformed JSON lines
+          }
+        }
+      }
+    }
+
+    // If we have memory content, format it properly
+    if (memoryParts.length > 1) {
+      return memoryParts.join('\n') + '\n\n[Task]';
+    }
+
+    return '';
+  } catch (error) {
+    // Fail gracefully - memory injection is optional
+    console.warn('Memory context injection failed:', error);
+    return '';
+  }
+}
+
+/**
+ * Build template variables from prior node outputs for prompt/path interpolation.
+ * Reused across LLM, media, tool, and fs nodes.
+ */
+async function buildTemplateVars(
+  teamDir: string,
+  runsDir: string,
+  runId: string,
+  workflowFile: string,
+  workflow: { id?: string; name?: string },
+): Promise<Record<string, string>> {
+  const vars = {
+    date: new Date().toISOString(),
+    'run.id': runId,
+    'run.timestamp': runId,
+    'workflow.id': String(workflow.id ?? ''),
+    'workflow.name': String(workflow.name ?? workflow.id ?? workflowFile),
+  } as Record<string, string>;
+
+  const { run: runSnap } = await loadRunFile(teamDir, runsDir, runId);
+  for (const nr of (runSnap.nodeResults ?? [])) {
+    const nid = String((nr as Record<string, unknown>).nodeId ?? '');
+    const nrOutPath = String((nr as Record<string, unknown>).nodeOutputPath ?? '');
+    if (nid && nrOutPath) {
+      try {
+        const outAbs = path.resolve(teamDir, nrOutPath);
+        const outputContent = await fs.readFile(outAbs, 'utf8');
+        vars[`${nid}.output`] = outputContent;
+
+        try {
+          const parsed = JSON.parse(outputContent.trim());
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            for (const [key, value] of Object.entries(parsed)) {
+              if (typeof value === 'string') {
+                vars[`${nid}.${key}`] = value;
+                if (key === 'text') {
+                  try {
+                    const nestedParsed = JSON.parse(value);
+                    if (nestedParsed && typeof nestedParsed === 'object' && !Array.isArray(nestedParsed)) {
+                      for (const [nestedKey, nestedValue] of Object.entries(nestedParsed)) {
+                        if (typeof nestedValue === 'string') {
+                          vars[`${nid}.${nestedKey}`] = nestedValue;
+                        } else if (nestedValue !== null && nestedValue !== undefined) {
+                          vars[`${nid}.${nestedKey}_json`] = JSON.stringify(nestedValue);
+                        }
+                      }
+                    }
+                  } catch { /* nested parse fail is fine */ }
+                }
+              } else if (value !== null && value !== undefined) {
+                vars[`${nid}.${key}_json`] = JSON.stringify(value);
+              }
+            }
+          }
+        } catch { /* non-JSON output is fine */ }
+      } catch { /* node output may not exist */ }
+    }
+  }
+
+  return vars;
+}
+
 // eslint-disable-next-line complexity, max-lines-per-function
 export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
   teamId: string;
@@ -187,7 +337,69 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
       }
       await ensureDir(path.dirname(nodeOutputAbs));
 
-      const prompt = promptTemplateInline ? promptTemplateInline : await readTextFile(promptPathAbs);
+      const promptRaw = promptTemplateInline ? promptTemplateInline : await readTextFile(promptPathAbs);
+      
+      // Build template variables (same as fs.write/fs.append)
+      const vars = {
+        date: new Date().toISOString(),
+        'run.id': runId,
+        'run.timestamp': runId,
+        'workflow.id': String(workflow.id ?? ''),
+        'workflow.name': String(workflow.name ?? workflow.id ?? workflowFile),
+      };
+      
+      // Load node outputs and make them available as template variables
+      const { run: runSnap } = await loadRunFile(teamDir, runsDir, task.runId);
+      for (const nr of (runSnap.nodeResults ?? [])) {
+        const nid = String((nr as Record<string, unknown>).nodeId ?? '');
+        const nrOutPath = String((nr as Record<string, unknown>).nodeOutputPath ?? '');
+        if (nid && nrOutPath) {
+          try {
+            const outAbs = path.resolve(teamDir, nrOutPath);
+            const outputContent = await fs.readFile(outAbs, 'utf8');
+            vars[`${nid}.output`] = outputContent;
+            
+            // Parse JSON outputs and make fields accessible
+            try {
+              const parsed = JSON.parse(outputContent.trim());
+              if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                for (const [key, value] of Object.entries(parsed)) {
+                  if (typeof value === 'string') {
+                    vars[`${nid}.${key}`] = value;
+                    
+                    // Special handling for 'text' field - try to parse as nested JSON
+                    if (key === 'text') {
+                      try {
+                        const nestedParsed = JSON.parse(value);
+                        if (nestedParsed && typeof nestedParsed === 'object' && !Array.isArray(nestedParsed)) {
+                          for (const [nestedKey, nestedValue] of Object.entries(nestedParsed)) {
+                            if (typeof nestedValue === 'string') {
+                              vars[`${nid}.${nestedKey}`] = nestedValue;
+                            } else if (nestedValue !== null && nestedValue !== undefined) {
+                              vars[`${nid}.${nestedKey}_json`] = JSON.stringify(nestedValue);
+                            }
+                          }
+                        }
+                      } catch {
+                        // If nested parsing fails, just keep the text field as is
+                      }
+                    }
+                  } else if (value !== null && value !== undefined) {
+                    // For non-string values, provide JSON representation
+                    vars[`${nid}.${key}_json`] = JSON.stringify(value);
+                  }
+                }
+              }
+            } catch {
+              // If output isn't valid JSON, skip parsing but keep raw output
+            }
+          } catch { /* node output may not exist */ }
+        }
+      }
+      
+      // Apply template variable replacement
+      const prompt = templateReplace(promptRaw, vars);
+      
       const taskText = [
         `You are executing a workflow run for teamId=${teamId}.`,
         `Workflow: ${workflow.name ?? workflow.id ?? workflowFile}`,
@@ -207,11 +419,15 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
         const timeoutMsRaw = Number(asString(action['timeoutMs'] ?? (node as unknown as { config?: unknown })?.config?.['timeoutMs'] ?? '120000'));
         const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? timeoutMsRaw : 120000;
 
+        // Inject team memory context for LLM nodes
+        const memoryContext = await buildMemoryContext(teamDir);
+        const promptWithMemory = memoryContext ? `${memoryContext}\n\n${taskText}` : taskText;
+
         const llmRes = await toolsInvoke<unknown>(api, {
           tool: 'llm-task',
           action: 'json',
           args: {
-            prompt: taskText,
+            prompt: promptWithMemory,
             input: { teamId, runId, nodeId: node.id, agentId, ...priorInput },
             timeoutMs,
           },
@@ -400,6 +616,56 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
             'workflow.id': String(workflow.id ?? ''),
             'workflow.name': String(workflow.name ?? workflow.id ?? workflowFile),
           };
+
+          // Load node outputs (same as fs.write)
+          const { run: runSnap } = await loadRunFile(teamDir, runsDir, task.runId);
+          for (const nr of (runSnap.nodeResults ?? [])) {
+            const nid = String((nr as Record<string, unknown>).nodeId ?? '');
+            const nrOutPath = String((nr as Record<string, unknown>).nodeOutputPath ?? '');
+            if (nid && nrOutPath) {
+              try {
+                const outAbs = path.resolve(teamDir, nrOutPath);
+                const outputContent = await fs.readFile(outAbs, 'utf8');
+                vars[`${nid}.output`] = outputContent;
+                
+                // Parse JSON outputs and make fields accessible
+                try {
+                  const parsed = JSON.parse(outputContent.trim());
+                  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    for (const [key, value] of Object.entries(parsed)) {
+                      if (typeof value === 'string') {
+                        vars[`${nid}.${key}`] = value;
+                        
+                        // Special handling for 'text' field - try to parse as nested JSON
+                        if (key === 'text') {
+                          try {
+                            const nestedParsed = JSON.parse(value);
+                            if (nestedParsed && typeof nestedParsed === 'object' && !Array.isArray(nestedParsed)) {
+                              for (const [nestedKey, nestedValue] of Object.entries(nestedParsed)) {
+                                if (typeof nestedValue === 'string') {
+                                  vars[`${nid}.${nestedKey}`] = nestedValue;
+                                } else if (nestedValue !== null && nestedValue !== undefined) {
+                                  vars[`${nid}.${nestedKey}_json`] = JSON.stringify(nestedValue);
+                                }
+                              }
+                            }
+                          } catch {
+                            // If nested parsing fails, just keep the text field as is
+                          }
+                        }
+                      } else if (value !== null && value !== undefined) {
+                        // For non-string values, provide JSON representation
+                        vars[`${nid}.${key}_json`] = JSON.stringify(value);
+                      }
+                    }
+                  }
+                } catch {
+                  // If output isn't valid JSON, skip parsing but keep raw output
+                }
+              } catch { /* node output may not exist */ }
+            }
+          }
+
           const relPath = templateReplace(relPathRaw, vars);
           const content = templateReplace(contentRaw, vars);
 
@@ -435,7 +701,43 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
             if (nid && nrOutPath) {
               try {
                 const outAbs = path.resolve(teamDir, nrOutPath);
-                vars[`${nid}.output`] = await fs.readFile(outAbs, 'utf8');
+                const outputContent = await fs.readFile(outAbs, 'utf8');
+                vars[`${nid}.output`] = outputContent;
+                
+                // Parse JSON outputs and make fields accessible
+                try {
+                  const parsed = JSON.parse(outputContent.trim());
+                  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    for (const [key, value] of Object.entries(parsed)) {
+                      if (typeof value === 'string') {
+                        vars[`${nid}.${key}`] = value;
+                        
+                        // Special handling for 'text' field - try to parse as nested JSON
+                        if (key === 'text') {
+                          try {
+                            const nestedParsed = JSON.parse(value);
+                            if (nestedParsed && typeof nestedParsed === 'object' && !Array.isArray(nestedParsed)) {
+                              for (const [nestedKey, nestedValue] of Object.entries(nestedParsed)) {
+                                if (typeof nestedValue === 'string') {
+                                  vars[`${nid}.${nestedKey}`] = nestedValue;
+                                } else if (nestedValue !== null && nestedValue !== undefined) {
+                                  vars[`${nid}.${nestedKey}_json`] = JSON.stringify(nestedValue);
+                                }
+                              }
+                            }
+                          } catch {
+                            // If nested parsing fails, just keep the text field as is
+                          }
+                        }
+                      } else if (value !== null && value !== undefined) {
+                        // For non-string values, provide JSON representation
+                        vars[`${nid}.${key}_json`] = JSON.stringify(value);
+                      }
+                    }
+                  }
+                } catch {
+                  // If output isn't valid JSON, skip parsing but keep raw output
+                }
               } catch { /* node output may not exist */ }
             }
           }
@@ -453,19 +755,92 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
           const result = { writtenTo: path.relative(teamDir, abs), bytes: Buffer.byteLength(content, 'utf8') };
           await fs.writeFile(artifactPath, JSON.stringify({ ok: true, tool: toolName, args: toolArgs, result }, null, 2) + '\n', 'utf8');
 
-        } else if (toolName === 'marketing.post_all') {
-          // 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 {
+          // Build template variables for general tool nodes (same as fs.write/fs.append)
+          const vars = {
+            date: new Date().toISOString(),
+            'run.id': runId,
+            'run.timestamp': runId,
+            'workflow.id': String(workflow.id ?? ''),
+            'workflow.name': String(workflow.name ?? workflow.id ?? workflowFile),
+          };
+          
+          // Load node outputs and make them available as template variables
+          const { run: runSnap } = await loadRunFile(teamDir, runsDir, task.runId);
+          for (const nr of (runSnap.nodeResults ?? [])) {
+            const nid = String((nr as Record<string, unknown>).nodeId ?? '');
+            const nrOutPath = String((nr as Record<string, unknown>).nodeOutputPath ?? '');
+            if (nid && nrOutPath) {
+              try {
+                const outAbs = path.resolve(teamDir, nrOutPath);
+                const outputContent = await fs.readFile(outAbs, 'utf8');
+                vars[`${nid}.output`] = outputContent;
+                
+                // Parse JSON outputs and make fields accessible
+                try {
+                  const parsed = JSON.parse(outputContent.trim());
+                  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    for (const [key, value] of Object.entries(parsed)) {
+                      if (typeof value === 'string') {
+                        vars[`${nid}.${key}`] = value;
+                        
+                        // Special handling for 'text' field - try to parse as nested JSON
+                        if (key === 'text') {
+                          try {
+                            const nestedParsed = JSON.parse(value);
+                            if (nestedParsed && typeof nestedParsed === 'object' && !Array.isArray(nestedParsed)) {
+                              for (const [nestedKey, nestedValue] of Object.entries(nestedParsed)) {
+                                if (typeof nestedValue === 'string') {
+                                  vars[`${nid}.${nestedKey}`] = nestedValue;
+                                } else if (nestedValue !== null && nestedValue !== undefined) {
+                                  vars[`${nid}.${nestedKey}_json`] = JSON.stringify(nestedValue);
+                                }
+                              }
+                            }
+                          } catch {
+                            // If nested parsing fails, just keep the text field as is
+                          }
+                        }
+                      } else if (value !== null && value !== undefined) {
+                        // For non-string values, provide JSON representation
+                        vars[`${nid}.${key}_json`] = JSON.stringify(value);
+                      }
+                    }
+                  }
+                } catch {
+                  // If output isn't valid JSON, skip parsing but keep raw output
+                }
+              } catch { /* node output may not exist */ }
+            }
+          }
+          
+          // Apply template variable replacement to all string values in toolArgs
+          const processedToolArgs: Record<string, unknown> = {};
+          for (const [key, value] of Object.entries(toolArgs)) {
+            if (typeof value === 'string') {
+              processedToolArgs[key] = templateReplace(value, vars);
+            } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+              // Recursively process nested objects
+              const processedObject: Record<string, unknown> = {};
+              for (const [nestedKey, nestedValue] of Object.entries(value as Record<string, unknown>)) {
+                if (typeof nestedValue === 'string') {
+                  processedObject[nestedKey] = templateReplace(nestedValue, vars);
+                } else {
+                  processedObject[nestedKey] = nestedValue;
+                }
+              }
+              processedToolArgs[key] = processedObject;
+            } else {
+              processedToolArgs[key] = value;
+            }
+          }
+
           const toolRes = await toolsInvoke<unknown>(api, {
             tool: toolName,
-            args: toolArgs,
+            args: processedToolArgs,
           });
 
-          await fs.writeFile(artifactPath, JSON.stringify({ ok: true, tool: toolName, result: toolRes }, null, 2) + '\n', 'utf8');
+          await fs.writeFile(artifactPath, JSON.stringify({ ok: true, tool: toolName, args: processedToolArgs, result: toolRes }, null, 2) + '\n', 'utf8');
         }
 
         const defaultNodeOutputRel = path.join('node-outputs', `${String(nodeIdx).padStart(3, '0')}-${node.id}.json`);
@@ -503,6 +878,172 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
         results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'error', error: (e as Error).message });
         continue;
       }
+    } else if (kind === 'media-image' || kind === 'media-video' || kind === 'media-audio') {
+      // ── Media generation nodes ──────────────────────────────────────────
+      // Two-step process:
+      //   1. LLM generates a refined prompt (image_prompt / video_prompt)
+      //   2. Agent invokes the selected skill to produce the actual media
+      const config = asRecord((node as unknown as Record<string, unknown>)['config']);
+      const action = asRecord(node.action);
+
+      const mediaType = asString(config['mediaType'] ?? kind.replace('media-', '')).trim() || 'image';
+      const provider = asString(config['provider'] ?? action['provider']).trim();
+      const promptTemplateRaw = asString(config['promptTemplate'] ?? config['prompt'] ?? action['promptTemplate'] ?? action['prompt']).trim();
+      const size = asString(config['size']).trim() || '1024x1024';
+      const quality = asString(config['quality']).trim() || 'standard';
+      const style = asString(config['style']).trim() || 'natural';
+      const outputPathRaw = asString(config['outputPath']).trim();
+      const agentIdMedia = asString(config['agentId'] ?? action['agentId'] ?? '').trim();
+
+      if (!promptTemplateRaw) throw new Error(`Node ${nodeLabel(node)} missing prompt or promptTemplate for media generation`);
+
+      const vars = await buildTemplateVars(teamDir, runsDir, task.runId, workflowFile, workflow);
+      // Add node-level vars that templateReplace doesn't normally include
+      vars['node.id'] = node.id;
+      const prompt = templateReplace(promptTemplateRaw, vars);
+      const outputRelPath = templateReplace(outputPathRaw, vars);
+
+      const defaultNodeOutputRel = path.join('node-outputs', `${String(nodeIdx).padStart(3, '0')}-${node.id}.json`);
+      const nodeOutputRel = String(node?.output?.path ?? '').trim() || defaultNodeOutputRel;
+      const nodeOutputAbs = path.resolve(runDir, nodeOutputRel);
+      await ensureDir(path.dirname(nodeOutputAbs));
+
+      // Determine the output media directory for the skill to save into
+      const mediaDir = outputRelPath
+        ? path.resolve(runDir, path.dirname(outputRelPath))
+        : path.resolve(runDir, 'media');
+      await ensureDir(mediaDir);
+
+      const promptKey = mediaType === 'video' ? 'video_prompt' : 'image_prompt';
+
+      let text = '';
+      try {
+        // Inject team memory context
+        const memoryContext = await buildMemoryContext(teamDir);
+        const timeoutMsRaw = Number(asString(config['timeoutMs'] ?? '300000'));
+        const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? timeoutMsRaw : 300000;
+
+        // ── Step 1: LLM refines the prompt ──────────────────────────────
+        const step1Text = [
+          `You are a media prompt engineer for teamId=${teamId}.`,
+          `Workflow: ${workflow.name ?? workflow.id ?? workflowFile}`,
+          `Node: ${nodeLabel(node)} | Media type: ${mediaType}`,
+          `Size: ${size} | Quality: ${quality} | Style: ${style}`,
+          `\n---\nINPUT PROMPT\n---\n`,
+          prompt.trim(),
+          `\n---\nINSTRUCTIONS\n---\n`,
+          `Refine the input into a detailed, production-ready ${mediaType} generation prompt.`,
+          `Return JSON with exactly one key: "${promptKey}" containing the refined prompt string.`,
+          `Example: {"${promptKey}": "A detailed description..."}`,
+        ].filter(Boolean).join('\n');
+
+        const step1Prompt = memoryContext ? `${memoryContext}\n\n${step1Text}` : step1Text;
+
+        const step1Res = await toolsInvoke<unknown>(api, {
+          tool: 'llm-task',
+          action: 'json',
+          args: { prompt: step1Prompt, timeoutMs: 60000 },
+        });
+
+        // Extract the refined prompt
+        const step1Rec = asRecord(step1Res);
+        const step1Details = asRecord(step1Rec['details']);
+        const step1Json = (step1Details['json'] ?? step1Details ?? step1Res) as Record<string, unknown>;
+        const refinedPrompt = asString(
+          step1Json[promptKey] ?? step1Json['image_prompt'] ?? step1Json['video_prompt'] ?? step1Json['prompt'] ?? prompt
+        ).trim();
+
+        if (!refinedPrompt) throw new Error('LLM returned empty refined prompt');
+
+        // ── Step 2: Invoke the skill script to generate actual media ─────
+        const skillName = provider.replace(/^skill-/, '');
+        const homedir = process.env.HOME || '/home/control';
+
+        // Search for the skill's executable script
+        const skillSearchDirs = [
+          path.join(homedir, '.openclaw', 'skills', skillName),
+          path.join(homedir, '.openclaw', 'workspace', 'skills', skillName),
+        ];
+        let scriptPath = '';
+        for (const dir of skillSearchDirs) {
+          const candidates = [`generate_image.sh`, `generate_video.sh`, `generate.sh`];
+          for (const c of candidates) {
+            const p = path.join(dir, c);
+            try { await fs.access(p); scriptPath = p; break; } catch { /* skip */ }
+          }
+          if (scriptPath) break;
+        }
+
+        let payload: Record<string, unknown>;
+        if (scriptPath) {
+          // Run the skill script directly with the refined prompt
+          const scriptOutput = execSync(
+            `bash ${JSON.stringify(scriptPath)} ${JSON.stringify(refinedPrompt)}`,
+            { cwd: mediaDir, timeout: timeoutMs, encoding: 'utf8', env: { ...process.env, HOME: homedir } }
+          ).trim();
+
+          // Parse the output — skill scripts print "MEDIA:/path/to/file"
+          const mediaMatch = scriptOutput.match(/MEDIA:(.+)$/m);
+          const filePath = mediaMatch ? mediaMatch[1].trim() : '';
+
+          payload = {
+            [promptKey]: refinedPrompt,
+            file_path: filePath,
+            status: filePath ? 'success' : 'error',
+            skill: skillName,
+            script_output: scriptOutput,
+            error: filePath ? null : 'No MEDIA: path in script output',
+          };
+        } else {
+          // No skill script found — fall back to prompt-only output
+          payload = {
+            [promptKey]: refinedPrompt,
+            file_path: '',
+            status: 'no_skill_script',
+            skill: skillName,
+            error: `No executable script found for skill "${skillName}" in ${skillSearchDirs.join(', ')}`,
+          };
+        }
+        text = JSON.stringify(payload, null, 2);
+      } catch (e) {
+        const errMsg = `Media generation failed for node ${nodeLabel(node)}: ${e instanceof Error ? e.message : String(e)}`;
+        const errorTs = new Date().toISOString();
+        await appendRunLog(runPath, (cur) => ({
+          ...cur,
+          status: 'error',
+          updatedAt: errorTs,
+          nodeStates: { ...(cur.nodeStates ?? {}), [node.id]: { status: 'error', ts: errorTs, error: errMsg } },
+          events: [...cur.events, { ts: errorTs, type: 'node.error', nodeId: node.id, kind: node.kind, message: errMsg }],
+          nodeResults: [...(cur.nodeResults ?? []), { nodeId: node.id, kind: node.kind, agentId: agentIdMedia || agentId, error: errMsg }],
+        }));
+        results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'error' });
+        continue;
+      }
+
+      // Save output
+      const outputObj = {
+        runId: task.runId,
+        teamId,
+        nodeId: node.id,
+        kind: node.kind,
+        mediaType,
+        provider,
+        agentId: agentIdMedia || agentId,
+        completedAt: new Date().toISOString(),
+        outputPath: outputRelPath,
+        mediaDir,
+        text,
+      };
+      await fs.writeFile(nodeOutputAbs, JSON.stringify(outputObj, null, 2) + '\n', 'utf8');
+
+      const completedTs = new Date().toISOString();
+      await appendRunLog(runPath, (cur) => ({
+        ...cur,
+        nextNodeIndex: nodeIdx + 1,
+        nodeStates: { ...(cur.nodeStates ?? {}), [node.id]: { status: 'success', ts: completedTs } },
+        events: [...cur.events, { ts: completedTs, type: 'node.completed', nodeId: node.id, kind: node.kind, nodeOutputPath: path.relative(teamDir, nodeOutputAbs) }],
+        nodeResults: [...(cur.nodeResults ?? []), { nodeId: node.id, kind: node.kind, mediaType, agentId: agentIdMedia || agentId, nodeOutputPath: path.relative(teamDir, nodeOutputAbs), bytes: new TextEncoder().encode(text).byteLength }],
+      }));
     } else {
       throw new Error(`Worker does not yet support node kind: ${kind}`);
     }