bosun 0.37.1 → 0.37.2

package/voice-relay.mjs

@@ -26,7 +26,7 @@ const OPENAI_REALTIME_MODEL = "gpt-realtime-1.5";
 const OPENAI_AUDIO_RESPONSES_MODEL = "gpt-audio-1.5";
 const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
 const OPENAI_DEFAULT_VISION_MODEL = "gpt-4.1-nano";
-const REALTIME_TRANSCRIBE_MODEL = "gpt-4o-transcribe";
+const DEFAULT_TRANSCRIBE_MODEL = "gpt-4o-transcribe";
 
 const AZURE_API_VERSION = "2025-04-01-preview";
 
@@ -73,6 +73,8 @@ function buildOpenAIRealtimeWebRtcUrl(model, overrideBase = "") {
 
 // GA models (gpt-realtime, gpt-realtime-1.5, gpt-realtime-mini, etc.) use /openai/v1/ paths.
 // Preview models (for example gpt-4o-realtime-preview-*) use legacy /openai/realtimeapi/ paths.
+// NOTE: Azure AI Foundry "Global Standard" deployments may only support preview paths
+// even for GA model names.  We try GA first.  If it 404s the caller falls back to preview.
 function isAzureGaProtocol(deployment) {
   const d = String(deployment || "").toLowerCase().trim();
   return d.startsWith("gpt-realtime") && !d.startsWith("gpt-4o-realtime");
@@ -93,6 +95,13 @@ function normalizeAzureRealtimeDeployment(rawDeployment) {
   return deployment;
 }
 
+function parseOptionalBoolean(rawValue) {
+  if (rawValue == null) return null;
+  const normalized = String(rawValue).trim().toLowerCase();
+  if (!normalized) return null;
+  return !["0", "false", "no", "off"].includes(normalized);
+}
+
 function isOpenAIAudioResponsesModel(rawModel) {
   const model = String(rawModel || "").trim().toLowerCase();
   return /^gpt-audio/.test(model);
@@ -305,18 +314,42 @@ function sanitizeVoiceCallContext(context = {}) {
   const rawExecutor = String(context?.executor || "").trim().toLowerCase();
   const rawMode = String(context?.mode || "").trim().toLowerCase();
   const rawModel = String(context?.model || "").trim();
+  const rawVoiceAgentId = String(context?.voiceAgentId || "").trim();
+  const rawVoiceAgentName = String(context?.voiceAgentName || "").trim();
+  const rawVoiceAgentInstructions = String(context?.voiceAgentInstructions || "").trim();
+  const rawVoiceToolCapabilityPrompt = String(context?.voiceToolCapabilityPrompt || "").trim();
+  const rawVoiceAgentSkills = Array.isArray(context?.voiceAgentSkills)
+    ? context.voiceAgentSkills.map((s) => String(s || "").trim()).filter(Boolean)
+    : [];
+  const rawEnabledMcpServers = Array.isArray(context?.enabledMcpServers)
+    ? context.enabledMcpServers.map((s) => String(s || "").trim()).filter(Boolean)
+    : [];
 
   return {
     sessionId: rawSessionId || null,
     executor: VALID_EXECUTORS.has(rawExecutor) ? rawExecutor : null,
     mode: VALID_AGENT_MODES.has(rawMode) ? rawMode : null,
     model: rawModel || null,
+    voiceAgentId: rawVoiceAgentId || null,
+    voiceAgentName: rawVoiceAgentName || null,
+    voiceAgentInstructions: rawVoiceAgentInstructions || null,
+    voiceToolCapabilityPrompt: rawVoiceToolCapabilityPrompt || null,
+    voiceAgentSkills: rawVoiceAgentSkills,
+    enabledMcpServers: rawEnabledMcpServers,
   };
 }
 
 async function buildSessionScopedInstructions(baseInstructions, callContext = {}) {
   const context = sanitizeVoiceCallContext(callContext);
-  if (!context.sessionId && !context.executor && !context.mode && !context.model) {
+  if (
+    !context.sessionId
+    && !context.executor
+    && !context.mode
+    && !context.model
+    && !context.voiceAgentId
+    && !context.voiceAgentInstructions
+    && !context.voiceToolCapabilityPrompt
+  ) {
     return baseInstructions;
   }
 
@@ -381,6 +414,22 @@ async function buildSessionScopedInstructions(baseInstructions, callContext = {}
     "",
     "## Bosun Voice Call Context",
     `Active chat session id: ${context.sessionId || "none"}.`,
+    context.voiceAgentId
+      ? `Active voice agent id: ${context.voiceAgentId}.`
+      : "Active voice agent id: default.",
+    context.voiceAgentName
+      ? `Active voice agent name: ${context.voiceAgentName}.`
+      : "",
+    context.voiceAgentInstructions
+      ? `Voice agent instruction emphasis: ${context.voiceAgentInstructions}`
+      : "",
+    context.voiceToolCapabilityPrompt || "",
+    context.enabledMcpServers?.length
+      ? `Enabled MCP servers for this session: ${context.enabledMcpServers.join(", ")}.`
+      : "",
+    context.voiceAgentSkills?.length
+      ? `Voice agent skills: ${context.voiceAgentSkills.join(", ")}.`
+      : "",
     context.executor
       ? `Preferred executor for delegated work: ${context.executor}.`
       : "Preferred executor for delegated work: use configured default.",
@@ -783,6 +832,12 @@ export function getVoiceConfig(forceReload = false) {
       azureDeployment: String(ep.deployment || ep.azureDeployment || "").trim() || null,
       voiceId: String(ep.voiceId || "").trim() || null,
       visionModel: String(ep.visionModel || "").trim() || null,
+      transcriptionModel: String(ep.transcriptionModel || "").trim() || null,
+      // Azure defaults to transcription OFF unless explicitly enabled because
+      // item-level ASR failures can spam and destabilize long-running calls.
+      transcriptionEnabled: String(ep.provider || "").toLowerCase() === "azure"
+        ? (ep.transcriptionEnabled === true)
+        : (ep.transcriptionEnabled !== false),
       role: String(ep.role || "primary").trim() || "primary",
       weight: typeof ep.weight === "number" ? ep.weight : 100,
       name: String(ep.name || "").trim() || null,
@@ -861,6 +916,19 @@ export function getVoiceConfig(forceReload = false) {
         : OPENAI_DEFAULT_VISION_MODEL;
   const visionModel =
     voice.visionModel || process.env.VOICE_VISION_MODEL || defaultVisionModel;
+  const transcriptionModel =
+    voice.transcriptionModel || process.env.VOICE_TRANSCRIPTION_MODEL || DEFAULT_TRANSCRIBE_MODEL;
+  const transcriptionEnabledRaw =
+    voice.transcriptionEnabled ?? process.env.VOICE_TRANSCRIPTION_ENABLED;
+  const transcriptionEnabled =
+    transcriptionEnabledRaw == null
+      ? true
+      : !["0", "false", "no", "off"].includes(
+          String(transcriptionEnabledRaw).trim().toLowerCase(),
+        );
+  const azureTranscriptionEnabled = parseOptionalBoolean(
+    voice.azureTranscriptionEnabled ?? process.env.VOICE_AZURE_TRANSCRIPTION_ENABLED,
+  );
   const fallbackMode =
     voice.fallbackMode || process.env.VOICE_FALLBACK_MODE || "browser";
   const delegateExecutor =
@@ -906,6 +974,9 @@ For complex operations like writing code or creating PRs, delegate to the approp
     turnDetection,
     visionModel,
     instructions,
+    transcriptionModel,
+    transcriptionEnabled,
+    azureTranscriptionEnabled,
     fallbackMode,
     delegateExecutor,
     enabled,
@@ -1120,6 +1191,13 @@ async function createOpenAIEphemeralToken(cfg, toolDefinitions = [], callContext
   const instructions = await buildSessionScopedInstructions(cfg.instructions, context);
   const model = normalizeOpenAIRealtimeModel(candidate?.model || cfg.model || OPENAI_REALTIME_MODEL);
   const voiceId = String(candidate?.voiceId || cfg.voiceId || "alloy").trim() || "alloy";
+  // Per-endpoint transcription overrides
+  const transcriptionModel = String(candidate?.transcriptionModel || "").trim() || cfg.transcriptionModel;
+  const transcriptionEnabled = candidate?.transcriptionEnabled !== undefined
+    ? candidate.transcriptionEnabled !== false
+    : cfg.azureTranscriptionEnabled != null
+      ? cfg.azureTranscriptionEnabled !== false
+      : false;
 
   const sessionConfig = {
     model,
@@ -1144,8 +1222,7 @@ async function createOpenAIEphemeralToken(cfg, toolDefinitions = [], callContext
         interrupt_response: true,
       } : {}),
     },
-    input_audio_transcription: { model: REALTIME_TRANSCRIBE_MODEL },
-    output_audio_transcription: { model: REALTIME_TRANSCRIBE_MODEL },
+    ...(transcriptionEnabled ? { input_audio_transcription: { model: transcriptionModel } } : {}),
     tools: toolDefinitions,
   };
 
@@ -1198,11 +1275,17 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
     candidate?.azureDeployment || candidate?.model || cfg.azureDeployment || OPENAI_REALTIME_MODEL,
   );
   const voiceId = String(candidate?.voiceId || cfg.voiceId || "alloy").trim() || "alloy";
+  // Per-endpoint transcription overrides
+  const transcriptionModel = String(candidate?.transcriptionModel || "").trim() || cfg.transcriptionModel;
+  const transcriptionEnabled = candidate?.transcriptionEnabled !== undefined ? candidate.transcriptionEnabled !== false : cfg.transcriptionEnabled;
   // GA protocol (gpt-realtime-1.5, gpt-realtime, etc.) uses /openai/v1/realtime/sessions?api-version=...
   // Preview protocol uses /openai/realtimeapi/sessions?api-version=...
-  const url = isAzureGaProtocol(deployment)
-    ? `${resolvedEndpoint}/openai/v1/realtime/sessions?api-version=${AZURE_API_VERSION}`
-    : `${resolvedEndpoint}/openai/realtimeapi/sessions?api-version=${AZURE_API_VERSION}&deployment=${encodeURIComponent(deployment)}`;
+  // Azure AI Foundry "Global Standard" resources may not support GA paths even for GA model names,
+  // so we build both and try GA first with automatic fallback to preview.
+  const gaUrl = `${resolvedEndpoint}/openai/v1/realtime/sessions?api-version=${AZURE_API_VERSION}`;
+  const previewUrl = `${resolvedEndpoint}/openai/realtimeapi/sessions?api-version=${AZURE_API_VERSION}&deployment=${encodeURIComponent(deployment)}`;
+  const useGa = isAzureGaProtocol(deployment);
+  const url = useGa ? gaUrl : previewUrl;
 
   const headers = {
     "Content-Type": "application/json",
@@ -1239,17 +1322,28 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
         interrupt_response: true,
       } : {}),
     },
-    input_audio_transcription: { model: REALTIME_TRANSCRIBE_MODEL },
-    output_audio_transcription: { model: REALTIME_TRANSCRIBE_MODEL },
+    ...(transcriptionEnabled ? { input_audio_transcription: { model: transcriptionModel } } : {}),
     tools: toolDefinitions,
   };
 
-  const response = await fetch(url, {
+  let response = await fetch(url, {
     method: "POST",
     headers,
     body: JSON.stringify(sessionConfig),
   });
 
+  // Azure AI Foundry "Global Standard" deployments may 404 on the GA path.
+  // Automatically fall back to the preview path before giving up.
+  if (!response.ok && response.status === 404 && useGa) {
+    const previewConfig = { ...sessionConfig };
+    delete previewConfig.type; // preview path does not accept type: "realtime"
+    response = await fetch(previewUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(previewConfig),
+    });
+  }
+
   if (!response.ok) {
     const errorText = await buildProviderErrorDetails(response, "unknown");
     throw new Error(`Azure Realtime session failed (${response.status}): ${errorText}`);
@@ -1257,9 +1351,22 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
 
   const data = await response.json();
   // WebRTC URL diverges from /sessions URL: GA uses /openai/v1/realtime, preview uses /openai/realtime.
-  const webrtcUrl = isAzureGaProtocol(deployment)
+  // If the GA session was created via fallback to preview, use preview WebRTC URL too.
+  const gaSessionSucceeded = useGa && response.url?.includes("/v1/realtime");
+  const webrtcUrl = (useGa && gaSessionSucceeded)
     ? `${resolvedEndpoint}/openai/v1/realtime?api-version=${AZURE_API_VERSION}`
     : `${resolvedEndpoint}/openai/realtime?api-version=${AZURE_API_VERSION}&deployment=${encodeURIComponent(deployment)}`;
+
+  // WebSocket fallback URL — Azure Realtime API always supports WebSocket even
+  // when WebRTC SDP is unavailable (404).  The api-key query parameter provides
+  // authentication since browsers cannot set custom headers on WebSocket.
+  const wsAuthParam = resolvedOAuthToken
+    ? `access_token=${encodeURIComponent(resolvedOAuthToken)}`
+    : `api-key=${encodeURIComponent(resolvedApiKey)}`;
+  const wsUrl = (useGa && gaSessionSucceeded)
+    ? `wss://${new URL(resolvedEndpoint).host}/openai/v1/realtime?api-version=${AZURE_API_VERSION}&${wsAuthParam}`
+    : `wss://${new URL(resolvedEndpoint).host}/openai/realtime?api-version=${AZURE_API_VERSION}&deployment=${encodeURIComponent(deployment)}&${wsAuthParam}`;
+
   return {
     token: data.client_secret?.value || data.token,
     expiresAt: data.client_secret?.expires_at || (Date.now() / 1000 + 60),
@@ -1267,6 +1374,7 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
     voiceId,
     provider: "azure",
     url: webrtcUrl,
+    wsUrl,
     sessionConfig,
     azureEndpoint: resolvedEndpoint,
     azureDeployment: deployment,

package/workflow-engine.mjs

@@ -899,6 +899,60 @@ export class WorkflowEngine extends EventEmitter {
     return triggered;
   }
 
+  // ── Schedule trigger evaluation ──────────────────────────────────────────
+
+  /**
+   * Evaluate all workflows that use `trigger.schedule` or `trigger.scheduled_once`.
+   * Unlike evaluateTriggers() (event-driven), this is polling-based and should
+   * be called periodically (e.g. every 60s) by the monitor.
+   *
+   * Returns an array of { workflowId, triggeredBy } for workflows whose
+   * schedule interval has elapsed since their last completed run.
+   */
+  evaluateScheduleTriggers() {
+    if (!this._loaded) this.load();
+
+    const triggered = [];
+    const runIndex = this._readRunIndex();
+
+    for (const [id, def] of this._workflows) {
+      if (def.enabled === false) continue;
+
+      // Skip workflows that are already running
+      const alreadyRunning = Array.from(this._activeRuns.values()).some(
+        (info) => info?.workflowId === id,
+      );
+      if (alreadyRunning) continue;
+
+      const triggerNodes = (def.nodes || []).filter(
+        (n) => n.type === "trigger.schedule" || n.type === "trigger.scheduled_once",
+      );
+
+      for (const tNode of triggerNodes) {
+        const intervalMs = Number(tNode.config?.intervalMs) || 3600000;
+
+        // Find the most recent completed run for this workflow
+        let lastRunAt = 0;
+        for (const entry of runIndex) {
+          if (entry?.workflowId !== id) continue;
+          const ts = Number(entry?.startedAt || entry?.completedAt || 0);
+          if (ts > lastRunAt) lastRunAt = ts;
+        }
+
+        const elapsed = Date.now() - lastRunAt;
+        if (elapsed >= intervalMs) {
+          triggered.push({ workflowId: id, triggeredBy: tNode.id });
+
+          // For scheduled_once, only fire if never run before
+          if (tNode.type === "trigger.scheduled_once" && lastRunAt > 0) {
+            triggered.pop(); // undo — already ran once
+          }
+        }
+      }
+    }
+    return triggered;
+  }
+
   /** Get status of active runs */
   getActiveRuns() {
     return Array.from(this._activeRuns.entries())

package/workflow-nodes.mjs

@@ -798,7 +798,9 @@ registerNodeType("trigger.manual", {
 });
 
 registerNodeType("trigger.task_low", {
-  describe: () => "Fires when backlog task count drops below threshold",
+  describe: () =>
+    "Fires when backlog task count drops below threshold. Self-queries kanban " +
+    "when todoCount is not pre-populated in context data.",
   schema: {
     type: "object",
     properties: {
@@ -809,7 +811,29 @@ registerNodeType("trigger.task_low", {
   },
   async execute(node, ctx) {
     const threshold = node.config?.threshold ?? 3;
-    const todoCount = ctx.data?.todoCount ?? ctx.data?.backlogCount ?? 0;
+    const status = node.config?.status ?? "todo";
+    let todoCount = ctx.data?.todoCount ?? ctx.data?.backlogCount ?? null;
+
+    // Self-query kanban if todoCount not pre-populated
+    if (todoCount == null) {
+      try {
+        const projectId = cfgOrCtx(node, ctx, "projectId") || undefined;
+        const kanban = ctx.data?._services?.kanban;
+        let tasks;
+        if (kanban?.listTasks) {
+          tasks = await kanban.listTasks(projectId, { status });
+        } else {
+          const ka = await ensureKanbanAdapterMod();
+          tasks = await ka.listTasks(projectId, { status });
+        }
+        todoCount = Array.isArray(tasks) ? tasks.length : 0;
+        ctx.log(node.id, `Self-queried kanban: ${todoCount} task(s) with status "${status}"`);
+      } catch (err) {
+        ctx.log(node.id, `Kanban query failed: ${err?.message || err} — using 0`);
+        todoCount = 0;
+      }
+    }
+
     const triggered = todoCount < threshold;
     ctx.log(node.id, `Task count: ${todoCount}, threshold: ${threshold}, triggered: ${triggered}`);
     return { triggered, todoCount, threshold };
@@ -2322,7 +2346,9 @@ registerNodeType("action.git_operations", {
 });
 
 registerNodeType("action.create_pr", {
-  describe: () => "Hand off pull-request lifecycle to Bosun management (direct creation disabled)",
+  describe: () =>
+    "Create a pull request via GitHub CLI. Falls back to Bosun-managed handoff " +
+    "when gh is unavailable or the operation fails with failOnError=false.",
   schema: {
     type: "object",
     properties: {
@@ -2330,10 +2356,18 @@ registerNodeType("action.create_pr", {
       body: { type: "string", description: "PR body" },
       base: { type: "string", description: "Base branch" },
       baseBranch: { type: "string", description: "Legacy alias for base branch" },
-      branch: { type: "string", description: "Head branch for Bosun lifecycle handoff context" },
+      branch: { type: "string", description: "Head branch (source)" },
       draft: { type: "boolean", default: false },
+      labels: {
+        oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+        description: "Comma-separated or array of labels",
+      },
+      reviewers: {
+        oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+        description: "Comma-separated or array of reviewer handles",
+      },
       cwd: { type: "string" },
-      failOnError: { type: "boolean", default: false, description: "Retained for compatibility; direct PR commands are disabled" },
+      failOnError: { type: "boolean", default: false, description: "If true, throw on gh failure instead of falling back" },
     },
     required: ["title"],
   },
@@ -2342,23 +2376,77 @@ registerNodeType("action.create_pr", {
     const body = ctx.resolve(node.config?.body || "");
     const base = ctx.resolve(node.config?.base || node.config?.baseBranch || "main");
     const branch = ctx.resolve(node.config?.branch || "");
+    const draft = node.config?.draft === true;
+    const failOnError = node.config?.failOnError === true;
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
-    ctx.log(
-      node.id,
-      `PR lifecycle handoff recorded for "${title}" (direct PR commands are disabled)`,
-    );
-    return {
-      success: true,
-      handedOff: true,
-      lifecycle: "bosun_managed",
-      action: "pr_handoff",
-      message: "Direct PR commands are disabled; Bosun manages pull-request lifecycle.",
-      title,
-      body,
-      base,
-      branch: branch || null,
-      cwd,
+
+    // Normalize labels/reviewers to arrays
+    const toList = (v) => {
+      if (!v) return [];
+      if (Array.isArray(v)) return v.map(String).filter(Boolean);
+      return String(v).split(",").map((s) => s.trim()).filter(Boolean);
     };
+    const labels = toList(ctx.resolve(node.config?.labels || ""));
+    const reviewers = toList(ctx.resolve(node.config?.reviewers || ""));
+
+    // Build gh pr create command
+    const args = ["gh", "pr", "create"];
+    args.push("--title", JSON.stringify(title));
+    if (body) args.push("--body", JSON.stringify(body));
+    if (base) args.push("--base", base);
+    if (branch) args.push("--head", branch);
+    if (draft) args.push("--draft");
+    if (labels.length) args.push("--label", labels.join(","));
+    if (reviewers.length) args.push("--reviewer", reviewers.join(","));
+
+    const cmd = args.join(" ");
+    ctx.log(node.id, `Creating PR: ${cmd}`);
+
+    try {
+      const output = execSync(cmd, { cwd, encoding: "utf8", timeout: 60000 });
+      const trimmed = (output || "").trim();
+      // gh pr create prints the PR URL on success
+      const urlMatch = trimmed.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
+      const prNumber = urlMatch ? parseInt(urlMatch[1], 10) : null;
+      const prUrl = urlMatch ? urlMatch[0] : trimmed;
+      ctx.log(node.id, `PR created: ${prUrl}`);
+      return {
+        success: true,
+        prUrl,
+        prNumber,
+        title,
+        base,
+        branch: branch || null,
+        draft,
+        labels,
+        reviewers,
+        output: trimmed,
+      };
+    } catch (err) {
+      const errorMsg = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
+      ctx.log(node.id, `PR creation failed: ${errorMsg}`);
+      if (failOnError) {
+        return { success: false, error: errorMsg, command: cmd };
+      }
+      // Graceful fallback — record handoff for Bosun management
+      ctx.log(node.id, `Falling back to Bosun-managed PR lifecycle handoff`);
+      return {
+        success: true,
+        handedOff: true,
+        lifecycle: "bosun_managed",
+        action: "pr_handoff",
+        message: "gh CLI failed; Bosun manages pull-request lifecycle.",
+        title,
+        body,
+        base,
+        branch: branch || null,
+        draft,
+        labels,
+        reviewers,
+        cwd,
+        ghError: errorMsg,
+      };
+    }
   },
 });
 
@@ -3484,17 +3572,23 @@ registerNodeType("flow.gate", {
 // ═══════════════════════════════════════════════════════════════════════════
 
 registerNodeType("loop.for_each", {
-  describe: () => "Iterate over an array, executing downstream nodes for each item",
+  describe: () =>
+    "Iterate over an array, executing a sub-workflow for each item. " +
+    "Supports parallel fan-out via maxConcurrent and provides per-item " +
+    "context injection under the configured variable name.",
   schema: {
     type: "object",
     properties: {
       items: { type: "string", description: "Expression that resolves to an array" },
       variable: { type: "string", default: "item", description: "Variable name for current item" },
-      maxIterations: { type: "number", default: 50 },
+      indexVariable: { type: "string", default: "index", description: "Variable name for current index" },
+      maxIterations: { type: "number", default: 50, description: "Cap on total iterations" },
+      maxConcurrent: { type: "number", default: 1, description: "Parallel fan-out width (1 = sequential)" },
+      workflowId: { type: "string", description: "Sub-workflow to execute for each item (optional)" },
     },
     required: ["items"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const expr = node.config?.items || "[]";
     let items;
     try {
@@ -3507,12 +3601,65 @@ registerNodeType("loop.for_each", {
     const max = node.config?.maxIterations || 50;
     items = items.slice(0, max);
     const varName = node.config?.variable || "item";
+    const indexVar = node.config?.indexVariable || "index";
+    const maxConcurrent = Math.max(1, node.config?.maxConcurrent || 1);
+    const subWorkflowId = node.config?.workflowId || "";
 
-    // Store items for downstream processing
+    // Store items for downstream processing (backward compat)
     ctx.data[`_loop_${node.id}_items`] = items;
     ctx.data[`_loop_${node.id}_count`] = items.length;
 
-    return { items, count: items.length, variable: varName };
+    const results = [];
+
+    // If a sub-workflow is specified, fan-out execution across items
+    if (subWorkflowId && engine?.execute) {
+      ctx.log(node.id, `Fan-out: ${items.length} item(s), concurrency=${maxConcurrent}, workflow=${subWorkflowId}`);
+
+      // Process items in batches of maxConcurrent
+      for (let batchStart = 0; batchStart < items.length; batchStart += maxConcurrent) {
+        const batch = items.slice(batchStart, batchStart + maxConcurrent);
+        const batchPromises = batch.map(async (item, batchIdx) => {
+          const itemIndex = batchStart + batchIdx;
+          const itemData = {
+            ...ctx.data,
+            [varName]: item,
+            [indexVar]: itemIndex,
+            _loopParentNodeId: node.id,
+            _loopIteration: itemIndex,
+            _loopTotal: items.length,
+          };
+          try {
+            const runCtx = await engine.execute(subWorkflowId, itemData);
+            const ok = !runCtx?.errors?.length;
+            return { index: itemIndex, item, success: ok, runId: runCtx?.id || null };
+          } catch (err) {
+            return { index: itemIndex, item, success: false, error: err?.message || String(err) };
+          }
+        });
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+      }
+    } else {
+      // No sub-workflow — store items for downstream node access (legacy mode)
+      for (let i = 0; i < items.length; i++) {
+        ctx.data[varName] = items[i];
+        ctx.data[indexVar] = i;
+        results.push({ index: i, item: items[i], success: true });
+      }
+    }
+
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.length - successCount;
+    ctx.log(node.id, `Loop complete: ${successCount} succeeded, ${failCount} failed out of ${items.length}`);
+
+    return {
+      items,
+      count: items.length,
+      variable: varName,
+      results,
+      successCount,
+      failCount,
+    };
   },
 });
 
@@ -5088,17 +5235,19 @@ registerNodeType("action.detect_new_commits", {
   schema: {
     type: "object",
     properties: {
-      worktreePath: { type: "string", description: "Worktree path" },
+      worktreePath: { type: "string", description: "Worktree path (soft-fails if not set)" },
       preExecHead: { type: "string", description: "HEAD hash before agent (auto from ctx)" },
       baseBranch: { type: "string", description: "Base branch for diff stats" },
     },
-    required: ["worktreePath"],
   },
   async execute(node, ctx) {
     const worktreePath = cfgOrCtx(node, ctx, "worktreePath");
     const baseBranch = cfgOrCtx(node, ctx, "baseBranch", "origin/main");
 
-    if (!worktreePath) throw new Error("action.detect_new_commits: worktreePath is required");
+    if (!worktreePath) {
+      ctx.log(node.id, "action.detect_new_commits: worktreePath not set — skipping commit detection");
+      return { success: false, error: "worktreePath required", hasCommits: false, hasNewCommits: false, unpushedCount: 0 };
+    }
 
     // Read preExecHead from record-head node output or ctx
     const preExecHead = cfgOrCtx(node, ctx, "preExecHead")