bosun 0.37.1 → 0.37.2

package/workflow-templates/github.mjs

@@ -244,14 +244,26 @@ export const PR_TRIAGE_TEMPLATE = {
       command: "gh pr edit {{prNumber}} --add-label \"size/L\"",
     }, { x: 650, y: 480 }),
 
-    node("detect-breaking", "action.run_agent", "Detect Breaking Changes", {
-      prompt: "Analyze the diff for PR #{{prNumber}} and determine if there are any breaking changes. Respond with JSON: { \"breaking\": true/false, \"reason\": \"...\" }",
-      timeoutMs: 300000,
+    node("detect-breaking", "condition.expression", "Detect Breaking Changes", {
+      expression:
+        "(() => {" +
+        "  const raw=$ctx.getNodeOutput('get-stats')?.output||'{}';" +
+        "  let stats={};" +
+        "  try{stats=typeof raw==='string'?JSON.parse(raw):raw;}catch{return false;}" +
+        "  const title=String(stats?.title||'').toLowerCase();" +
+        "  const body=String(stats?.body||'').toLowerCase();" +
+        "  const files=Array.isArray(stats?.files)?stats.files.map((f)=>String(f?.path||f?.filename||f||'').toLowerCase()):[];" +
+        "  const text=title+'\\n'+body;" +
+        "  const explicit=/\\bbreaking\\b|\\bbreaking change\\b|\\bmajor\\b|\\bbackward incompatible\\b/.test(text);" +
+        "  const apiTouch=files.some((f)=>f.includes('api/')||f.includes('/proto/')||f.includes('openapi')||f.includes('schema'));" +
+        "  const contractWords=/\\bremove\\b|\\brename\\b|\\bdeprecate\\b|\\bdrop\\b/.test(text);" +
+        "  return explicit || (apiTouch && contractWords);" +
+        "})()",
     }, { x: 400, y: 630 }),
 
     node("is-breaking", "condition.expression", "Breaking?", {
       expression:
-        "(() => { const raw = $ctx.getNodeOutput('detect-breaking')?.output || '{}'; try { const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw; return parsed?.breaking === true; } catch { return /\"breaking\"\\s*:\\s*true/i.test(String(raw)); } })()",
+        "(() => { return $ctx.getNodeOutput('detect-breaking')?.result === true; })()",
     }, { x: 400, y: 780, outputs: ["yes", "no"] }),
 
     node("label-breaking", "action.run_command", "Label: Breaking", {
@@ -876,43 +888,73 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
         "}catch(e){return false;}})()",
     }, { x: 200, y: 530 }),
 
-    node("dispatch-fix", "action.run_agent", "Dispatch Fix Agent", {
+    node("programmatic-fix", "action.run_command", "Programmatic Fix Pass", {
+      command: [
+        "node -e \"",
+        "const {execFileSync}=require('child_process');",
+        "const raw=String(process.env.BOSUN_FETCH_AND_CLASSIFY||'');",
+        "const payload=(()=>{try{return JSON.parse(raw||'{}')}catch{return {}}})();",
+        "const ciFailures=Array.isArray(payload.ciFailures)?payload.ciFailures:[];",
+        "const conflicts=Array.isArray(payload.conflicts)?payload.conflicts:[];",
+        "const needsAgent=[];",
+        "let rerunRequested=0;",
+        "function runGh(args){return execFileSync('gh',args,{encoding:'utf8',stdio:['pipe','pipe','pipe']}).trim();}",
+        "for(const item of ciFailures){",
+        "  const repo=String(item?.repo||'').trim();",
+        "  const branch=String(item?.branch||'').trim();",
+        "  const n=String(item?.n||'').trim();",
+        "  if(!repo||!branch){needsAgent.push({repo,number:n,reason:'missing_repo_or_branch'});continue;}",
+        "  try{",
+        "    const listRaw=runGh(['run','list','--repo',repo,'--branch',branch,'--json','databaseId,conclusion,status','--limit','8']);",
+        "    const runs=(()=>{try{return JSON.parse(listRaw||'[]')}catch{return []}})();",
+        "    const failed=(Array.isArray(runs)?runs:[]).find((r)=>{",
+        "      const c=String(r?.conclusion||'').toUpperCase();",
+        "      return c==='FAILURE'||c==='ERROR'||c==='TIMED_OUT'||c==='CANCELLED';",
+        "    });",
+        "    if(failed?.databaseId){runGh(['run','rerun',String(failed.databaseId),'--repo',repo]);rerunRequested++;}",
+        "    else{needsAgent.push({repo,number:n,reason:'no_rerunnable_failed_run_found'});}",
+        "  }catch(e){needsAgent.push({repo,number:n,reason:'ci_rerun_failed',error:String(e?.message||e)});}",
+        "}",
+        "for(const item of conflicts){",
+        "  needsAgent.push({repo:String(item?.repo||'').trim(),number:String(item?.n||'').trim(),branch:String(item?.branch||'').trim(),base:String(item?.base||'').trim(),reason:'merge_conflict_requires_code_resolution'});",
+        "}",
+        "console.log(JSON.stringify({rerunRequested,ciFailureCount:ciFailures.length,conflictCount:conflicts.length,needsAgentCount:needsAgent.length,needsAgent}));",
+        "\"",
+      ].join(" "),
+      continueOnError: true,
+      failOnError: false,
+      env: {
+        BOSUN_FETCH_AND_CLASSIFY:
+          "(()=>{const r=$ctx.getNodeOutput('fetch-and-classify');return r&&r.success!==false?String(r.output||'{}'):'{}';})()",
+      },
+    }, { x: 200, y: 640 }),
+
+    node("fix-agent-needed", "condition.expression", "Needs Agent Fix?", {
+      expression:
+        "(()=>{try{" +
+        "const o=$ctx.getNodeOutput('programmatic-fix')?.output;" +
+        "return (JSON.parse(o||'{}').needsAgentCount||0)>0;" +
+        "}catch(e){return false;}})()",
+    }, { x: 200, y: 750 }),
+
+    node("dispatch-fix-agent", "action.run_agent", "Dispatch Fix Agent (Fallback)", {
       prompt:
-        "You are a Bosun PR repair agent. A watchdog workflow has identified " +
-        "bosun-attached PRs that need fixing.\n\n" +
-        "For EACH target repo, list PRs needing work. Always include --repo <owner/repo>.\n" +
-        "Example:\n" +
-        "  gh pr list --repo <owner/repo> --label bosun-needs-fix --label bosun-attached --state open \\\n" +
-        "    --json number,title,headRefName,baseRefName,mergeable,statusCheckRollup,labels,url \\\n" +
-        "    --limit 10\n\n" +
-        "For each PR returned, follow the appropriate path:\n\n" +
-        "CONFLICT (mergeable is CONFLICTING, BEHIND, or DIRTY):\n" +
-        "1. git fetch origin\n" +
-        "2. git checkout <headRefName>\n" +
-        "3. git rebase origin/<baseRefName>  (or git merge origin/<baseRefName> if rebase is too complex)\n" +
-        "4. Resolve merge conflicts, preserving the intent of both sides.\n" +
-        "5. Run the repo's build + test suite to confirm nothing is broken.\n" +
-        "6. git push --force-with-lease origin <headRefName>\n\n" +
-        "CI FAILURE (statusCheckRollup has FAILURE/ERROR/TIMED_OUT entries):\n" +
-        "1. git checkout <headRefName>\n" +
-        "2. Inspect CI logs: gh run list --repo <owner/repo> --branch <headRefName> --limit 3\n" +
-        "   Then: gh run view <run-id> --repo <owner/repo> --log-failed\n" +
-        "3. Fix the root cause (lint, type error, failing test, build error).\n" +
-        "4. Commit: fix(<scope>): <description>  (conventional commit format)\n" +
-        "5. Push the branch — CI will re-trigger automatically.\n\n" +
-        "AFTER fixing either type:\n" +
-        "- Remove the bosun-needs-fix label: gh pr edit <number> --repo <owner/repo> --remove-label bosun-needs-fix\n\n" +
+        "You are a Bosun PR repair fallback agent. A deterministic CLI fix pass has already run. " +
+        "Only work unresolved items from this JSON:\n\n" +
+        "{{$ctx.getNodeOutput('programmatic-fix')?.output}}\n\n" +
+        "For conflict items: rebase/merge branch onto base, resolve conflicts, run tests, push with --force-with-lease if needed.\n" +
+        "For CI-failure items: inspect failed logs, apply minimal fix, commit and push.\n" +
+        "After successful repair remove bosun-needs-fix label.\n\n" +
         "STRICT RULES:\n" +
-        "- Fix only what breaks CI or causes the conflict. No scope creep.\n" +
-        "- Do NOT merge, close, or approve any PR.\n" +
-        "- Do NOT touch PRs that do not have the bosun-attached label.\n" +
-        "- If a conflict cannot be resolved cleanly, leave it labeled and add a comment explaining why.",
+        "- Fix only CI/conflict issues. No scope creep.\n" +
+        "- Do NOT merge/close/approve PRs.\n" +
+        "- Do NOT touch PRs without bosun-attached.",
       sdk: "auto",
       timeoutMs: 1_800_000,
       maxRetries: 2,
       retryDelayMs: 30_000,
       continueOnError: true,
-    }, { x: 200, y: 700 }),
+    }, { x: 200, y: 860 }),
 
     // ─────────────────────────────────────────────────────────────────────────
     // STEP 2b: Review gate — MANDATORY before any merge.
@@ -927,50 +969,65 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
         "}catch(e){return false;}})()",
     }, { x: 600, y: 530 }),
 
-    node("dispatch-review", "action.run_agent", "Review Gate: Inspect & Merge", {
-      prompt:
-        "You are the Bosun PR merge review agent — the LAST LINE OF DEFENCE before " +
-        "any PR is merged. Your job is to inspect each merge candidate and decide " +
-        "whether it is safe to merge.\n\n" +
-        "MERGE CANDIDATES (CI passing, no conflicts, bosun-attached):\n" +
-        "  Run per target repo: gh pr list --repo <owner/repo> --label bosun-attached --state open \\\n" +
-        "    --json number,title,headRefName,isDraft,statusCheckRollup,labels,url \\\n" +
-        "    --limit {{maxPrs}}\n" +
-        "  Filter to PRs where: not isDraft, CI all-passing, no bosun-needs-fix label.\n\n" +
-        "FOR EACH CANDIDATE — before merging, run:\n" +
-        "  gh pr view <number> --repo <owner/repo> --json number,title,additions,deletions,changedFiles,body,baseRefName\n\n" +
-        "SAFETY CHECKS (ALL must pass before merging):\n\n" +
-        "1. DESTRUCTIVE DIFF CHECK:\n" +
-        "   If (deletions > additions × {{suspiciousDeletionRatio}}) AND (deletions > {{minDestructiveDeletions}}):\n" +
-        "   → This PR deletes far more than it adds — HOLD IT.\n" +
-        "   → Run: gh pr edit <number> --repo <owner/repo> --add-label {{labelNeedsReview}}\n" +
-        "   → Run: gh pr comment <number> --repo <owner/repo> --body ':alert: **Bosun Review Agent: merge held** — " +
-        "This PR deletes significantly more lines than it adds (deletions: <X>, additions: <Y>). " +
-        "A human should verify this is intentional before merging.'\n" +
-        "   → Do NOT merge this PR. Move to next candidate.\n\n" +
-        "2. DIFF SANITY CHECK (for PRs that pass the ratio check):\n" +
-        "   Run: gh pr diff <number> --repo <owner/repo> | head -200\n" +
-        "   Look for: mass file deletions, removal of entire modules/directories, " +
-        "   files changed that are unrelated to the PR description.\n" +
-        "   If something looks wrong → HOLD with bosun-needs-human-review label + comment.\n\n" +
-        "3. CI STATUS RECONFIRM:\n" +
-        "   Run: gh pr checks <number> --repo <owner/repo> --json name,state,conclusion\n" +
-        "   Ensure ALL checks have conclusion SUCCESS/SKIPPED/NEUTRAL. " +
-        "   If any are pending or failing → do NOT merge (CI may still be running).\n\n" +
-        "MERGE (only if ALL checks pass):\n" +
-        "   gh pr merge <number> --repo <owner/repo> --{{mergeMethod}} --delete-branch\n" +
-        "   Log: :check: Merged PR #<number> — <title>\n\n" +
-        "STRICT RULES:\n" +
-        "- NEVER merge if ANY safety check fails. When in doubt, HOLD.\n" +
-        "- NEVER merge PRs without the bosun-attached label.\n" +
-        "- NEVER merge draft PRs.\n" +
-        "- The bosun-needs-human-review label means a human must look at it before bosun touches it again.\n" +
-        "- After processing all candidates, output a summary: { merged: N, held: N, skipped: N }",
-      sdk: "auto",
-      timeoutMs: 1_200_000,
-      maxRetries: 1,
-      retryDelayMs: 30_000,
+    node("programmatic-review", "action.run_command", "Review Gate: Programmatic Merge", {
+      command: [
+        "node -e \"",
+        "const {execFileSync}=require('child_process');",
+        "const raw=String(process.env.BOSUN_FETCH_AND_CLASSIFY||'');",
+        "const payload=(()=>{try{return JSON.parse(raw||'{}')}catch{return {}}})();",
+        "const candidates=Array.isArray(payload.readyCandidates)?payload.readyCandidates:[];",
+        "const ratio=Number('{{suspiciousDeletionRatio}}')||3;",
+        "const minDel=Number('{{minDestructiveDeletions}}')||500;",
+        "const labelReview=String('{{labelNeedsReview}}'||'bosun-needs-human-review');",
+        "const method=String('{{mergeMethod}}'||'squash').toLowerCase();",
+        "const merged=[]; const held=[]; const skipped=[];",
+        "function gh(args){return execFileSync('gh',args,{encoding:'utf8',stdio:['pipe','pipe','pipe']}).trim();}",
+        "for(const c of candidates){",
+        "  const repo=String(c?.repo||'').trim();",
+        "  const n=String(c?.n||'').trim();",
+        "  if(!repo||!n){skipped.push({repo,number:n,reason:'missing_repo_or_pr'});continue;}",
+        "  try{",
+        "    const viewRaw=gh(['pr','view',n,'--repo',repo,'--json','number,title,additions,deletions,changedFiles,isDraft']);",
+        "    const view=(()=>{try{return JSON.parse(viewRaw||'{}')}catch{return {}}})();",
+        "    if(view?.isDraft===true){skipped.push({repo,number:n,reason:'draft'});continue;}",
+        "    const add=Number(view?.additions||0);",
+        "    const del=Number(view?.deletions||0);",
+        "    const changed=Number(view?.changedFiles||0);",
+        "    const destructive=(del>(add*ratio))&&(del>minDel);",
+        "    const tooWide=changed>250;",
+        "    if(destructive||tooWide){",
+        "      gh(['pr','edit',n,'--repo',repo,'--add-label',labelReview]);",
+        "      gh(['pr','comment',n,'--repo',repo,'--body',':warning: Bosun held this PR for human review due to suspicious diff footprint.']);",
+        "      held.push({repo,number:n,reason:destructive?'destructive_diff':'changed_files_too_large',additions:add,deletions:del,changedFiles:changed});",
+        "      continue;",
+        "    }",
+        "    const checksRaw=gh(['pr','checks',n,'--repo',repo,'--json','name,state,conclusion']);",
+        "    const checks=(()=>{try{return JSON.parse(checksRaw||'[]')}catch{return []}})();",
+        "    const bad=(Array.isArray(checks)?checks:[]).some((x)=>{",
+        "      const c=String(x?.conclusion||'').toUpperCase();",
+        "      const s=String(x?.state||'').toUpperCase();",
+        "      return ['FAILURE','ERROR','TIMED_OUT','CANCELLED'].includes(c) || ['PENDING','IN_PROGRESS','QUEUED','WAITING','REQUESTED','EXPECTED'].includes(s);",
+        "    });",
+        "    if(bad){skipped.push({repo,number:n,reason:'ci_not_green'});continue;}",
+        "    const mergeArgs=['pr','merge',n,'--repo',repo,'--delete-branch'];",
+        "    if(method==='rebase') mergeArgs.push('--rebase');",
+        "    else if(method==='merge') mergeArgs.push('--merge');",
+        "    else mergeArgs.push('--squash');",
+        "    gh(mergeArgs);",
+        "    merged.push({repo,number:n,title:String(view?.title||'')});",
+        "  }catch(e){",
+        "    held.push({repo,number:n,reason:'merge_attempt_failed',error:String(e?.message||e)});",
+        "  }",
+        "}",
+        "console.log(JSON.stringify({mergedCount:merged.length,heldCount:held.length,skippedCount:skipped.length,merged,held,skipped}));",
+        "\"",
+      ].join(" "),
       continueOnError: true,
+      failOnError: false,
+      env: {
+        BOSUN_FETCH_AND_CLASSIFY:
+          "(()=>{const r=$ctx.getNodeOutput('fetch-and-classify');return r&&r.success!==false?String(r.output||'{}'):'{}';})()",
+      },
     }, { x: 600, y: 700 }),
 
     node("notify", "notify.telegram", "Watchdog Report", {
@@ -991,31 +1048,33 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
     edge("has-prs",          "fix-needed",      { condition: "$output?.result === true" }),
     edge("has-prs",          "no-prs",          { condition: "$output?.result !== true" }),
     // Fix path (conflicts + CI failures)
-    edge("fix-needed",       "dispatch-fix",    { condition: "$output?.result === true" }),
+    edge("fix-needed",       "programmatic-fix",{ condition: "$output?.result === true" }),
     edge("fix-needed",       "review-needed",   { condition: "$output?.result !== true" }),
-    edge("dispatch-fix",     "review-needed"),
+    edge("programmatic-fix", "fix-agent-needed"),
+    edge("fix-agent-needed", "dispatch-fix-agent", { condition: "$output?.result === true" }),
+    edge("fix-agent-needed", "review-needed",      { condition: "$output?.result !== true" }),
+    edge("dispatch-fix-agent","review-needed"),
     // Review gate (merge candidates)
-    edge("review-needed",    "dispatch-review", { condition: "$output?.result === true" }),
+    edge("review-needed",    "programmatic-review", { condition: "$output?.result === true" }),
     edge("review-needed",    "notify",          { condition: "$output?.result !== true" }),
-    edge("dispatch-review",  "notify"),
+    edge("programmatic-review","notify"),
   ],
   metadata: {
     author: "bosun",
-    version: 3,
+    version: 4,
     createdAt: "2025-07-01T00:00:00Z",
-    templateVersion: "2.1.0",
+    templateVersion: "2.2.0",
     tags: ["github", "pr", "ci", "merge", "watchdog", "bosun-attached", "safety"],
     replaces: {
       module: "agent-hooks.mjs",
       functions: ["registerBuiltinHooks (PostPR block)"],
       calledFrom: [],
       description:
-        "v2: Consolidates PR polling into one gh pr list fetch per target repo per cycle. " +
-        "Adds mandatory review gate agent that checks diff stats (additions/deletions " +
-        "ratio) and diff content before any merge — preventing destructive PRs from " +
-        "being auto-merged. Adds conflict detection via the 'mergeable' field. " +
-        "Single fix agent handles both conflict resolution and CI failures. " +
-        "All external PRs (no bosun-attached label) are never touched.",
+        "v2.2: Consolidates PR polling into one gh pr list fetch per target repo per cycle. " +
+        "Uses deterministic-first remediation and review/merge command nodes; " +
+        "agent execution is now fallback-only for unresolved conflicts or failed " +
+        "automatic remediation attempts. All external PRs (no bosun-attached label) " +
+        "remain untouched.",
     },
   },
 };
@@ -1087,10 +1146,59 @@ export const GITHUB_KANBAN_SYNC_TEMPLATE = {
         "}catch{return false;}})()",
     }, { x: 400, y: 370 }),
 
-    node("sync-agent", "action.run_agent", "Sync PR State → Kanban", {
+    node("sync-programmatic", "action.run_command", "Sync PR State → Kanban (Programmatic)", {
+      command: [
+        "node -e \"",
+        "const {execFileSync}=require('child_process');",
+        "const fs=require('fs');",
+        "const raw=String(process.env.BOSUN_FETCH_PR_STATE||'');",
+        "const data=(()=>{try{return JSON.parse(raw||'{}')}catch{return {}}})();",
+        "const merged=Array.isArray(data.merged)?data.merged:[];",
+        "const open=Array.isArray(data.open)?data.open:[];",
+        "const updates=[]; const unresolved=[];",
+        "const taskCli=fs.existsSync('task-cli.mjs')?'task-cli.mjs':'';",
+        "if(!taskCli){",
+        "  console.log(JSON.stringify({updated:0,unresolved:[{reason:'task_cli_missing'}],needsAgent:true}));",
+        "  process.exit(0);",
+        "}",
+        "function runTask(args){return execFileSync('node',[taskCli,...args],{encoding:'utf8',stdio:['pipe','pipe','pipe']}).trim();}",
+        "for(const item of merged){",
+        "  const id=String(item?.taskId||'').trim();",
+        "  if(!id) continue;",
+        "  try{runTask(['update',id,'--status','done']);updates.push({taskId:id,status:'done'});}catch(e){unresolved.push({taskId:id,status:'done',error:String(e?.message||e)});}",
+        "}",
+        "for(const item of open){",
+        "  const id=String(item?.taskId||'').trim();",
+        "  if(!id) continue;",
+        "  try{runTask(['update',id,'--status','inreview']);updates.push({taskId:id,status:'inreview'});}catch(e){unresolved.push({taskId:id,status:'inreview',error:String(e?.message||e)});}",
+        "}",
+        "console.log(JSON.stringify({updated:updates.length,updates,unresolved,needsAgent:unresolved.length>0}));",
+        "\"",
+      ].join(" "),
+      continueOnError: true,
+      failOnError: false,
+      env: {
+        BOSUN_FETCH_PR_STATE:
+          "(()=>{const r=$ctx.getNodeOutput('fetch-pr-state');return r&&r.success!==false?String(r.output||'{}'):'{}';})()",
+      },
+    }, { x: 400, y: 530 }),
+
+    node("sync-agent-needed", "condition.expression", "Needs Agent Sync?", {
+      expression:
+        "(()=>{try{" +
+        "const raw=$ctx.getNodeOutput('sync-programmatic')?.output||'{}';" +
+        "const d=JSON.parse(raw);" +
+        "return d?.needsAgent===true || (Array.isArray(d?.unresolved)&&d.unresolved.length>0);" +
+        "}catch{return true;}})()",
+    }, { x: 400, y: 615 }),
+
+    node("sync-agent", "action.run_agent", "Sync PR State → Kanban (Fallback)", {
       prompt:
-        "You are the Bosun GitHub-Kanban sync agent. Sync the kanban board " +
-        "to match the GitHub PR state shown below.\n\n" +
+        "You are the Bosun GitHub-Kanban sync fallback agent. A deterministic sync pass already ran.\n\n" +
+        "Programmatic sync output:\n" +
+        "{{$ctx.getNodeOutput('sync-programmatic')?.output}}\n\n" +
+        "Now complete only unresolved updates.\n\n" +
+        "GitHub PR state:\n" +
         "PR state (JSON from fetch-pr-state node output):\n" +
         "{{$ctx.getNodeOutput('fetch-pr-state')?.output}}\n\n" +
         "RULES:\n" +
@@ -1107,7 +1215,7 @@ export const GITHUB_KANBAN_SYNC_TEMPLATE = {
       sdk: "auto",
       timeoutMs: 300_000,
       continueOnError: true,
-    }, { x: 400, y: 530 }),
+    }, { x: 400, y: 700 }),
 
     node("done", "notify.log", "Sync Complete", {
       message: "GitHub ↔ Kanban sync cycle complete",
@@ -1122,8 +1230,11 @@ export const GITHUB_KANBAN_SYNC_TEMPLATE = {
   edges: [
     edge("trigger", "fetch-pr-state"),
     edge("fetch-pr-state", "has-updates"),
-    edge("has-updates", "sync-agent", { condition: "$output?.result === true" }),
+    edge("has-updates", "sync-programmatic", { condition: "$output?.result === true" }),
     edge("has-updates", "skip", { condition: "$output?.result !== true" }),
+    edge("sync-programmatic", "sync-agent-needed"),
+    edge("sync-agent-needed", "sync-agent", { condition: "$output?.result === true" }),
+    edge("sync-agent-needed", "done", { condition: "$output?.result !== true" }),
     edge("sync-agent", "done"),
   ],
   metadata: {

package/workflow-templates/task-batch.mjs

@@ -0,0 +1,247 @@
+/**
+ * task-batch.mjs — Task Batch Processor Workflow Template
+ *
+ * Picks up multiple tasks from the kanban backlog and dispatches them in
+ * parallel using the loop.for_each fan-out node. Each task is executed via
+ * the Task Lifecycle sub-workflow (template-task-lifecycle).
+ *
+ * Templates:
+ *   - TASK_BATCH_PROCESSOR_TEMPLATE (primary batch dispatch)
+ *   - TASK_BATCH_PR_TEMPLATE (batch → agent → PR shortcut)
+ *
+ * DAG overview:
+ *   trigger.task_low
+ *     → condition.expression (is coordinator or solo?)
+ *       → action.run_command (list todo tasks)
+ *         → loop.for_each (fan-out, maxConcurrent tasks at a time)
+ *           → sub-workflow: template-task-lifecycle per task
+ *         → action.set_variable (record batch results)
+ *           → notify.log (summary)
+ */
+
+import { node, edge, resetLayout } from "./_helpers.mjs";
+
+// ═══════════════════════════════════════════════════════════════════════════
+//  Task Batch Processor — Parallel Task Dispatch
+// ═══════════════════════════════════════════════════════════════════════════
+
+resetLayout();
+
+export const TASK_BATCH_PROCESSOR_TEMPLATE = {
+  id: "template-task-batch-processor",
+  name: "Task Batch Processor",
+  description:
+    "Monitors the task backlog and dispatches multiple tasks in parallel " +
+    "using the Task Lifecycle sub-workflow. Automatically picks up tasks " +
+    "when backlog drops below threshold, fans out execution across " +
+    "available slots, and reports batch results.",
+  category: "lifecycle",
+  enabled: true,
+  recommended: true,
+  trigger: "trigger.task_low",
+  variables: {
+    backlogThreshold: 3,
+    maxConcurrent: 3,
+    pollStatus: "todo",
+    maxBatchSize: 10,
+    subWorkflow: "template-task-lifecycle",
+    notifyChannel: "telegram",
+  },
+  nodes: [
+    // ── Trigger: Backlog drops below threshold ───────────────────────────
+    node("trigger", "trigger.task_low", "Backlog Low?", {
+      threshold: "{{backlogThreshold}}",
+      status: "{{pollStatus}}",
+    }, { x: 400, y: 50 }),
+
+    // ── Gate: Fleet coordinator check (skip if not coordinator) ──────────
+    node("check-coordinator", "condition.expression", "Is Coordinator?", {
+      expression: "$data?.isCoordinator !== false",
+    }, { x: 400, y: 180 }),
+
+    // ── Query kanban for available tasks ─────────────────────────────────
+    node("query-tasks", "action.run_command", "Query Task Backlog", {
+      command: "node",
+      args: ["-e", `
+        import("./kanban-adapter.mjs")
+          .then(k => k.listTasks(undefined, { status: "todo" }))
+          .then(tasks => {
+            const batch = (tasks || []).slice(0, parseInt(process.env.MAX_BATCH || "10"));
+            console.log(JSON.stringify(batch.map(t => ({
+              taskId: t.id,
+              taskTitle: t.title || t.id,
+              status: t.status,
+              branch: t.branch || t.metadata?.branch || null,
+              scope: t.scope || t.metadata?.scope || null,
+            }))));
+          })
+          .catch(e => { console.error(e.message); process.exit(1); });
+      `],
+      env: { MAX_BATCH: "{{maxBatchSize}}" },
+      parseJson: true,
+    }, { x: 400, y: 310 }),
+
+    // ── Fan-out: dispatch each task to the lifecycle workflow ─────────────
+    node("dispatch-tasks", "loop.for_each", "Dispatch Tasks", {
+      items: "{{queryResult}}",
+      itemVariable: "currentTask",
+      indexVariable: "taskIndex",
+      maxConcurrent: "{{maxConcurrent}}",
+      workflowId: "{{subWorkflow}}",
+    }, { x: 400, y: 440 }),
+
+    // ── Record batch results ─────────────────────────────────────────────
+    node("record-results", "action.set_variable", "Record Results", {
+      key: "batchResult",
+      value: "{{dispatchResult}}",
+    }, { x: 400, y: 570 }),
+
+    // ── Notify on completion ─────────────────────────────────────────────
+    node("notify-complete", "notify.telegram", "Batch Summary", {
+      channel: "{{notifyChannel}}",
+      message: "Task batch completed: {{batchResult.successCount}}/{{batchResult.totalItems}} succeeded",
+    }, { x: 400, y: 700 }),
+  ],
+  edges: [
+    edge("trigger", "check-coordinator"),
+    edge("check-coordinator", "query-tasks", { condition: "result.result === true" }),
+    edge("query-tasks", "dispatch-tasks"),
+    edge("dispatch-tasks", "record-results"),
+    edge("record-results", "notify-complete"),
+  ],
+  metadata: {
+    author: "bosun",
+    version: 1,
+    createdAt: "2026-03-15T00:00:00Z",
+    templateVersion: "1.0.0",
+    tags: ["task", "batch", "parallel", "dispatch", "lifecycle"],
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+//  Task Batch → PR Shortcut — Pick tasks, run agent, create PRs
+// ═══════════════════════════════════════════════════════════════════════════
+
+resetLayout();
+
+export const TASK_BATCH_PR_TEMPLATE = {
+  id: "template-task-batch-pr",
+  name: "Task Batch → PR",
+  description:
+    "Simplified batch processor that picks todo tasks, runs the agent on " +
+    "each, and creates pull requests for any that produce commits. Ideal " +
+    "for autonomous mode where tasks should flow straight to PRs.",
+  category: "lifecycle",
+  enabled: true,
+  recommended: false,
+  trigger: "trigger.task_low",
+  variables: {
+    backlogThreshold: 3,
+    maxConcurrent: 2,
+    pollStatus: "todo",
+    maxBatchSize: 5,
+    defaultBaseBranch: "main",
+    draftPR: true,
+    notifyChannel: "telegram",
+  },
+  nodes: [
+    // ── Trigger ──────────────────────────────────────────────────────────
+    node("trigger", "trigger.task_low", "Backlog Low?", {
+      threshold: "{{backlogThreshold}}",
+      status: "{{pollStatus}}",
+    }, { x: 400, y: 50 }),
+
+    // ── Query for tasks ──────────────────────────────────────────────────
+    node("query-tasks", "action.run_command", "List Todo Tasks", {
+      command: "node",
+      args: ["-e", `
+        import("./kanban-adapter.mjs")
+          .then(k => k.listTasks(undefined, { status: "todo" }))
+          .then(tasks => {
+            const batch = (tasks || []).slice(0, parseInt(process.env.MAX_BATCH || "5"));
+            console.log(JSON.stringify(batch.map(t => ({
+              taskId: t.id,
+              taskTitle: t.title || t.id,
+              branch: t.branch || t.metadata?.branch || null,
+            }))));
+          })
+          .catch(e => { console.error(e.message); process.exit(1); });
+      `],
+      env: { MAX_BATCH: "{{maxBatchSize}}" },
+      parseJson: true,
+    }, { x: 400, y: 180 }),
+
+    // ── Fan-out: per-task agent + PR ─────────────────────────────────────
+    node("for-each-task", "loop.for_each", "Process Each Task", {
+      items: "{{queryResult}}",
+      itemVariable: "task",
+      indexVariable: "idx",
+      maxConcurrent: "{{maxConcurrent}}",
+    }, { x: 400, y: 310 }),
+
+    // ── Per-task: set status to inprogress ───────────────────────────────
+    node("set-inprogress", "action.update_task_status", "Mark In-Progress", {
+      taskId: "{{task.taskId}}",
+      status: "inprogress",
+    }, { x: 400, y: 440 }),
+
+    // ── Per-task: run agent ──────────────────────────────────────────────
+    node("run-agent", "action.run_agent", "Run Agent", {
+      taskId: "{{task.taskId}}",
+      taskTitle: "{{task.taskTitle}}",
+      branch: "{{task.branch}}",
+    }, { x: 400, y: 570 }),
+
+    // ── Per-task: detect commits ─────────────────────────────────────────
+    node("detect-commits", "action.detect_new_commits", "Check Commits", {
+      taskId: "{{task.taskId}}",
+      worktreePath: "{{worktreePath}}",
+      failOnError: false,
+    }, { x: 400, y: 700 }),
+
+    // ── Per-task: push + create PR ───────────────────────────────────────
+    node("push-branch", "action.git_operations", "Push Branch", {
+      operation: "push",
+      cwd: "{{worktreePath}}",
+    }, { x: 400, y: 830 }),
+
+    node("create-pr", "action.create_pr", "Create PR", {
+      title: "{{task.taskTitle}}",
+      body: "Automated PR for task {{task.taskId}}",
+      base: "{{defaultBaseBranch}}",
+      branch: "{{task.branch}}",
+      draft: "{{draftPR}}",
+    }, { x: 400, y: 960 }),
+
+    // ── Per-task: mark review ────────────────────────────────────────────
+    node("set-inreview", "action.update_task_status", "Mark In-Review", {
+      taskId: "{{task.taskId}}",
+      status: "inreview",
+    }, { x: 400, y: 1090 }),
+
+    // ── Batch complete notification ──────────────────────────────────────
+    node("notify", "notify.telegram", "Batch Complete", {
+      channel: "{{notifyChannel}}",
+      message: "Task batch PR pipeline complete",
+    }, { x: 400, y: 1220 }),
+  ],
+  edges: [
+    edge("trigger", "query-tasks"),
+    edge("query-tasks", "for-each-task"),
+    edge("for-each-task", "set-inprogress"),
+    edge("set-inprogress", "run-agent"),
+    edge("run-agent", "detect-commits"),
+    edge("detect-commits", "push-branch", { condition: "result.hasNewCommits === true" }),
+    edge("push-branch", "create-pr"),
+    edge("create-pr", "set-inreview"),
+    edge("detect-commits", "notify", { condition: "result.hasNewCommits !== true" }),
+    edge("set-inreview", "notify"),
+  ],
+  metadata: {
+    author: "bosun",
+    version: 1,
+    createdAt: "2026-03-15T00:00:00Z",
+    templateVersion: "1.0.0",
+    tags: ["task", "batch", "pr", "agent", "autonomous"],
+  },
+};