bosun 0.41.2 → 0.41.3

package/workflow-templates/_helpers.mjs

@@ -10,6 +10,24 @@
 let _nextX = 100;
 let _nextY = 100;
 
+const TEMPLATE_LAYOUT_DEFAULTS = Object.freeze({
+  centerX: 480,
+  topY: 80,
+  columnGap: 280,
+  rowGap: 180,
+});
+
+function toFiniteNumber(value, fallback = 0) {
+  return Number.isFinite(value) ? value : fallback;
+}
+
+function getNodeOriginalPosition(node, fallbackX = 0) {
+  return {
+    x: toFiniteNumber(node?.position?.x, fallbackX),
+    y: toFiniteNumber(node?.position?.y, 0),
+  };
+}
+
 /**
  * Create a workflow node definition with automatic positioning.
  * @param {string} id - Unique node identifier within the template
@@ -63,3 +81,139 @@ export function resetLayout() {
   _nextX = 100;
   _nextY = 100;
 }
+
+export function normalizeTemplateLayoutInPlace(template, opts = {}) {
+  const nodes = Array.isArray(template?.nodes) ? template.nodes : [];
+  const edges = Array.isArray(template?.edges) ? template.edges : [];
+  if (nodes.length <= 1) return template;
+
+  const centerX = toFiniteNumber(opts.centerX, TEMPLATE_LAYOUT_DEFAULTS.centerX);
+  const topY = toFiniteNumber(opts.topY, TEMPLATE_LAYOUT_DEFAULTS.topY);
+  const columnGap = Math.max(180, toFiniteNumber(opts.columnGap, TEMPLATE_LAYOUT_DEFAULTS.columnGap));
+  const rowGap = Math.max(120, toFiniteNumber(opts.rowGap, TEMPLATE_LAYOUT_DEFAULTS.rowGap));
+
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  const originalIndex = new Map(nodes.map((node, index) => [node.id, index]));
+  const originalPosition = new Map(
+    nodes.map((node, index) => [node.id, getNodeOriginalPosition(node, index * columnGap)]),
+  );
+
+  const incoming = new Map(nodes.map((node) => [node.id, []]));
+  const outgoing = new Map(nodes.map((node) => [node.id, []]));
+  for (const edgeDef of edges) {
+    if (!edgeDef || edgeDef.backEdge === true) continue;
+    const source = String(edgeDef.source || "").trim();
+    const target = String(edgeDef.target || "").trim();
+    if (!nodeIds.has(source) || !nodeIds.has(target)) continue;
+    outgoing.get(source).push(target);
+    incoming.get(target).push(source);
+  }
+
+  const sortedNodeIds = [...nodeIds].sort((left, right) => {
+    const leftPos = originalPosition.get(left) || { x: 0, y: 0 };
+    const rightPos = originalPosition.get(right) || { x: 0, y: 0 };
+    if (leftPos.y !== rightPos.y) return leftPos.y - rightPos.y;
+    if (leftPos.x !== rightPos.x) return leftPos.x - rightPos.x;
+    return (originalIndex.get(left) || 0) - (originalIndex.get(right) || 0);
+  });
+
+  const rootIds = sortedNodeIds.filter((nodeId) => {
+    const node = nodes[originalIndex.get(nodeId) || 0];
+    return (incoming.get(nodeId)?.length || 0) === 0 || String(node?.type || "").startsWith("trigger.");
+  });
+  const queue = rootIds.length > 0 ? [...rootIds] : [sortedNodeIds[0]];
+  const indegree = new Map([...incoming.entries()].map(([nodeId, parents]) => [nodeId, parents.length]));
+  const depthById = new Map(queue.map((nodeId) => [nodeId, 0]));
+  const queued = new Set(queue);
+
+  for (const nodeId of sortedNodeIds) {
+    if ((indegree.get(nodeId) || 0) === 0 && !queued.has(nodeId)) {
+      queue.push(nodeId);
+      queued.add(nodeId);
+      depthById.set(nodeId, 0);
+    }
+  }
+
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    const currentDepth = depthById.get(nodeId) || 0;
+    for (const targetId of outgoing.get(nodeId) || []) {
+      const nextDepth = currentDepth + 1;
+      if (nextDepth > (depthById.get(targetId) || 0)) {
+        depthById.set(targetId, nextDepth);
+      }
+      indegree.set(targetId, (indegree.get(targetId) || 0) - 1);
+      if ((indegree.get(targetId) || 0) <= 0 && !queued.has(targetId)) {
+        queue.push(targetId);
+        queued.add(targetId);
+      }
+    }
+  }
+
+  const unresolved = sortedNodeIds.filter((nodeId) => !depthById.has(nodeId));
+  while (unresolved.length > 0) {
+    let progressed = false;
+    for (let index = unresolved.length - 1; index >= 0; index -= 1) {
+      const nodeId = unresolved[index];
+      const parents = incoming.get(nodeId) || [];
+      if (parents.every((parentId) => depthById.has(parentId))) {
+        const nextDepth = parents.length > 0
+          ? Math.max(...parents.map((parentId) => depthById.get(parentId) || 0)) + 1
+          : 0;
+        depthById.set(nodeId, nextDepth);
+        unresolved.splice(index, 1);
+        progressed = true;
+      }
+    }
+    if (progressed) continue;
+    const nodeId = unresolved.shift();
+    const parents = incoming.get(nodeId) || [];
+    const knownParentDepths = parents
+      .map((parentId) => depthById.get(parentId))
+      .filter((depth) => Number.isFinite(depth));
+    const fallbackDepth = knownParentDepths.length > 0
+      ? Math.max(...knownParentDepths) + 1
+      : 0;
+    depthById.set(nodeId, fallbackDepth);
+  }
+
+  const layerMap = new Map();
+  for (const nodeId of sortedNodeIds) {
+    const depth = depthById.get(nodeId) || 0;
+    if (!layerMap.has(depth)) layerMap.set(depth, []);
+    layerMap.get(depth).push(nodeId);
+  }
+
+  const assignedX = new Map();
+  const sortedLayers = [...layerMap.keys()].sort((left, right) => left - right);
+  for (const depth of sortedLayers) {
+    const layerNodeIds = layerMap.get(depth) || [];
+    layerNodeIds.sort((left, right) => {
+      const leftParents = (incoming.get(left) || []).filter((parentId) => assignedX.has(parentId));
+      const rightParents = (incoming.get(right) || []).filter((parentId) => assignedX.has(parentId));
+      const leftBarycenter = leftParents.length > 0
+        ? leftParents.reduce((sum, parentId) => sum + assignedX.get(parentId), 0) / leftParents.length
+        : (originalPosition.get(left)?.x || 0);
+      const rightBarycenter = rightParents.length > 0
+        ? rightParents.reduce((sum, parentId) => sum + assignedX.get(parentId), 0) / rightParents.length
+        : (originalPosition.get(right)?.x || 0);
+      if (leftBarycenter !== rightBarycenter) return leftBarycenter - rightBarycenter;
+      const leftPos = originalPosition.get(left) || { x: 0, y: 0 };
+      const rightPos = originalPosition.get(right) || { x: 0, y: 0 };
+      if (leftPos.x !== rightPos.x) return leftPos.x - rightPos.x;
+      if (leftPos.y !== rightPos.y) return leftPos.y - rightPos.y;
+      return (originalIndex.get(left) || 0) - (originalIndex.get(right) || 0);
+    });
+
+    const startX = centerX - ((layerNodeIds.length - 1) * columnGap) / 2;
+    layerNodeIds.forEach((nodeId, index) => {
+      const node = nodes[originalIndex.get(nodeId) || 0];
+      const x = Math.round(startX + index * columnGap);
+      const y = topY + depth * rowGap;
+      node.position = { x, y };
+      assignedX.set(nodeId, x);
+    });
+  }
+
+  return template;
+}

package/workflow-templates/agents.mjs

@@ -13,6 +13,63 @@
 
 import { node, edge, resetLayout } from "./_helpers.mjs";
 
+const AGENT_SESSION_MONITOR_COMMAND = [
+  'node -e "',
+  "const fs = require('node:fs');",
+  "const path = require('node:path');",
+  "const { pathToFileURL } = require('node:url');",
+  "const cwd = process.cwd();",
+  "const mirrorMarker = `${path.sep}.bosun${path.sep}workspaces${path.sep}`.toLowerCase();",
+  "let repoRoot = cwd;",
+  "if (cwd.toLowerCase().includes(mirrorMarker)) {",
+  "const sourceRepoRoot = path.resolve(cwd, '..', '..', '..', '..');",
+  "if (fs.existsSync(path.join(sourceRepoRoot, 'infra', 'session-tracker.mjs'))) repoRoot = sourceRepoRoot;",
+  "}",
+  "const trackerModuleUrl = pathToFileURL(path.join(repoRoot, 'infra', 'session-tracker.mjs')).href;",
+  "import(trackerModuleUrl).then(({ getSessionTracker }) => {",
+  "const tracker = getSessionTracker();",
+  "const sessions = tracker.getActiveSessions().map((session) => {",
+  "const progress = tracker.getProgressStatus(session.taskId);",
+  "return {",
+  "id: session.taskId,",
+  "taskId: session.taskId,",
+  "taskTitle: session.taskTitle || null,",
+  "status: progress.status,",
+  "idleMs: progress.idleMs,",
+  "totalEvents: progress.totalEvents,",
+  "elapsedMs: progress.elapsedMs,",
+  "lastEventType: progress.lastEventType,",
+  "recommendation: progress.recommendation,",
+  "tokenPercent: null",
+  "};",
+  "});",
+  "console.log(JSON.stringify(sessions));",
+  "}).catch((err) => { console.error(err?.stack || String(err)); process.exit(1); });",
+  '"',
+].join("");
+
+const buildAgentSessionMonitorParseExpression = (rawExpression) => [
+  "(() => {",
+  `const raw = String(${rawExpression} || '[]');`,
+  "const lines = raw.split(/\\r?\\n/).map((line) => line.trim()).filter(Boolean);",
+  "const candidate = lines.length ? lines[lines.length - 1] : '[]';",
+  "try {",
+  "const parsed = JSON.parse(candidate);",
+  "return Array.isArray(parsed) ? parsed : [];",
+  "} catch {",
+  "return [];",
+  "}",
+  "})()",
+].join("");
+
+const AGENT_SESSION_MONITOR_LIST_PARSE_EXPRESSION = buildAgentSessionMonitorParseExpression(
+  "$ctx.getNodeOutput('list-sessions')?.output",
+);
+
+const AGENT_SESSION_MONITOR_HEALTH_PARSE_EXPRESSION = buildAgentSessionMonitorParseExpression(
+  "$ctx.getNodeOutput('check-health')?.output",
+);
+
 // ═══════════════════════════════════════════════════════════════════════════
 //  Frontend Agent with Screenshot Validation
 // ═══════════════════════════════════════════════════════════════════════════
@@ -368,21 +425,21 @@ export const AGENT_SESSION_MONITOR_TEMPLATE = {
     }, { x: 400, y: 50 }),
 
     node("list-sessions", "action.run_command", "List Active Sessions", {
-      command: "bosun agent list --json --active",
+      command: AGENT_SESSION_MONITOR_COMMAND,
       continueOnError: true,
     }, { x: 400, y: 200 }),
 
     node("has-active", "condition.expression", "Any Active?", {
-      expression: "($ctx.getNodeOutput('list-sessions')?.output || '[]') !== '[]' && ($ctx.getNodeOutput('list-sessions')?.output || '').length > 5",
+      expression: `${AGENT_SESSION_MONITOR_LIST_PARSE_EXPRESSION}.length > 0`,
     }, { x: 400, y: 340 }),
 
     node("check-health", "action.run_command", "Check Session Health", {
-      command: "bosun agent health --json",
+      command: AGENT_SESSION_MONITOR_COMMAND,
       continueOnError: true,
     }, { x: 200, y: 490 }),
 
     node("has-issues", "condition.expression", "Any Unhealthy?", {
-      expression: "(() => { const out = String($ctx.getNodeOutput('check-health')?.output || ''); const maxIdleMs = Number($data?.maxIdleMs || 600000); const maxTokenPercent = Number($data?.maxTokenPercent || 85); const idleMatch = out.match(/idle(?:_ms)?\\s*[:=]\\s*(\\d+)/i); const tokenMatch = out.match(/token(?:_usage|_percent)?\\s*[:=]\\s*(\\d+(?:\\.\\d+)?)/i); const idleExceeded = idleMatch ? Number(idleMatch[1]) > maxIdleMs : false; const tokenExceeded = tokenMatch ? Number(tokenMatch[1]) >= maxTokenPercent : false; return out.includes('stalled') || out.includes('timeout') || idleExceeded || tokenExceeded; })()",
+      expression: `(() => { const sessions = ${AGENT_SESSION_MONITOR_HEALTH_PARSE_EXPRESSION}; const maxIdleMs = Number($data?.maxIdleMs || 600000); const maxTokenPercent = Number($data?.maxTokenPercent || 85); return sessions.some((item) => { const status = String(item?.status || '').toLowerCase(); const idleMs = Number(item?.idleMs || 0); const tokenPercent = Number(item?.tokenPercent); return status === 'idle' || status === 'stalled' || status === 'timeout' || idleMs > maxIdleMs || (Number.isFinite(tokenPercent) && tokenPercent >= maxTokenPercent); }); })()`,
     }, { x: 200, y: 640 }),
 
     node("auto-continue", "action.continue_session", "Auto-Continue Stalled", {

package/workflow-templates/code-quality.mjs

@@ -34,7 +34,7 @@ export const CODE_QUALITY_STRIKER_TEMPLATE = {
   trigger: "trigger.schedule",
   variables: {
     sessionTimeoutMs: 5400000,       // 90 minutes hard cap
-    branch: "chore/code-quality-striker-{{_runId}}",
+    branch: "chore/code-quality-striker",
     baseBranch: "main",
     sessionLogPath: ".bosun-monitor/code-quality-striker.md",
     maxFilesPerSession: 6,           // keep PRs reviewable; prevents mega-diffs
@@ -184,7 +184,7 @@ If tests fail, **revert your change** (\`git checkout -- <file>\`) and either:
 
 ### Step 5 — Commit, push, and open the PR
 
-Branch name: \`chore/code-quality-striker-{{_runId}}\`
+Branch name: \`{{branch}}\`
 Base branch: \`{{baseBranch}}\`
 
 Commit message format:
@@ -203,7 +203,7 @@ PR body template:
 \`\`\`markdown
 ## Code Quality Pass
 
-**Session**: code-quality-striker {{_runId}}
+**Session**: {{branch}}
 **Scope**: structural refactor only — zero functional changes
 
 ### Changes
@@ -266,7 +266,7 @@ A small, clean, tested PR is always better than nothing.`,
 
     // ── 7a. Create PR ──────────────────────────────────────────────────────
     node("create-pr", "action.create_pr", "Open Quality PR", {
-      title: "refactor: code quality pass {{_runId}}",
+      title: "refactor: code quality pass",
       body: "Automated code-quality session. Structural refactor only — zero functional changes. See `.bosun-monitor/code-quality-striker.md` for session details.",
       branch: "{{branch}}",
       baseBranch: "{{baseBranch}}",
@@ -274,17 +274,17 @@ A small, clean, tested PR is always better than nothing.`,
     }, { x: 200, y: 890 }),
 
     node("notify-success", "notify.telegram", "Notify PR Opened", {
-      message: ":check: Code quality striker session complete.\nPR opened: **{{branch}}**\nRun ID: `{{_runId}}`",
+      message: ":check: Code quality striker session complete.\nPR opened: **{{branch}}**",
       silent: true,
     }, { x: 200, y: 1030 }),
 
     // ── 7b. Validation failed — notify and abort ───────────────────────────
     node("notify-failure", "notify.telegram", "Notify — Validation Failed", {
-      message: ":alert: Code quality striker **validation failed** for run `{{_runId}}`.\n\nThe agent produced changes that broke tests or build. No PR was created.\nCheck `.bosun-monitor/code-quality-striker.md` for details.",
+      message: ":alert: Code quality striker **validation failed**.\n\nThe agent produced changes that broke tests or build. No PR was created.\nCheck `.bosun-monitor/code-quality-striker.md` for details.",
     }, { x: 600, y: 890 }),
 
     node("log-failure", "notify.log", "Log Failure", {
-      message: "Code quality striker run {{_runId}} failed validation — no PR created.",
+      message: "Code quality striker validation failed — no PR created.",
       level: "warn",
     }, { x: 600, y: 1030 }),
   ],

package/workflow-templates/github.mjs

@@ -102,7 +102,7 @@ Respond with JSON: { "action": "<choice>", "reason": "<why>", "message": "<optio
     }, { x: 400, y: 520, outputs: ["merge", "prompt-agent", "close", "retry", "escalate", "wait-for-ci", "default"] }),
 
     node("do-merge", "action.run_command", "Auto-Merge PR", {
-      command: "gh pr merge {{prNumber}} --auto --squash",
+      command: "gh pr merge {{prNumber}} --auto --merge",
       failOnError: true,
       maxRetries: "{{maxRetries}}",
       retryDelayMs: 30000,
@@ -698,7 +698,7 @@ export const BOSUN_PR_PROGRESSOR_TEMPLATE = {
   recommended: true,
   trigger: "trigger.workflow_call",
   variables: {
-    mergeMethod: "squash",
+    mergeMethod: "merge",
     labelNeedsFix: "bosun-needs-fix",
     labelNeedsReview: "bosun-needs-human-review",
     suspiciousDeletionRatio: 3,
@@ -889,7 +889,7 @@ export const BOSUN_PR_PROGRESSOR_TEMPLATE = {
         "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 method=String('{{mergeMethod}}'||'merge').toLowerCase();",
         "function gh(args){return execFileSync('gh',args,{encoding:'utf8',stdio:['pipe','pipe','pipe']}).trim();}",
         "if(!repo||!n){console.log(JSON.stringify({mergedCount:0,heldCount:0,skippedCount:1,skipped:[{repo,number:n,reason:'missing_repo_or_pr'}]}));process.exit(0);}",
         "try{",
@@ -1015,7 +1015,7 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
   recommended: true,
   trigger: "trigger.schedule",
   variables: {
-    mergeMethod:        "squash",                   // squash | merge | rebase
+    mergeMethod:        "merge",                    // merge | squash | rebase
     labelNeedsFix:      "bosun-needs-fix",           // applied to CI failures and conflicts
     labelNeedsReview:   "bosun-needs-human-review",  // applied when review agent flags a suspicious diff
     // auto: active workspace repos from bosun.config.json (fallback current repo)
@@ -1027,6 +1027,7 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
     // If net deletions > additions × ratio AND deletions > minDestructiveDeletions → HOLD
     suspiciousDeletionRatio: 3,    // e.g. deletes 3× more lines than it adds
     minDestructiveDeletions: 500,  // absolute floor — small PRs are fine even if net negative
+    autoApplySuggestions:   true,  // auto-commit review suggestions before merge
   },
   nodes: [
     node("trigger", "trigger.schedule", "Poll Every 90s", {
@@ -1429,7 +1430,7 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
         "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 method=String('{{mergeMethod}}'||'merge').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){",
@@ -1464,6 +1465,17 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
         "    });",
         "    if(hasFailure){skipped.push({repo,number:n,reason:'ci_failed'});continue;}",
         "    if(hasPending){skipped.push({repo,number:n,reason:'ci_pending'});continue;}",
+        "    const doApplySuggestions=String('{{autoApplySuggestions}}'||'true')==='true'&&process.env.BOSUN_AUTO_APPLY_SUGGESTIONS!=='false';",
+        "    if(doApplySuggestions){",
+        "      try{",
+        "        const toolPath=require('path').resolve(process.cwd(),'tools','apply-pr-suggestions.mjs');",
+        "        if(require('fs').existsSync(toolPath)){",
+        "          const sugOut=execFileSync('node',[toolPath,'--owner',repo.split('/')[0],'--repo',repo.split('/')[1],n,'--json'],{encoding:'utf8',timeout:60000,stdio:['pipe','pipe','pipe']});",
+        "          const sugRes=(()=>{try{return JSON.parse(sugOut)}catch{return null}})();",
+        "          if(sugRes?.commitSha) console.error('[watchdog] auto-applied '+sugRes.applied+' suggestion(s) on PR #'+n+' → '+sugRes.commitSha.slice(0,8));",
+        "        }",
+        "      }catch(sugErr){console.error('[watchdog] suggestion auto-apply skipped for PR #'+n+': '+String(sugErr?.message||sugErr).slice(0,120));}",
+        "    }",
         "    const mergeArgs=['pr','merge',n,'--repo',repo,'--delete-branch'];",
         "    if(method==='rebase') mergeArgs.push('--rebase');",
         "    else if(method==='merge') mergeArgs.push('--merge');",
@@ -1488,11 +1500,10 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
       },
     }, { x: 600, y: 700 }),
 
-    node("notify", "notify.telegram", "Watchdog Report", {
+    node("notify", "notify.log", "Watchdog Report", {
       message:
-        ":bug: Bosun PR Watchdog cycle complete — " +
-        "fix-dispatched: {{fixNeeded}} | candidates-reviewed: {{readyCandidates}}",
-      silent: true,
+        "Bosun PR Watchdog cycle complete — see live digest/status board for streaming updates",
+      level: "info",
     }, { x: 400, y: 900 }),
 
     node("no-prs", "notify.log", "No Bosun PRs Open", {
@@ -1992,4 +2003,3 @@ export const SDK_CONFLICT_RESOLVER_TEMPLATE = {
   },
 };
 
-

package/workflow-templates/task-batch.mjs

@@ -16,7 +16,9 @@
  *         → 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)
+ *           → condition.expression (any failures?)
+ *             → notify.telegram (failure alert)
+ *             → notify.log (summary)
  */
 
 import { node, edge, resetLayout } from "./_helpers.mjs";
@@ -110,11 +112,19 @@ export const TASK_BATCH_PROCESSOR_TEMPLATE = {
       value: "{{dispatch-tasks}}",
     }, { x: 400, y: 570 }),
 
-    // ── Notify on completion ─────────────────────────────────────────────
-    node("notify-complete", "notify.telegram", "Batch Summary", {
-      channel: "{{notifyChannel}}",
-      message: "Task batch completed: {{dispatch-tasks.successCount}}/{{dispatch-tasks.totalItems}} succeeded ({{dispatch-tasks.failCount}} failed)",
+    node("has-batch-failures", "condition.expression", "Any Batch Failures?", {
+      expression: "Number($data?.batchResult?.failCount || 0) > 0",
     }, { x: 400, y: 700 }),
+
+    node("notify-failures", "notify.telegram", "Batch Failure Alert", {
+      channel: "{{notifyChannel}}",
+      message: "Task batch needs attention: {{batchResult.failCount}} failed out of {{batchResult.totalItems}} ({{batchResult.successCount}} succeeded)",
+    }, { x: 220, y: 830 }),
+
+    node("log-summary", "notify.log", "Batch Summary", {
+      message: "Task batch completed: {{batchResult.successCount}}/{{batchResult.totalItems}} succeeded ({{batchResult.failCount}} failed)",
+      level: "info",
+    }, { x: 580, y: 830 }),
   ],
   edges: [
     edge("trigger", "check-coordinator"),
@@ -122,7 +132,9 @@ export const TASK_BATCH_PROCESSOR_TEMPLATE = {
     edge("query-tasks", "dispatch-tasks"),
     edge("dispatch-tasks", "join-dispatch"),
     edge("join-dispatch", "record-results"),
-    edge("record-results", "notify-complete"),
+    edge("record-results", "has-batch-failures"),
+    edge("has-batch-failures", "notify-failures", { condition: "$output?.result === true" }),
+    edge("has-batch-failures", "log-summary", { condition: "$output?.result !== true" }),
   ],
   metadata: {
     author: "bosun",
@@ -156,7 +168,6 @@ export const TASK_BATCH_PR_TEMPLATE = {
     maxBatchSize: 5,
     defaultBaseBranch: "main",
     draftPR: true,
-    notifyChannel: "telegram",
   },
   nodes: [
     // ── Trigger ──────────────────────────────────────────────────────────
@@ -262,9 +273,9 @@ export const TASK_BATCH_PR_TEMPLATE = {
     }, { x: 400, y: 1230 }),
 
     // ── Batch complete notification ──────────────────────────────────────
-    node("notify", "notify.telegram", "Batch Complete", {
-      channel: "{{notifyChannel}}",
+    node("notify", "notify.log", "Batch Complete", {
       message: "Task batch PR pipeline complete",
+      level: "info",
     }, { x: 400, y: 1220 }),
   ],
   edges: [

package/workflow-templates/task-lifecycle.mjs

@@ -431,19 +431,41 @@ export const TASK_LIFECYCLE_TEMPLATE = {
       taskId: "{{taskId}}",
     }, { x: 600, y: 1090 }),
 
+    node("wt-failure-blocking", "condition.expression", "Non-Retryable WT Failure?", {
+      expression: "$ctx.getNodeOutput('acquire-worktree')?.retryable === false",
+    }, { x: 600, y: 1220, outputs: ["yes", "no"] }),
+
+    node("set-blocked-wt-failed", "action.update_task_status", "Set Blocked (WT Fail)", {
+      taskId: "{{taskId}}",
+      status: "blocked",
+      taskTitle: "{{taskTitle}}",
+    }, { x: 470, y: 1350 }),
+    
+    node("annotate-blocked-wt-failed", "action.bosun_function", "Annotate Blocked (WT Fail)", {
+      function: "tasks.update",
+      args: {
+        taskId: "{{taskId}}",
+        fields: {
+          cooldownUntil: "{{acquire-worktree.retryAt}}",
+          blockedReason: "{{acquire-worktree.blockedReason}}",
+          meta: "{{(() => { const current = ($data.taskMeta && typeof $data.taskMeta === 'object') ? $data.taskMeta : {}; const output = $ctx.getNodeOutput('acquire-worktree') || {}; return { ...current, autoRecovery: { active: true, reason: 'worktree_failure', failureKind: output.failureKind || 'branch_refresh_conflict', retryAt: output.retryAt || null, recoveryDelayMs: output.autoRecoverDelayMs || null, error: output.error || '', recordedAt: output.recordedAt || null }, worktreeFailure: { failureKind: output.failureKind || 'branch_refresh_conflict', retryable: output.retryable !== false, retryAt: output.retryAt || null, blockedReason: output.blockedReason || '', error: output.error || '', recordedAt: output.recordedAt || null } }; })()}}",
+        },
+      },
+    }, { x: 470, y: 1480 }),
+
     node("set-todo-wt-failed", "action.update_task_status", "Set Todo (WT Fail)", {
       taskId: "{{taskId}}",
       status: "todo",
       taskTitle: "{{taskTitle}}",
-    }, { x: 600, y: 1220 }),
+    }, { x: 730, y: 1350 }),
 
     node("release-slot-wt-failed", "action.release_slot", "Release Slot (WT Fail)", {
       taskId: "{{taskId}}",
-    }, { x: 600, y: 1350 }),
+    }, { x: 600, y: 1480 }),
 
     node("notify-wt-failed", "notify.telegram", "Notify WT Failed", {
-      message: "⚠️ Worktree failed for \"{{taskTitle}}\" ({{taskId}})",
-    }, { x: 600, y: 1480 }),
+      message: "⚠️ Worktree failed for \"{{taskTitle}}\" ({{taskId}}){{acquire-worktree.recoveryNote}}",
+    }, { x: 600, y: 1740 }),
   ],
   edges: [
     // Main flow
@@ -515,7 +537,11 @@ export const TASK_LIFECYCLE_TEMPLATE = {
 
     // Worktree failed path
     edge("worktree-ok", "release-claim-wt-failed", { condition: "$output?.result !== true", port: "no" }),
-    edge("release-claim-wt-failed", "set-todo-wt-failed"),
+    edge("release-claim-wt-failed", "wt-failure-blocking"),
+    edge("wt-failure-blocking", "set-blocked-wt-failed", { condition: "$output?.result === true", port: "yes" }),
+    edge("wt-failure-blocking", "set-todo-wt-failed", { condition: "$output?.result !== true", port: "no" }),
+    edge("set-blocked-wt-failed", "annotate-blocked-wt-failed"),
+    edge("annotate-blocked-wt-failed", "release-slot-wt-failed"),
     edge("set-todo-wt-failed", "release-slot-wt-failed"),
     edge("release-slot-wt-failed", "notify-wt-failed"),
   ],
@@ -801,4 +827,3 @@ export const VE_ORCHESTRATOR_LITE_TEMPLATE = {
   },
 };
 
-