bosun 0.40.2 → 0.40.4

package/workflow/workflow-engine.mjs

@@ -1282,12 +1282,12 @@ export class WorkflowEngine extends EventEmitter {
   // ── Schedule trigger evaluation ──────────────────────────────────────────
 
   /**
-   * Evaluate all workflows that use `trigger.schedule` or `trigger.scheduled_once`.
+   * Evaluate polling workflows.
    * 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.
+   * polling interval has elapsed since their last completed run.
    */
   evaluateScheduleTriggers() {
     if (!this._loaded) this.load();
@@ -1304,12 +1304,22 @@ export class WorkflowEngine extends EventEmitter {
       );
       if (alreadyRunning) continue;
 
-      const triggerNodes = (def.nodes || []).filter(
-        (n) => n.type === "trigger.schedule" || n.type === "trigger.scheduled_once",
+      const triggerNodes = (def.nodes || []).filter((n) =>
+        n.type === "trigger.schedule"
+        || n.type === "trigger.scheduled_once"
+        || n.type === "trigger.task_available"
+        || n.type === "trigger.task_low",
       );
 
       for (const tNode of triggerNodes) {
-        const intervalMs = Number(tNode.config?.intervalMs) || 3600000;
+        let intervalMs = 3600000;
+        if (tNode.type === "trigger.task_available") {
+          intervalMs = Number(tNode.config?.pollIntervalMs) || 30000;
+        } else if (tNode.type === "trigger.task_low") {
+          intervalMs = Number(tNode.config?.pollIntervalMs) || 60000;
+        } else {
+          intervalMs = Number(tNode.config?.intervalMs) || 3600000;
+        }
 
         // Find the most recent completed run for this workflow
         let lastRunAt = 0;
@@ -1781,6 +1791,7 @@ export class WorkflowEngine extends EventEmitter {
         const node = nodeMap.get(nodeId);
         const edges = adjacency.get(nodeId) || [];
         const sourceOutput = ctx.getNodeOutput(nodeId);
+        const triggerBlocked = node?.type?.startsWith("trigger.") && sourceOutput?.triggered === false;
         const selectedPortRaw =
           sourceOutput?.matchedPort ??
           sourceOutput?.port ??
@@ -1790,6 +1801,19 @@ export class WorkflowEngine extends EventEmitter {
             ? selectedPortRaw.trim()
             : null;
 
+        if (triggerBlocked) {
+          for (const edge of edges) {
+            if (edge.backEdge) continue;
+            const newDegree = (inDegree.get(edge.target) || 1) - 1;
+            inDegree.set(edge.target, newDegree);
+            if (newDegree <= 0 && !executed.has(edge.target)) {
+              ctx.setNodeStatus(edge.target, NodeStatus.SKIPPED);
+              executed.add(edge.target);
+            }
+          }
+          continue;
+        }
+
         // Handle loop.for_each: iterate downstream subgraph per item
         if (node?.type === "loop.for_each" && ctx.getNodeStatus(nodeId) === NodeStatus.COMPLETED) {
           const loopOutput = ctx.getNodeOutput(nodeId);
@@ -2442,18 +2466,6 @@ export class WorkflowEngine extends EventEmitter {
 
       if (!runs.length) {
         this._resumingRuns = false;
-    this._taskTraceHooks = new Set();
-    if (typeof opts.onTaskWorkflowEvent === "function") {
-      this._taskTraceHooks.add(opts.onTaskWorkflowEvent);
-    }
-    if (typeof opts.taskTraceHook === "function") {
-      this._taskTraceHooks.add(opts.taskTraceHook);
-    }
-    if (Array.isArray(opts.taskTraceHooks)) {
-      for (const hook of opts.taskTraceHooks) {
-        if (typeof hook === "function") this._taskTraceHooks.add(hook);
-      }
-    }
         return;
       }
 
@@ -2512,18 +2524,6 @@ export class WorkflowEngine extends EventEmitter {
       }
     } finally {
       this._resumingRuns = false;
-    this._taskTraceHooks = new Set();
-    if (typeof opts.onTaskWorkflowEvent === "function") {
-      this._taskTraceHooks.add(opts.onTaskWorkflowEvent);
-    }
-    if (typeof opts.taskTraceHook === "function") {
-      this._taskTraceHooks.add(opts.taskTraceHook);
-    }
-    if (Array.isArray(opts.taskTraceHooks)) {
-      for (const hook of opts.taskTraceHooks) {
-        if (typeof hook === "function") this._taskTraceHooks.add(hook);
-      }
-    }
     }
   }
 
@@ -2630,3 +2630,4 @@ export async function executeWorkflow(id, data, opts) { return getWorkflowEngine
 export async function retryWorkflowRun(runId, retryOpts, engineOpts) { return getWorkflowEngine(engineOpts).retryRun(runId, retryOpts); }
 
 
+

package/workflow/workflow-nodes.mjs

@@ -25,6 +25,8 @@ import { randomUUID } from "node:crypto";
 import { getAgentToolConfig, getEffectiveTools } from "../agent/agent-tool-config.mjs";
 import { getToolsPromptBlock } from "../agent/agent-custom-tools.mjs";
 import { buildRelevantSkillsPromptBlock, findRelevantSkills } from "../agent/bosun-skills.mjs";
+import { getSessionTracker } from "../infra/session-tracker.mjs";
+import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
 
 const TAG = "[workflow-nodes]";
 const PORTABLE_WORKTREE_COUNT_COMMAND = "node -e \"const cp=require('node:child_process');const wt=cp.execSync('git worktree list --porcelain',{encoding:'utf8'});const count=(wt.match(/^worktree /gm)||[]).length;process.stdout.write(String(count)+'\\\\n');\"";
@@ -40,6 +42,29 @@ const WORKFLOW_AGENT_EVENT_PREVIEW_LIMIT = (() => {
   return Math.max(20, Math.min(500, Math.trunc(raw)));
 })();
 
+function makeIsolatedGitEnv(extra = {}) {
+  const env = { ...process.env, ...extra };
+  for (const key of [
+    "GIT_DIR",
+    "GIT_WORK_TREE",
+    "GIT_COMMON_DIR",
+    "GIT_INDEX_FILE",
+    "GIT_OBJECT_DIRECTORY",
+    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+    "GIT_PREFIX",
+  ]) {
+    delete env[key];
+  }
+  return env;
+}
+
+function execGitSync(command, options = {}) {
+  return execSync(command, {
+    ...options,
+    env: makeIsolatedGitEnv(options.env),
+  });
+}
+
 function trimLogText(value, max = 180) {
   const text = String(value || "").replace(/\s+/g, " ").trim();
   if (!text) return "";
@@ -1510,6 +1535,20 @@ registerNodeType("action.run_agent", {
     const prompt = ctx.resolve(node.config?.prompt || "");
     const sdk = node.config?.sdk || "auto";
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
+    const trackedTaskId = String(
+      ctx.data?.taskId ||
+        ctx.data?.task?.id ||
+        ctx.data?.taskDetail?.id ||
+        ctx.resolve(node.config?.taskId || "") ||
+        "",
+    ).trim();
+    const trackedTaskTitle = String(
+      ctx.data?.task?.title ||
+        ctx.data?.taskDetail?.title ||
+        ctx.data?.taskInfo?.title ||
+        trackedTaskId ||
+        "",
+    ).trim();
     const agentProfileId = String(
       ctx.resolve(node.config?.agentProfile || ctx.data?.agentProfile || ""),
     ).trim();
@@ -1637,6 +1676,43 @@ registerNodeType("action.run_agent", {
         const maxRetainedEvents = Number.isFinite(Number(node.config?.maxRetainedEvents))
           ? Math.max(10, Math.min(500, Math.trunc(Number(node.config.maxRetainedEvents))))
           : WORKFLOW_AGENT_EVENT_PREVIEW_LIMIT;
+        const tracker = trackedTaskId ? getSessionTracker() : null;
+        const trackedSessionType = trackedTaskId ? "task" : "flow";
+
+        if (tracker && trackedTaskId) {
+          const existing = tracker.getSessionById(trackedTaskId);
+          if (!existing) {
+            tracker.createSession({
+              id: trackedTaskId,
+              type: "task",
+              taskId: trackedTaskId,
+              metadata: {
+                title: trackedTaskTitle || trackedTaskId,
+                workspaceId: String(ctx.data?.workspaceId || ctx.data?.activeWorkspace || "").trim() || undefined,
+                workspaceDir: String(cwd || "").trim() || undefined,
+                branch:
+                  String(
+                    ctx.data?.branch ||
+                      ctx.data?.task?.branchName ||
+                      ctx.data?.taskDetail?.branchName ||
+                      "",
+                  ).trim() || undefined,
+              },
+            });
+          } else {
+            tracker.updateSessionStatus(trackedTaskId, "active");
+            if (trackedTaskTitle) {
+              tracker.renameSession(trackedTaskId, trackedTaskTitle);
+            }
+          }
+          tracker.recordEvent(trackedTaskId, {
+            role: "system",
+            type: "system",
+            content: `Workflow agent run started in ${cwd}`,
+            timestamp: new Date().toISOString(),
+            _sessionType: trackedSessionType,
+          });
+        }
 
         const launchExtra = {};
         if (sessionId) launchExtra.resumeThreadId = sessionId;
@@ -1644,6 +1720,12 @@ registerNodeType("action.run_agent", {
         if (modelOverride) launchExtra.model = modelOverride;
         launchExtra.onEvent = (event) => {
           try {
+            if (tracker && trackedTaskId) {
+              tracker.recordEvent(trackedTaskId, {
+                ...(event && typeof event === "object" ? event : { content: String(event || "") }),
+                _sessionType: trackedSessionType,
+              });
+            }
             const line = summarizeAgentStreamEvent(event);
             if (!line || line === lastStreamLog) return;
             lastStreamLog = line;
@@ -1711,9 +1793,10 @@ registerNodeType("action.run_agent", {
               timeoutMs,
               maxRetries: sessionRetries,
               maxContinues,
-              sessionType: "flow",
+              sessionType: trackedSessionType,
               sdk: sdkOverride,
               model: modelOverride,
+              onEvent: launchExtra.onEvent,
             });
           }
 
@@ -1721,9 +1804,10 @@ registerNodeType("action.run_agent", {
             ctx.log(node.id, `${passLabel} Recovery: launchOrResumeThread taskKey=${recoveryTaskKey}`.trim());
             result = await agentPool.launchOrResumeThread(passPrompt, cwd, timeoutMs, {
               taskKey: recoveryTaskKey,
-              sessionType: "flow",
+              sessionType: trackedSessionType,
               sdk: sdkOverride,
               model: modelOverride,
+              onEvent: launchExtra.onEvent,
             });
           }
 
@@ -1736,6 +1820,24 @@ registerNodeType("action.run_agent", {
         }
         ctx.log(node.id, `${passLabel || "Agent"} completed: success=${success} streamEvents=${streamEventCount}`);
 
+        if (tracker && trackedTaskId) {
+          if (streamEventCount === 0) {
+            const fallbackContent = success
+              ? String(result?.output || result?.message || "Agent run completed.").trim()
+              : String(result?.error || "Agent run failed.").trim();
+            if (fallbackContent) {
+              tracker.recordEvent(trackedTaskId, {
+                role: success ? "assistant" : "system",
+                type: success ? "agent_message" : "error",
+                content: fallbackContent,
+                timestamp: new Date().toISOString(),
+                _sessionType: trackedSessionType,
+              });
+            }
+          }
+          tracker.endSession(trackedTaskId, success ? "completed" : "failed");
+        }
+
         const threadId = result?.threadId || result?.sessionId || sessionId || null;
         if (persistSession && threadId) {
           ctx.data.sessionId = threadId;
@@ -2713,7 +2815,7 @@ registerNodeType("action.update_task_status", {
     required: ["taskId", "status"],
   },
   async execute(node, ctx, engine) {
-    const taskId = ctx.resolve(node.config?.taskId || "");
+    let taskId = ctx.resolve(node.config?.taskId || "");
     const status = node.config?.status;
     const kanban = engine.services?.kanban;
     const workflowEvent = ctx.resolve(node.config?.workflowEvent || "");
@@ -2732,6 +2834,29 @@ registerNodeType("action.update_task_status", {
     if (workflowData) updateOptions.workflowData = workflowData;
     if (workflowDedupKey) updateOptions.workflowDedupKey = workflowDedupKey;
 
+    if (isUnresolvedTemplateToken(taskId)) {
+      const fallbackTaskId =
+        ctx.data?.taskId ||
+        ctx.data?.task?.id ||
+        ctx.data?.task_id ||
+        "";
+      if (fallbackTaskId && !isUnresolvedTemplateToken(fallbackTaskId)) {
+        taskId = String(fallbackTaskId);
+      }
+    }
+
+    if (!taskId || isUnresolvedTemplateToken(taskId)) {
+      const unresolvedValue = String(taskId || node.config?.taskId || "(empty)");
+      ctx.log(node.id, `Skipping update_task_status due unresolved taskId: ${unresolvedValue}`);
+      return {
+        success: false,
+        skipped: true,
+        error: "unresolved_task_id",
+        taskId: unresolvedValue,
+        status,
+      };
+    }
+
     if (kanban?.updateTaskStatus) {
       await kanban.updateTaskStatus(taskId, status, updateOptions);
       bindTaskContext(ctx, {
@@ -2897,7 +3022,8 @@ registerNodeType("action.create_pr", {
     // Build gh pr create command
     const args = ["gh", "pr", "create"];
     args.push("--title", JSON.stringify(title));
-    if (body) args.push("--body", JSON.stringify(body));
+    // gh pr create requires either --body (empty is allowed) or --fill* in non-interactive mode.
+    args.push("--body", JSON.stringify(String(body)));
     if (base) args.push("--base", base);
     if (branch) args.push("--head", branch);
     if (draft) args.push("--draft");
@@ -6893,6 +7019,7 @@ registerNodeType("transform.mcp_extract", {
 
 /** Module-scope lazy caches for task lifecycle imports. */
 let _taskClaimsMod = null;
+let _taskClaimsInitPromise = null;
 let _taskComplexityMod = null;
 let _kanbanAdapterMod = null;
 let _agentPoolMod = null;
@@ -6903,6 +7030,46 @@ async function ensureTaskClaimsMod() {
   if (!_taskClaimsMod) _taskClaimsMod = await import("../task/task-claims.mjs");
   return _taskClaimsMod;
 }
+function pickTaskString(...values) {
+  for (const value of values) {
+    const normalized = String(value || "").trim();
+    if (normalized) return normalized;
+  }
+  return "";
+}
+function deriveTaskBranch(task = {}) {
+  const explicit = pickTaskString(
+    task?.branch,
+    task?.branchName,
+    task?.meta?.branch,
+    task?.metadata?.branch,
+  );
+  if (explicit) return explicit;
+  const taskId = pickTaskString(task?.id, task?.task_id).replace(/[^a-zA-Z0-9]/g, "").slice(0, 12);
+  const titleSlug = pickTaskString(task?.title, "task")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+  const suffix = titleSlug || "task";
+  if (taskId) return `task/${taskId}-${suffix}`;
+  return `task/${suffix}`;
+}
+async function ensureTaskClaimsInitialized(ctx, claims) {
+  if (typeof claims?.initTaskClaims !== "function") return;
+  if (!_taskClaimsInitPromise) {
+    const repoRoot = pickTaskString(
+      ctx?.data?.repoRoot,
+      ctx?.data?.workspace,
+      process.cwd(),
+    );
+    _taskClaimsInitPromise = claims.initTaskClaims({ repoRoot }).catch((err) => {
+      _taskClaimsInitPromise = null;
+      throw err;
+    });
+  }
+  await _taskClaimsInitPromise;
+}
 async function ensureTaskComplexityMod() {
   if (!_taskComplexityMod) _taskComplexityMod = await import("../task/task-complexity.mjs");
   return _taskComplexityMod;
@@ -6937,6 +7104,7 @@ function normalizeCanStartGuardResult(raw) {
       blockingTaskIds: [],
       missingDependencyTaskIds: [],
       blockingSprintIds: [],
+      blockingEpicIds: [],
     };
   }
   const data = raw && typeof raw === "object" ? raw : {};
@@ -6947,11 +7115,11 @@ function normalizeCanStartGuardResult(raw) {
     blockingTaskIds: Array.isArray(data.blockingTaskIds) ? data.blockingTaskIds : [],
     missingDependencyTaskIds: Array.isArray(data.missingDependencyTaskIds) ? data.missingDependencyTaskIds : [],
     blockingSprintIds: Array.isArray(data.blockingSprintIds) ? data.blockingSprintIds : [],
+    blockingEpicIds: Array.isArray(data.blockingEpicIds) ? data.blockingEpicIds : [],
     sprintOrderMode: data.sprintOrderMode || null,
     sprintTaskOrderMode: data.sprintTaskOrderMode || null,
   };
 }
-
 /** Resolve a config value, falling back to ctx.data, then defaultVal. */
 function cfgOrCtx(node, ctx, key, defaultVal = "") {
   const raw = node.config?.[key];
@@ -6961,6 +7129,48 @@ function cfgOrCtx(node, ctx, key, defaultVal = "") {
   return defaultVal;
 }
 
+function getWorkflowRuntimeState(ctx) {
+  if (!ctx || typeof ctx !== "object") return {};
+  if (!ctx.__workflowRuntimeState || typeof ctx.__workflowRuntimeState !== "object") {
+    ctx.__workflowRuntimeState = {};
+  }
+  return ctx.__workflowRuntimeState;
+}
+
+function isUnresolvedTemplateToken(value) {
+  return /{{[^{}]+}}/.test(String(value || ""));
+}
+
+function normalizeGitRefValue(value) {
+  const text = String(value ?? "").trim();
+  if (!text || isUnresolvedTemplateToken(text)) return "";
+  const lowered = text.toLowerCase();
+  if (lowered === "null" || lowered === "undefined") return "";
+  return text;
+}
+
+function pickGitRef(...candidates) {
+  for (const candidate of candidates) {
+    const normalized = normalizeGitRefValue(candidate);
+    if (normalized) return normalized;
+  }
+  return "";
+}
+
+function formatExecSyncError(err) {
+  if (!err) return "unknown error";
+  const detail = [err?.stderr, err?.stdout, err?.message]
+    .map((entry) => String(entry || "").trim())
+    .filter(Boolean)
+    .join(" | ");
+  return trimLogText(detail || String(err?.message || err), 420);
+}
+
+function isExistingBranchWorktreeError(err) {
+  const detail = formatExecSyncError(err).toLowerCase();
+  return detail.includes("already exists") || detail.includes("is already checked out");
+}
+
 /**
  * Anti-thrash state — module-scope to survive across workflow runs.
  * Mirrors TaskExecutor._noCommitCounts / _skipUntil / _completedWithPR.
@@ -7153,6 +7363,7 @@ registerNodeType("trigger.task_available", {
               blockingTaskIds: guard.blockingTaskIds,
               missingDependencyTaskIds: guard.missingDependencyTaskIds,
               blockingSprintIds: guard.blockingSprintIds,
+              blockingEpicIds: guard.blockingEpicIds,
               sprintOrderMode: guard.sprintOrderMode,
               sprintTaskOrderMode: guard.sprintTaskOrderMode,
               strict: Boolean(taskNotFound && strictStartGuardMissingTask),
@@ -7254,12 +7465,54 @@ registerNodeType("trigger.task_available", {
       }
     }
 
+    const primaryTask = toDispatch[0] || null;
+    if (primaryTask) {
+      const taskId = pickTaskString(primaryTask.id, primaryTask.task_id);
+      const taskTitle = pickTaskString(primaryTask.title, primaryTask.task_title);
+      bindTaskContext(ctx, { taskId, taskTitle, task: primaryTask });
+      const taskDescription = pickTaskString(
+        primaryTask.description,
+        primaryTask.task_description,
+      );
+      if (taskDescription) ctx.data.taskDescription = taskDescription;
+      const taskWorkspace = pickTaskString(
+        primaryTask.workspace,
+        primaryTask.workspacePath,
+        primaryTask.meta?.workspace,
+        primaryTask.metadata?.workspace,
+      );
+      if (taskWorkspace) {
+        ctx.data.workspace = taskWorkspace;
+        if (!pickTaskString(ctx.data.repoRoot)) {
+          ctx.data.repoRoot = taskWorkspace;
+        }
+      }
+      const taskRepository = pickTaskString(
+        primaryTask.repository,
+        primaryTask.repo,
+        primaryTask.meta?.repository,
+        primaryTask.metadata?.repository,
+      );
+      if (taskRepository) ctx.data.repository = taskRepository;
+      const taskRepositories = Array.isArray(primaryTask.repositories)
+        ? primaryTask.repositories
+        : [];
+      if (taskRepositories.length > 0) {
+        ctx.data.repositories = taskRepositories;
+      }
+      const baseBranch = pickTaskString(primaryTask.baseBranch, primaryTask.base_branch);
+      if (baseBranch) ctx.data.baseBranch = baseBranch;
+      const branch = deriveTaskBranch(primaryTask);
+      if (branch) ctx.data.branch = branch;
+    }
+
     ctx.log(node.id, `Found ${toDispatch.length} task(s) ready (${remaining} slot(s) free)`);
     return {
       triggered: true,
       tasks: toDispatch,
       taskCount: toDispatch.length,
       availableSlots: remaining,
+      selectedTaskId: primaryTask ? pickTaskString(primaryTask.id, primaryTask.task_id) : "",
       auditEvents: startGuardAuditEvents,
     };
   },
@@ -7426,6 +7679,12 @@ registerNodeType("action.claim_task", {
     if (!taskId) throw new Error("action.claim_task: taskId is required");
 
     const claims = await ensureTaskClaimsMod();
+    try {
+      await ensureTaskClaimsInitialized(ctx, claims);
+    } catch (initErr) {
+      ctx.log(node.id, `Claim init failed: ${initErr.message}`);
+      return { success: false, error: initErr.message, taskId, alreadyClaimed: false };
+    }
 
     let claimResult;
     try {
@@ -7452,11 +7711,18 @@ registerNodeType("action.claim_task", {
       ctx.data._claimToken = token;
       ctx.data._claimInstanceId = instanceId;
 
-      // Start renewal timer (stored in ctx for cleanup by release_claim)
-      if (renewIntervalMs > 0 && claims.renewTaskClaim) {
+      const runtimeState = getWorkflowRuntimeState(ctx);
+      // Start renewal timer (stored in non-serializable runtime state for cleanup by release_claim)
+      const renewClaimFn =
+        typeof claims.renewTaskClaim === "function"
+          ? claims.renewTaskClaim.bind(claims)
+          : typeof claims.renewClaim === "function"
+            ? claims.renewClaim.bind(claims)
+            : null;
+      if (renewIntervalMs > 0 && renewClaimFn) {
         const renewTimer = setInterval(async () => {
           try {
-            await claims.renewTaskClaim({ taskId, claimToken: token, instanceId, ttlMinutes });
+            await renewClaimFn({ taskId, claimToken: token, instanceId, ttlMinutes });
           } catch (renewErr) {
             const msg = renewErr?.message || String(renewErr);
             const fatal = ["claimed_by_different_instance", "claim_token_mismatch",
@@ -7464,6 +7730,7 @@ registerNodeType("action.claim_task", {
             if (fatal) {
               ctx.log(node.id, `Claim renewal fatal: ${msg} — aborting task`);
               clearInterval(renewTimer);
+              runtimeState.claimRenewTimer = null;
               ctx.data._claimRenewTimer = null;
               // Signal abort to downstream nodes via context
               ctx.data._claimStolen = true;
@@ -7474,7 +7741,9 @@ registerNodeType("action.claim_task", {
         }, renewIntervalMs);
         // Prevent timer from keeping the process alive
         if (renewTimer.unref) renewTimer.unref();
-        ctx.data._claimRenewTimer = renewTimer;
+        runtimeState.claimRenewTimer = renewTimer;
+        // Keep serialized context JSON-safe.
+        ctx.data._claimRenewTimer = null;
       }
 
       ctx.log(node.id, `Task "${taskTitle}" claimed (ttl=${ttlMinutes}min, renew=${renewIntervalMs}ms)`);
@@ -7510,11 +7779,14 @@ registerNodeType("action.release_claim", {
     const claimToken = cfgOrCtx(node, ctx, "claimToken") || ctx.data?._claimToken || "";
     const instanceId = cfgOrCtx(node, ctx, "instanceId") || ctx.data?._claimInstanceId || "";
 
-    // Always cancel the renewal timer first
-    if (ctx.data?._claimRenewTimer) {
-      try { clearInterval(ctx.data._claimRenewTimer); } catch { /* ok */ }
-      ctx.data._claimRenewTimer = null;
+    // Always cancel the renewal timer first.
+    const runtimeState = getWorkflowRuntimeState(ctx);
+    const renewTimer = runtimeState.claimRenewTimer || ctx.data?._claimRenewTimer;
+    if (renewTimer) {
+      try { clearInterval(renewTimer); } catch { /* ok */ }
     }
+    runtimeState.claimRenewTimer = null;
+    ctx.data._claimRenewTimer = null;
 
     if (!taskId || !claimToken) {
       ctx.log(node.id, `No claim to release for ${taskId || "(unknown)"}`);
@@ -7523,7 +7795,22 @@ registerNodeType("action.release_claim", {
 
     const claims = await ensureTaskClaimsMod();
     try {
-      await claims.releaseTaskClaim({ taskId, claimToken, instanceId });
+      await ensureTaskClaimsInitialized(ctx, claims);
+    } catch (initErr) {
+      ctx.log(node.id, `Claim release init warning: ${initErr.message}`);
+      ctx.data._claimToken = null;
+      ctx.data._claimInstanceId = null;
+      return { success: true, taskId, warning: initErr.message };
+    }
+    const releaseClaimFn =
+      typeof claims.releaseTaskClaim === "function"
+        ? claims.releaseTaskClaim.bind(claims)
+        : typeof claims.releaseTask === "function"
+          ? claims.releaseTask.bind(claims)
+          : null;
+    try {
+      if (!releaseClaimFn) throw new Error("no claim release function available");
+      await releaseClaimFn({ taskId, claimToken, instanceId });
       ctx.data._claimToken = null;
       ctx.data._claimInstanceId = null;
       ctx.log(node.id, `Claim released for ${taskId}`);
@@ -7642,7 +7929,9 @@ registerNodeType("action.acquire_worktree", {
     const taskId = cfgOrCtx(node, ctx, "taskId");
     const branch = cfgOrCtx(node, ctx, "branch");
     const repoRoot = cfgOrCtx(node, ctx, "repoRoot") || process.cwd();
-    const baseBranch = cfgOrCtx(node, ctx, "baseBranch", "origin/main");
+    const baseBranchRaw = cfgOrCtx(node, ctx, "baseBranch", "origin/main");
+    const defaultTargetBranch = cfgOrCtx(node, ctx, "defaultTargetBranch", "origin/main");
+    const baseBranch = pickGitRef(baseBranchRaw, defaultTargetBranch, "origin/main", "main");
     const fetchTimeout = node.config?.fetchTimeout ?? 30000;
     const worktreeTimeout = node.config?.worktreeTimeout ?? 60000;
 
@@ -7699,17 +7988,24 @@ registerNodeType("action.acquire_worktree", {
           `git worktree add "${worktreePath}" -b "${branch}" "${baseBranch}" 2>&1`,
           { cwd: repoRoot, encoding: "utf8", timeout: worktreeTimeout },
         );
-      } catch {
-        // Branch may already exist — try checkout
+      } catch (createErr) {
+        if (!isExistingBranchWorktreeError(createErr)) {
+          throw new Error(`Worktree creation failed: ${formatExecSyncError(createErr)}`);
+        }
+        // Branch already exists — attach worktree to existing branch.
         try {
           execSync(
             `git worktree add "${worktreePath}" "${branch}" 2>&1`,
             { cwd: repoRoot, encoding: "utf8", timeout: worktreeTimeout },
           );
-        } catch (err2) {
-          throw new Error(`Worktree creation failed: ${err2.message}`);
+        } catch (reuseErr) {
+          throw new Error(
+            `Worktree creation failed: ${formatExecSyncError(createErr)}; ` +
+            `reuse failed: ${formatExecSyncError(reuseErr)}`,
+          );
         }
       }
+      fixGitConfigCorruption(repoRoot);
 
       ctx.data.worktreePath = worktreePath;
       ctx.data._worktreeCreated = true;
@@ -8104,7 +8400,7 @@ registerNodeType("action.detect_new_commits", {
     // Get current HEAD
     let postExecHead = "";
     try {
-      postExecHead = execSync("git rev-parse HEAD", {
+      postExecHead = execGitSync("git rev-parse HEAD", {
         cwd: worktreePath, encoding: "utf8", timeout: 5000,
       }).trim();
     } catch (err) {
@@ -8118,7 +8414,7 @@ registerNodeType("action.detect_new_commits", {
     let hasUnpushed = false;
     let commitCount = 0;
     try {
-      const log = execSync(`git log --oneline ${baseBranch}..HEAD`, {
+      const log = execGitSync(`git log --oneline ${baseBranch}..HEAD`, {
         cwd: worktreePath, encoding: "utf8", timeout: 10000,
         stdio: ["ignore", "pipe", "pipe"],
       }).trim();
@@ -8132,7 +8428,7 @@ registerNodeType("action.detect_new_commits", {
     let diffStats = null;
     if (hasNewCommits || hasUnpushed) {
       try {
-        const statOutput = execSync(`git diff --stat ${baseBranch}..HEAD`, {
+        const statOutput = execGitSync(`git diff --stat ${baseBranch}..HEAD`, {
           cwd: worktreePath, encoding: "utf8", timeout: 10000,
           stdio: ["ignore", "pipe", "pipe"],
         }).trim();
@@ -8502,3 +8798,6 @@ registerNodeType("action.web_search", {
 // ═══════════════════════════════════════════════════════════════════════════
 
 export { registerNodeType, getNodeType, listNodeTypes } from "./workflow-engine.mjs";
+
+
+

package/workflow/workflow-templates.mjs

@@ -575,7 +575,7 @@ export const WORKFLOW_SETUP_PROFILES = Object.freeze({
       "template-task-batch-processor",
     ]),
   }),
-  workflowFirst: Object.freeze({
+  workflowfirst: Object.freeze({
     id: "workflowFirst",
     name: "Workflow-First (Full)",
     description: