bosun 0.40.2 → 0.40.3

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);
@@ -2630,3 +2654,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

@@ -2897,7 +2897,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 +6894,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 +6905,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 +6979,7 @@ function normalizeCanStartGuardResult(raw) {
       blockingTaskIds: [],
       missingDependencyTaskIds: [],
       blockingSprintIds: [],
+      blockingEpicIds: [],
     };
   }
   const data = raw && typeof raw === "object" ? raw : {};
@@ -6947,11 +6990,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];
@@ -7153,6 +7196,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 +7298,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 +7512,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 {
@@ -7522,6 +7614,14 @@ registerNodeType("action.release_claim", {
     }
 
     const claims = await ensureTaskClaimsMod();
+    try {
+      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 };
+    }
     try {
       await claims.releaseTaskClaim({ taskId, claimToken, instanceId });
       ctx.data._claimToken = null;

package/workspace/workspace-manager.mjs

@@ -44,6 +44,14 @@ function getChildProcess() {
   return _childProcessModule;
 }
 
+function sanitizeGitProcessEnv(baseEnv = process.env) {
+  const env = { ...baseEnv };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  return env;
+}
+
 // Lazy-loaded reference to repo-config.mjs (resolved on first use)
 let _repoConfigModule = null;
 
@@ -247,6 +255,7 @@ function cloneIntoExistingRepoPath(childProcess, repoUrl, repoPath) {
     timeout: 300000,
     stdio: ["pipe", "pipe", "pipe"],
     cwd: repoPath,
+    env: sanitizeGitProcessEnv(),
   });
 }
 
@@ -321,6 +330,7 @@ function buildGitPullFailureDetails(err, repoPath, childProcess) {
           encoding: "utf8",
           timeout: 10_000,
           stdio: ["pipe", "pipe", "pipe"],
+          env: sanitizeGitProcessEnv(),
         }),
       );
       if (statusOut) {
@@ -571,6 +581,7 @@ export function addRepoToWorkspace(configDir, workspaceId, { url, name, branch,
       encoding: "utf8",
       timeout: 300000, // 5 minutes
       stdio: ["pipe", "pipe", "pipe"],
+      env: sanitizeGitProcessEnv(),
     });
 
     if (result.status !== 0) {
@@ -698,6 +709,7 @@ export function pullWorkspaceRepos(configDir, workspaceId) {
           encoding: "utf8",
           timeout: 300000,
           stdio: ["pipe", "pipe", "pipe"],
+          env: sanitizeGitProcessEnv(),
         });
         if (clone.status !== 0) {
           const stderr = String(clone.stderr || clone.stdout || "");
@@ -787,6 +799,7 @@ export function pullWorkspaceRepos(configDir, workspaceId) {
         encoding: "utf8",
         timeout: 120000,
         stdio: ["pipe", "pipe", "pipe"],
+        env: sanitizeGitProcessEnv(),
       });
       results.push({ name: repo.name, success: true });
     } catch (err) {
@@ -939,6 +952,7 @@ export function detectWorkspaces(configDir) {
             encoding: "utf8",
             timeout: 3000,
             stdio: ["pipe", "pipe", "ignore"],
+            env: sanitizeGitProcessEnv(),
           }).trim();
           slug = extractSlug(remote);
         } catch { /* no remote */ }

package/workspace/worktree-manager.mjs

@@ -65,7 +65,7 @@ const GIT_ENV = {
  */
 function fixGitConfigCorruption(repoRoot) {
   try {
-    const bareResult = spawnSync("git", ["config", "--local", "core.bare"], {
+    const bareResult = spawnSync("git", ["config", "--bool", "--get", "core.bare"], {
       cwd: repoRoot,
       encoding: "utf8",
       timeout: 5000,
@@ -75,7 +75,7 @@ function fixGitConfigCorruption(repoRoot) {
       console.warn(
         `${TAG} :alert: Detected core.bare=true on main repo — fixing git config corruption`,
       );
-      spawnSync("git", ["config", "--unset", "core.bare"], {
+      spawnSync("git", ["config", "--local", "core.bare", "false"], {
         cwd: repoRoot,
         encoding: "utf8",
         timeout: 5000,