bosun 0.40.3 → 0.40.4

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, {
@@ -7004,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.
@@ -7544,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",
@@ -7556,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;
@@ -7566,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)`);
@@ -7602,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)"}`);
@@ -7622,8 +7802,15 @@ registerNodeType("action.release_claim", {
       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 {
-      await claims.releaseTaskClaim({ taskId, claimToken, instanceId });
+      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}`);
@@ -7742,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;
 
@@ -7799,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;
@@ -8204,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) {
@@ -8218,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();
@@ -8232,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();
@@ -8602,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:

package/workflow-templates/task-batch.mjs

@@ -10,7 +10,7 @@
  *   - TASK_BATCH_PR_TEMPLATE (batch → agent → PR shortcut)
  *
  * DAG overview:
- *   trigger.task_low
+ *   trigger.task_available
  *     → condition.expression (is coordinator or solo?)
  *       → action.run_command (list todo tasks)
  *         → loop.for_each (fan-out, maxConcurrent tasks at a time)
@@ -38,9 +38,8 @@ export const TASK_BATCH_PROCESSOR_TEMPLATE = {
   category: "lifecycle",
   enabled: true,
   recommended: true,
-  trigger: "trigger.task_low",
+  trigger: "trigger.task_available",
   variables: {
-    backlogThreshold: 3,
     maxConcurrent: 3,
     pollStatus: "todo",
     maxBatchSize: 10,
@@ -48,9 +47,10 @@ export const TASK_BATCH_PROCESSOR_TEMPLATE = {
     notifyChannel: "telegram",
   },
   nodes: [
-    // ── Trigger: Backlog drops below threshold ───────────────────────────
-    node("trigger", "trigger.task_low", "Backlog Low?", {
-      threshold: "{{backlogThreshold}}",
+    // ── Trigger: Tasks available for processing ──────────────────────────
+    node("trigger", "trigger.task_available", "Tasks Available?", {
+      maxParallel: "{{maxConcurrent}}",
+      pollIntervalMs: 60000,
       status: "{{pollStatus}}",
     }, { x: 400, y: 50 }),
 
@@ -141,9 +141,8 @@ export const TASK_BATCH_PR_TEMPLATE = {
   category: "lifecycle",
   enabled: true,
   recommended: false,
-  trigger: "trigger.task_low",
+  trigger: "trigger.task_available",
   variables: {
-    backlogThreshold: 3,
     maxConcurrent: 2,
     pollStatus: "todo",
     maxBatchSize: 5,
@@ -153,8 +152,9 @@ export const TASK_BATCH_PR_TEMPLATE = {
   },
   nodes: [
     // ── Trigger ──────────────────────────────────────────────────────────
-    node("trigger", "trigger.task_low", "Backlog Low?", {
-      threshold: "{{backlogThreshold}}",
+    node("trigger", "trigger.task_available", "Tasks Available?", {
+      maxParallel: "{{maxConcurrent}}",
+      pollIntervalMs: 60000,
       status: "{{pollStatus}}",
     }, { x: 400, y: 50 }),
 

package/workspace/workspace-manager.mjs

@@ -403,6 +403,16 @@ export function listWorkspaces(configDir, opts = {}) {
       const standardExists = existsSync(standardPath);
       let effectivePath = standardPath;
       let exists = standardExists;
+      const repoUrlRaw = String(repo.url || "").trim();
+      const looksLikeRemoteUrl =
+        /^https?:\/\//i.test(repoUrlRaw) ||
+        /^git@[^:]+:/i.test(repoUrlRaw) ||
+        /^ssh:\/\//i.test(repoUrlRaw);
+      const repoUrlPath = repoUrlRaw && !looksLikeRemoteUrl ? resolve(repoUrlRaw) : null;
+      if (!standardExists && repoUrlPath && existsSync(repoUrlPath)) {
+        effectivePath = repoUrlPath;
+        exists = true;
+      }
       if (!standardExists && repoRootOverride) {
         const altPath = resolve(repoRootOverride, repo.name);
         if (existsSync(altPath)) {
@@ -1000,3 +1010,4 @@ export function initializeWorkspaces(configDir, opts = {}) {
 
   return { workspaces: [], isNew: true };
 }
+

package/workspace/worktree-manager.mjs

@@ -81,6 +81,12 @@ function fixGitConfigCorruption(repoRoot) {
         timeout: 5000,
         env: { ...process.env, ...GIT_ENV },
       });
+      spawnSync("git", ["config", "--local", "--unset-all", "core.worktree"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        timeout: 5000,
+        env: { ...process.env, ...GIT_ENV },
+      });
     }
   } catch {
     /* best-effort — don't crash on config repair */