bosun 0.41.2 → 0.41.3

package/workflow/workflow-nodes.mjs

@@ -24,13 +24,19 @@ import {
   registerNodeType,
   unregisterNodeType,
 } from "./workflow-engine.mjs";
+import {
+  _completedWithPR,
+  _noCommitCounts,
+  _skipUntil,
+  MAX_NO_COMMIT_ATTEMPTS,
+} from "./workflow-nodes/transforms.mjs";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { execSync, execFileSync, spawn, spawnSync } from "node:child_process";
 import { createHash, 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 { buildRelevantSkillsPromptBlock, emitSkillInvokeEvent, findRelevantSkills } from "../agent/bosun-skills.mjs";
 import { readBenchmarkModeState, taskMatchesBenchmarkMode } from "../bench/benchmark-mode.mjs";
 import { getSessionTracker } from "../infra/session-tracker.mjs";
 import {
@@ -38,8 +44,9 @@ import {
   loadWorkflowContract,
   validateWorkflowContract,
 } from "./workflow-contract.mjs";
+import { loadConfig } from "../config/config.mjs";
 import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
-import { clearBlockedWorktreeIdentity } from "../git/git-safety.mjs";
+import { clearBlockedWorktreeIdentity, normalizeBaseBranch } from "../git/git-safety.mjs";
 import { getGitHubToken, invalidateTokenType } from "../github/github-auth-manager.mjs";
 import {
   CUSTOM_NODE_DIR_NAME,
@@ -55,6 +62,7 @@ let customLoadPromise = null;
 let customDiscoveryStarted = false;
 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');\"";
 const PORTABLE_PRUNE_AND_COUNT_WORKTREES_COMMAND = "node -e \"const cp=require('node:child_process');cp.execSync('git worktree prune',{stdio:'ignore'});const wt=cp.execSync('git worktree list --porcelain',{encoding:'utf8'});const count=(wt.match(/^worktree /gm)||[]).length;process.stdout.write(String(count)+'\\\\n');\"";
+const DEFAULT_NON_RETRYABLE_WORKTREE_RECOVERY_MS = 15 * 60 * 1000;
 const WORKFLOW_AGENT_HEARTBEAT_MS = (() => {
   const raw = Number(process.env.WORKFLOW_AGENT_HEARTBEAT_MS || 30000);
   if (!Number.isFinite(raw)) return 30000;
@@ -67,6 +75,19 @@ const WORKFLOW_AGENT_EVENT_PREVIEW_LIMIT = (() => {
 })();
 const BOSUN_ATTACHED_PR_LABEL = "bosun-attached";
 
+function getNonRetryableWorktreeRecoveryMs() {
+  try {
+    const config = loadConfig();
+    const minutes = Number(config?.workflowWorktreeRecoveryCooldownMin);
+    if (!Number.isFinite(minutes)) {
+      return DEFAULT_NON_RETRYABLE_WORKTREE_RECOVERY_MS;
+    }
+    return Math.max(1, Math.min(1440, Math.trunc(minutes))) * 60 * 1000;
+  } catch {
+    return DEFAULT_NON_RETRYABLE_WORKTREE_RECOVERY_MS;
+  }
+}
+
 const HTML_TEXT_BREAK_TAGS = new Set([
   "address",
   "article",
@@ -1334,6 +1355,45 @@ function parseBooleanSetting(value, defaultValue = false) {
   return defaultValue;
 }
 
+async function recoverTimedBlockedWorkflowTasks({ kanban, ctx, node, projectId }) {
+  if (!kanban || typeof kanban.listTasks !== "function" || typeof kanban.updateTask !== "function") {
+    return { recoveredTaskIds: [], recoveredCount: 0 };
+  }
+
+  const blockedTasks = await kanban.listTasks(projectId, { status: "blocked" });
+  const nowMs = Date.now();
+  const recoveredTaskIds = [];
+  for (const task of Array.isArray(blockedTasks) ? blockedTasks : []) {
+    const autoRecovery = task?.meta?.autoRecovery;
+    if (!autoRecovery || typeof autoRecovery !== "object") continue;
+    if (autoRecovery.active === false) continue;
+    if (String(autoRecovery.reason || "").trim() !== "worktree_failure") continue;
+    const retryAtMs = Date.parse(String(autoRecovery.retryAt || task?.cooldownUntil || ""));
+    if (!Number.isFinite(retryAtMs) || retryAtMs > nowMs) continue;
+    await kanban.updateTask(task.id, {
+      status: "todo",
+      cooldownUntil: null,
+      blockedReason: null,
+      meta: {
+        ...(task?.meta && typeof task.meta === "object" ? task.meta : {}),
+        autoRecovery: {
+          ...autoRecovery,
+          active: false,
+          recoveredAt: new Date(nowMs).toISOString(),
+          recoveredStatus: "todo",
+        },
+      },
+    });
+    recoveredTaskIds.push(task.id);
+  }
+
+  if (recoveredTaskIds.length > 0) {
+    ctx.log(node.id, `Recovered ${recoveredTaskIds.length} blocked task(s): ${recoveredTaskIds.join(", ")}`);
+  }
+
+  return { recoveredTaskIds, recoveredCount: recoveredTaskIds.length };
+}
+
 function getPathValue(value, pathExpression) {
   const path = String(pathExpression || "").trim();
   if (!path) return undefined;
@@ -3936,7 +3996,7 @@ registerBuiltinNodeType("action.update_task_status", {
     type: "object",
     properties: {
       taskId: { type: "string", description: "Task ID (supports {{variables}})" },
-      status: { type: "string", enum: ["todo", "inprogress", "inreview", "done", "archived"] },
+      status: { type: "string", enum: ["todo", "inprogress", "inreview", "done", "blocked", "archived"] },
       taskTitle: { type: "string", description: "Optional task title for downstream event payloads" },
       previousStatus: { type: "string", description: "Optional explicit previous status" },
       workflowEvent: { type: "string", description: "Optional follow-up workflow event to emit after status update" },
@@ -4213,7 +4273,7 @@ registerBuiltinNodeType("action.create_pr", {
       autoMergeMethod: {
         type: "string",
         enum: ["merge", "squash", "rebase"],
-        default: "squash",
+        default: "merge",
         description: "Merge method used with gh pr merge --auto",
       },
       mergeMethod: {
@@ -4229,7 +4289,12 @@ registerBuiltinNodeType("action.create_pr", {
   async execute(node, ctx) {
     const title = ctx.resolve(node.config?.title || "");
     const body = ctx.resolve(node.config?.body || "");
-    const base = ctx.resolve(node.config?.base || node.config?.baseBranch || "main");
+    const baseInput = ctx.resolve(node.config?.base || node.config?.baseBranch || "main");
+    let base = String(baseInput || "main").trim() || "main";
+    try {
+      base = normalizeBaseBranch(base).branch;
+    } catch {
+    }
     const branch = ctx.resolve(node.config?.branch || "");
     const repoSlug = String(
       ctx.resolve(node.config?.repoSlug || ctx.data?.repoSlug || ctx.data?.repository || ""),
@@ -4241,11 +4306,11 @@ registerBuiltinNodeType("action.create_pr", {
       false,
     );
     const autoMergeMethodRaw = String(
-      ctx.resolve(node.config?.autoMergeMethod || node.config?.mergeMethod || "squash"),
+      ctx.resolve(node.config?.autoMergeMethod || node.config?.mergeMethod || process.env.BOSUN_MERGE_METHOD || "merge"),
     ).trim().toLowerCase();
     const autoMergeMethod = ["merge", "squash", "rebase"].includes(autoMergeMethodRaw)
       ? autoMergeMethodRaw
-      : "squash";
+      : (process.env.BOSUN_MERGE_METHOD || "merge");
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
 
     // Normalize labels/reviewers to arrays
@@ -9690,6 +9755,88 @@ function hasUnresolvedGitOperation(worktreePath) {
   }
 }
 
+function hasTrackedGitChanges(worktreePath) {
+  if (!worktreePath || !existsSync(worktreePath)) return false;
+  try {
+    const status = execGitArgsSync(
+      ["status", "--porcelain", "--untracked-files=no"],
+      {
+        cwd: worktreePath,
+        encoding: "utf8",
+        timeout: 5000,
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    ).trim();
+    return Boolean(status);
+  } catch {
+    return true;
+  }
+}
+
+function countCommitsBehindBase(worktreePath, baseBranch) {
+  if (!worktreePath || !existsSync(worktreePath) || !baseBranch) return 0;
+  try {
+    const counts = execGitArgsSync(
+      ["rev-list", "--left-right", "--count", `HEAD...${baseBranch}`],
+      {
+        cwd: worktreePath,
+        encoding: "utf8",
+        timeout: 5000,
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    ).trim();
+    const match = counts.match(/^(\d+)\s+(\d+)$/);
+    return match ? Number(match[2]) : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function refreshManagedWorktreeReuse(
+  nodeId,
+  ctx,
+  repoRoot,
+  worktreePath,
+  baseBranch,
+  baseBranchShort,
+  fetchTimeout,
+) {
+  if (!existsSync(worktreePath) || shouldSkipGitRefreshForTests()) return existsSync(worktreePath);
+  let refreshError = "";
+  try {
+    execSync(`git pull --rebase origin ${baseBranchShort}`, {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: fetchTimeout,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (error) {
+    refreshError = formatExecSyncError(error);
+  }
+  if (!existsSync(worktreePath)) return false;
+  if (hasUnresolvedGitOperation(worktreePath)) {
+    const detail = refreshError ? ` (${refreshError})` : "";
+    ctx.log(
+      nodeId,
+      `Managed worktree refresh left unresolved git state, recreating: ${worktreePath}${detail}`,
+    );
+    cleanupBrokenManagedWorktree(repoRoot, worktreePath);
+    return false;
+  }
+  const reasons = [];
+  if (hasTrackedGitChanges(worktreePath)) reasons.push("tracked changes after refresh");
+  const behindCount = countCommitsBehindBase(worktreePath, baseBranch);
+  if (behindCount > 0) reasons.push(`${behindCount} commit(s) behind ${baseBranch}`);
+  if (reasons.length === 0) return true;
+  if (refreshError) reasons.unshift(`refresh failed: ${refreshError}`);
+  ctx.log(
+    nodeId,
+    `Managed worktree refresh did not yield a clean up-to-date branch, recreating: ${worktreePath} (${reasons.join("; ")})`,
+  );
+  cleanupBrokenManagedWorktree(repoRoot, worktreePath);
+  return false;
+}
+
 function cleanupBrokenManagedWorktree(repoRoot, worktreePath) {
   if (!worktreePath) return;
   const linkedGitDir = resolveGitDirForWorktree(worktreePath);
@@ -9728,13 +9875,9 @@ function cleanupBrokenManagedWorktree(repoRoot, worktreePath) {
 }
 
 /**
- * Anti-thrash state — module-scope to survive across workflow runs.
- * Mirrors TaskExecutor._noCommitCounts / _skipUntil / _completedWithPR.
+ * Anti-thrash state — imported from transforms.mjs (single source of truth).
+ * Shared between monolithic workflow-nodes.mjs and modular triggers.mjs.
  */
-const _noCommitCounts = new Map();
-const _skipUntil = new Map();
-const _completedWithPR = new Set();
-const MAX_NO_COMMIT_ATTEMPTS = 3;
 const NO_COMMIT_BASE_COOLDOWN_MS = 15 * 60 * 1000; // 15 min
 const NO_COMMIT_MAX_COOLDOWN_MS = 2 * 60 * 60 * 1000; // 2 hours
 const STRICT_START_GUARD_MISSING_TASK = /^(1|true|yes|on)$/i.test(
@@ -9795,6 +9938,13 @@ registerBuiltinNodeType("trigger.task_available", {
     for (let attempt = 0; attempt <= listRetries; attempt++) {
       try {
         const kanban = ctx.data?._services?.kanban || engine?.services?.kanban;
+        if (status === "todo") {
+          try {
+            await recoverTimedBlockedWorkflowTasks({ kanban, ctx, node, projectId });
+          } catch (recoveryErr) {
+            ctx.log(node.id, `Blocked task recovery warning: ${recoveryErr?.message || recoveryErr}`);
+          }
+        }
         if (kanban?.listTasks) {
           tasks = await kanban.listTasks(projectId, { status });
         } else {
@@ -10108,6 +10258,9 @@ registerBuiltinNodeType("trigger.task_available", {
       if (baseBranch) ctx.data.baseBranch = baseBranch;
       const branch = deriveTaskBranch(primaryTask);
       if (branch) ctx.data.branch = branch;
+      ctx.data.taskMeta = primaryTask?.meta && typeof primaryTask.meta === "object"
+        ? { ...primaryTask.meta }
+        : {};
     }
 
     ctx.log(node.id, `Found ${toDispatch.length} task(s) ready (${remaining} slot(s) free)`);
@@ -10479,8 +10632,26 @@ registerBuiltinNodeType("action.resolve_executor", {
       || ctx.data?.agentProfile
       || "",
     ).trim();
+    const taskText = [task.title, task.description].filter(Boolean).join("\n");
+    const inferredResolutionTags = [];
+    if (/\btest(?:s|ing)?\b/i.test(taskText)) inferredResolutionTags.push("test", "tests");
+    if (/\b(?:ci|cd|pipeline|workflow|github actions?)\b/i.test(taskText)) inferredResolutionTags.push("ci", "cd", "pipeline");
+    if (/\b(?:merge conflict|conflicts|rebase|cherry-pick)\b/i.test(taskText)) inferredResolutionTags.push("conflict", "merge");
+    if (/\b(?:implement|implementation|feature|build|ship)\b/i.test(taskText)) inferredResolutionTags.push("implementation");
+    if (/\b(?:docs?|documentation|readme)\b/i.test(taskText)) inferredResolutionTags.push("docs", "documentation");
+    const resolutionTags = Array.from(new Set([
+      ...task.tags,
+      ...inferredResolutionTags,
+      String(ctx.data?.task?.type || "").trim(),
+      String(ctx.data?.task?.agentType || "").trim(),
+      String(ctx.data?.task?.assignedAgentType || "").trim(),
+      String(ctx.data?.agentType || "").trim(),
+      String(ctx.data?.assignedAgentType || "").trim(),
+    ].map((value) => String(value || "").trim()).filter(Boolean)));
     let profileDecision = null;
     let configuredExecutorPreference = null;
+    ctx.data.resolvedSkillIds = [];
+    ctx.data.resolvedLibraryPlan = null;
 
     // Check env var overrides (mirrors TaskExecutor behavior)
     const envModel =
@@ -10497,25 +10668,30 @@ registerBuiltinNodeType("action.resolve_executor", {
 
     try {
       const library = await ensureLibraryManagerMod();
-      const match = library.matchAgentProfiles?.(
+      const criteria = {
+        title: task.title,
+        description: task.description,
+        tags: resolutionTags,
+        agentType: ctx.data?.task?.agentType || ctx.data?.agentType || "",
         repoRoot,
+        changedFiles: Array.isArray(ctx.data?.changedFiles) ? ctx.data.changedFiles : [],
+      };
+      const planResult = library.resolveLibraryPlan?.(
+        repoRoot,
+        criteria,
         {
-          title: task.title,
-          description: task.description,
-          tags: task.tags,
-          agentType: ctx.data?.task?.agentType || ctx.data?.agentType || "",
-          repoRoot,
+          topN: Math.max(10, requestedAgentProfileId ? 25 : 10),
+          skillTopN: 5,
         },
-        { topN: Math.max(10, requestedAgentProfileId ? 25 : 10) },
       );
-      const candidates = Array.isArray(match?.candidates) ? match.candidates : [];
-      const bestCandidate = match?.best || null;
-      const autoMinScore = Number(match?.auto?.thresholds?.minScore || 12);
+      const candidates = Array.isArray(planResult?.candidates) ? planResult.candidates : [];
+      const bestCandidate = planResult?.best || null;
+      const autoMinScore = Number(planResult?.auto?.thresholds?.minScore || 12);
       const scoreQualified = Number(bestCandidate?.score || 0) >= autoMinScore;
       const matchedCandidate = requestedAgentProfileId
         ? candidates.find((candidate) => String(candidate?.id || "").trim() === requestedAgentProfileId) || null
-        : ((match?.auto?.shouldAutoApply || scoreQualified) ? bestCandidate : null);
-      if (!requestedAgentProfileId && bestCandidate && !match?.auto?.shouldAutoApply) {
+        : ((planResult?.auto?.shouldAutoApply || scoreQualified) ? bestCandidate : null);
+      if (!requestedAgentProfileId && bestCandidate && !planResult?.auto?.shouldAutoApply) {
         ctx.log(
           node.id,
           `Profile match below auto threshold; ignoring candidate ${String(bestCandidate.id || "unknown")}`,
@@ -10534,13 +10710,19 @@ registerBuiltinNodeType("action.resolve_executor", {
         ctx.data.agentProfile = profileId;
         ctx.data.resolvedAgentProfile = {
           id: profileId,
-          name: match?.best?.name || profile?.name || profileId,
+          name: matchedCandidate?.name || profile?.name || profileId,
           ...profile,
         };
-        const skillIds = Array.isArray(profile.skills)
-          ? profile.skills.map((value) => String(value || "").trim()).filter(Boolean)
-          : [];
+        const resolvedPlan = planResult?.plan && planResult.plan.agentProfileId === profileId
+          ? planResult.plan
+          : null;
+        const skillIds = resolvedPlan && Array.isArray(resolvedPlan.skillIds)
+          ? resolvedPlan.skillIds.map((value) => String(value || "").trim()).filter(Boolean)
+          : Array.isArray(profile.skills)
+            ? profile.skills.map((value) => String(value || "").trim()).filter(Boolean)
+            : [];
         ctx.data.resolvedSkillIds = skillIds;
+        ctx.data.resolvedLibraryPlan = resolvedPlan;
       }
     } catch (err) {
       ctx.log(node.id, `Library profile resolution failed: ${err.message}`);
@@ -10739,22 +10921,15 @@ registerBuiltinNodeType("action.acquire_worktree", {
       }
 
       if (existsSync(worktreePath)) {
-        // Reuse existing worktree — pull latest base if possible
-        if (!shouldSkipGitRefreshForTests()) {
-          try {
-            execSync(`git pull --rebase origin ${baseBranchShort}`, {
-              cwd: worktreePath, encoding: "utf8",
-              timeout: fetchTimeout,
-              stdio: ["ignore", "pipe", "pipe"],
-            });
-          } catch {
-            /* rebase failures are non-fatal for reuse */
-          }
-          if (existsSync(worktreePath) && hasUnresolvedGitOperation(worktreePath)) {
-            ctx.log(node.id, `Managed worktree refresh left unresolved git state, recreating: ${worktreePath}`);
-            cleanupBrokenManagedWorktree(repoRoot, worktreePath);
-          }
-        }
+        refreshManagedWorktreeReuse(
+          node.id,
+          ctx,
+          repoRoot,
+          worktreePath,
+          baseBranch,
+          baseBranchShort,
+          fetchTimeout,
+        );
         if (existsSync(worktreePath)) {
           ctx.data.worktreePath = worktreePath;
           ctx.data._worktreeCreated = false;
@@ -10767,6 +10942,7 @@ registerBuiltinNodeType("action.acquire_worktree", {
       }
 
       // Create fresh worktree
+      let attachedExistingBranch = false;
       try {
         execSync(
           `git worktree add "${worktreePath}" -b "${branch}" "${baseBranch}" 2>&1`,
@@ -10782,21 +10958,39 @@ registerBuiltinNodeType("action.acquire_worktree", {
             `git worktree add "${worktreePath}" "${branch}" 2>&1`,
             { cwd: repoRoot, encoding: "utf8", timeout: worktreeTimeout },
           );
+          attachedExistingBranch = true;
         } catch (reuseErr) {
           const existingBranchWorktree = findExistingWorktreePathForBranch(repoRoot, branch);
           if (existingBranchWorktree && existsSync(existingBranchWorktree)) {
-            if (!isValidGitWorktreePath(existingBranchWorktree) &&
-              isManagedBosunWorktree(existingBranchWorktree, repoRoot)
-            ) {
+            const existingWorktreeIsBroken = (
+              !isValidGitWorktreePath(existingBranchWorktree) ||
+              hasUnresolvedGitOperation(existingBranchWorktree)
+            ) && isManagedBosunWorktree(existingBranchWorktree, repoRoot);
+            if (existingWorktreeIsBroken) {
               ctx.log(
                 node.id,
-                `Existing branch worktree is invalid, recreating managed path: ${existingBranchWorktree}`,
+                `Existing branch worktree is invalid or unresolved, recreating managed path: ${existingBranchWorktree}`,
               );
               cleanupBrokenManagedWorktree(repoRoot, existingBranchWorktree);
             }
           }
           if (existingBranchWorktree && existsSync(existingBranchWorktree) &&
-            isValidGitWorktreePath(existingBranchWorktree)
+            isValidGitWorktreePath(existingBranchWorktree) &&
+            !hasUnresolvedGitOperation(existingBranchWorktree)
+          ) {
+            refreshManagedWorktreeReuse(
+              node.id,
+              ctx,
+              repoRoot,
+              existingBranchWorktree,
+              baseBranch,
+              baseBranchShort,
+              fetchTimeout,
+            );
+          }
+          if (existingBranchWorktree && existsSync(existingBranchWorktree) &&
+            isValidGitWorktreePath(existingBranchWorktree) &&
+            !hasUnresolvedGitOperation(existingBranchWorktree)
           ) {
             ctx.data.worktreePath = existingBranchWorktree;
             ctx.data._worktreeCreated = false;
@@ -10820,6 +11014,22 @@ registerBuiltinNodeType("action.acquire_worktree", {
           );
         }
       }
+      if (attachedExistingBranch) {
+        refreshManagedWorktreeReuse(
+          node.id,
+          ctx,
+          repoRoot,
+          worktreePath,
+          baseBranch,
+          baseBranchShort,
+          fetchTimeout,
+        );
+        if (!existsSync(worktreePath)) {
+          throw new Error(
+            `Worktree refresh failed for existing branch ${branch}; managed worktree was removed after stale refresh state`,
+          );
+        }
+      }
       fixGitConfigCorruption(repoRoot);
       const cleared3 = clearBlockedWorktreeIdentity(worktreePath);
       if (cleared3) ctx.log(node.id, `Cleared blocked test git identity from worktree: ${worktreePath}`);
@@ -10830,8 +11040,28 @@ registerBuiltinNodeType("action.acquire_worktree", {
       ctx.log(node.id, `Worktree created: ${worktreePath} (branch: ${branch}, base: ${baseBranch})`);
       return { success: true, worktreePath, created: true, branch, baseBranch };
     } catch (err) {
-      ctx.log(node.id, `Worktree acquisition failed: ${err.message}`);
-      return { success: false, error: err.message, branch, baseBranch };
+      const errorMessage = String(err?.message || err || "worktree_acquisition_failed");
+      const retryable = !/managed worktree was removed after stale refresh state/i.test(errorMessage);
+      const recordedAt = new Date().toISOString();
+      const autoRecoverDelayMs = retryable ? 0 : getNonRetryableWorktreeRecoveryMs();
+      const retryAt = retryable ? null : new Date(Date.now() + autoRecoverDelayMs).toISOString();
+      const blockedReason = retryable
+        ? errorMessage
+        : "Managed worktree refresh conflict detected; Bosun will retry automatically after cooldown.";
+      ctx.log(node.id, `Worktree acquisition failed: ${errorMessage}`);
+      return {
+        success: false,
+        error: errorMessage,
+        branch,
+        baseBranch,
+        retryable,
+        failureKind: retryable ? "worktree_acquisition_failed" : "branch_refresh_conflict",
+        recordedAt,
+        autoRecoverDelayMs,
+        retryAt,
+        blockedReason,
+        recoveryNote: retryable || !retryAt ? "" : ` — blocked until ${retryAt}`,
+      };
     }
   },
 });
@@ -10887,6 +11117,8 @@ registerBuiltinNodeType("action.release_worktree", {
         } catch { /* best-effort */ }
       }
 
+      fixGitConfigCorruption(repoRoot);
+
       ctx.data._worktreeCreated = false;
       ctx.data._worktreeManaged = false;
       ctx.log(node.id, `Worktree released: ${worktreePath}`);
@@ -11412,6 +11644,11 @@ registerBuiltinNodeType("action.build_task_prompt", {
           const content = library.getEntryContent?.(libraryRoot, entry);
           if (!content || (typeof content === "string" && !content.trim())) continue;
           const body = typeof content === "string" ? content.trim() : JSON.stringify(content, null, 2);
+          emitSkillInvokeEvent(skillId, entry.name || skillId, {
+            taskId,
+            executor: ctx.data?.resolvedSdk,
+            source: "library",
+          });
           librarySkillParts.push(`### Skill: ${entry.name || skillId} (\`${skillId}\`)`);
           librarySkillParts.push(body);
           librarySkillParts.push("");
@@ -11749,6 +11986,21 @@ registerBuiltinNodeType("action.push_branch", {
       }
     }
 
+    // ── Hard zero-diff guard (always active) ──
+    try {
+      const headSha = execSync("git rev-parse HEAD", {
+        cwd: worktreePath, encoding: "utf8", timeout: 5_000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      const mainSha = execSync("git rev-parse origin/main", {
+        cwd: worktreePath, encoding: "utf8", timeout: 5_000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      if (headSha && mainSha && headSha === mainSha) {
+        ctx.log(node.id, "HEAD is identical to origin/main — aborting push to prevent PR wipe");
+        ctx.data._pushSkipped = true;
+        return { success: false, error: "HEAD matches origin/main — refusing push", pushed: false };
+      }
+    } catch { /* best-effort */ }
+
     // ── Push ──
     const pushFlags = [];
     if (forceWithLease) pushFlags.push("--force-with-lease");