bosun 0.41.7 → 0.41.9

package/workflow/workflow-nodes.mjs

@@ -48,6 +48,7 @@ import { resolveAutoCommand } from "./project-detection.mjs";
 import { loadConfig } from "../config/config.mjs";
 import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
 import { clearBlockedWorktreeIdentity, normalizeBaseBranch } from "../git/git-safety.mjs";
+import { getBosunCoAuthorTrailer, shouldAddBosunCoAuthor } from "../git/git-commit-helpers.mjs";
 import { getGitHubToken, invalidateTokenType } from "../github/github-auth-manager.mjs";
 import {
   CUSTOM_NODE_DIR_NAME,
@@ -58,6 +59,8 @@ import {
   stopCustomNodeDiscovery,
 } from "./workflow-nodes/custom-loader.mjs";
 
+// CLAUDE:SUMMARY — workflow-nodes
+// Registers built-in workflow node types and shared prompt/runtime actions for Bosun workflows.
 const TAG = "[workflow-nodes]";
 let customLoadPromise = null;
 let customDiscoveryStarted = false;
@@ -966,6 +969,43 @@ async function createKanbanTaskWithProject(kanban, taskData = {}, projectIdValue
     payload.projectId = resolvedProjectId;
   }
 
+  const createTaskParamNames = (() => {
+    try {
+      const inspectTarget =
+        typeof kanban.createTask?.getMockImplementation === "function"
+          ? kanban.createTask.getMockImplementation() || kanban.createTask
+          : kanban.createTask;
+      const source = Function.prototype.toString.call(inspectTarget);
+      const parenMatch = source.match(/^[^(]*\(([^)]*)\)/s);
+      if (parenMatch) {
+        return String(parenMatch[1] || "")
+          .split(",")
+          .map((entry) =>
+            String(entry || "")
+              .trim()
+              .replace(/^\.{3}/, "")
+              .replace(/\s*=.*$/s, "")
+              .trim(),
+          )
+          .filter(Boolean);
+      }
+      const arrowMatch = source.match(/^(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/);
+      if (arrowMatch?.[1]) return [arrowMatch[1]];
+    } catch {
+      // Fall back to the project-aware signature when adapter source is opaque.
+    }
+    return [];
+  })();
+  const firstParamName = String(createTaskParamNames[0] || "").toLowerCase();
+  const payloadOnlyCreateTask =
+    createTaskParamNames.length === 1 &&
+    /(task|payload|spec|data)/i.test(firstParamName) &&
+    !/project/i.test(firstParamName);
+
+  if (payloadOnlyCreateTask) {
+    return kanban.createTask(payload);
+  }
+
   const taskPayload = { ...payload };
   delete taskPayload.projectId;
   return kanban.createTask(resolvedProjectId, taskPayload);
@@ -1368,7 +1408,7 @@ async function recoverTimedBlockedWorkflowTasks({ kanban, ctx, node, projectId }
     const autoRecovery = task?.meta?.autoRecovery;
     if (!autoRecovery || typeof autoRecovery !== "object") continue;
     if (autoRecovery.active === false) continue;
-    if (String(autoRecovery.reason || "").trim() !== "worktree_failure") continue;
+    // Accept any auto-recovery reason (worktree_failure, consecutive_errors, etc.)
     const retryAtMs = Date.parse(String(autoRecovery.retryAt || task?.cooldownUntil || ""));
     if (!Number.isFinite(retryAtMs) || retryAtMs > nowMs) continue;
     await kanban.updateTask(task.id, {
@@ -2305,7 +2345,9 @@ registerBuiltinNodeType("action.run_agent", {
     const timeoutMs = Number.isFinite(Number(resolvedTimeoutMs))
       ? Math.max(1000, Math.trunc(Number(resolvedTimeoutMs)))
       : 3600000;
-    const includeTaskContext = node.config?.includeTaskContext !== false;
+    const includeTaskContext =
+      node.config?.includeTaskContext !== false &&
+      ctx.data?._taskIncludeContext !== false;
     const configuredSystemPrompt =
       ctx.resolve(node.config?.systemPrompt || "") ||
       ctx.data?._taskSystemPrompt ||
@@ -2316,7 +2358,10 @@ registerBuiltinNodeType("action.run_agent", {
       .filter(Boolean)
       .join("\n\n");
     let finalPrompt = prompt;
-    if (includeTaskContext) {
+    const promptHasTaskContext =
+      ctx.data?._taskPromptIncludesTaskContext === true ||
+      String(finalPrompt || "").includes("## Task Context");
+    if (includeTaskContext && !promptHasTaskContext) {
       const explicitContext =
         ctx.data?.taskContext ||
         ctx.data?.taskContextBlock ||
@@ -8243,10 +8288,34 @@ const BOSUN_FUNCTION_REGISTRY = Object.freeze({
     async invoke(args, ctx) {
       const cwd = args.cwd || ctx.data?.worktreePath || ctx.data?.repoRoot || process.cwd();
       try {
-        const current = execSync("git branch --show-current", { encoding: "utf8", cwd, timeout: 15000, stdio: "pipe" }).trim();
-        const allBranches = execSync("git branch --list --format='%(refname:short)'", { encoding: "utf8", cwd, timeout: 15000, stdio: "pipe" })
-          .trim().split("\n").filter(Boolean);
-        return { current, branches: allBranches, branchCount: allBranches.length };
+        const lines = execFileSync("git", ["for-each-ref", "--format=%(HEAD)|%(refname:short)", "refs/heads"], {
+          encoding: "utf8",
+          cwd,
+          timeout: 4000,
+          stdio: "pipe",
+        })
+          .trim()
+          .split("\n")
+          .map((line) => line.trim())
+          .filter(Boolean);
+        const branches = [];
+        let current = "";
+        for (const line of lines) {
+          const [headMarker, ...rest] = line.split("|");
+          const branchName = rest.join("|").trim();
+          if (!branchName) continue;
+          branches.push(branchName);
+          if (headMarker === "*") current = branchName;
+        }
+        if (!current) {
+          current = execFileSync("git", ["branch", "--show-current"], {
+            encoding: "utf8",
+            cwd,
+            timeout: 2000,
+            stdio: "pipe",
+          }).trim();
+        }
+        return { current, branches, branchCount: branches.length };
       } catch (err) {
         return { current: "", branches: [], branchCount: 0, error: err.message };
       }
@@ -9429,6 +9498,7 @@ registerBuiltinNodeType("transform.mcp_extract", {
 /** Module-scope lazy caches for task lifecycle imports. */
 let _taskClaimsMod = null;
 let _taskClaimsInitPromise = null;
+let _taskClaimsInitRepoRoot = "";
 let _taskComplexityMod = null;
 let _kanbanAdapterMod = null;
 let _agentPoolMod = null;
@@ -9436,11 +9506,27 @@ let _libraryManagerMod = null;
 let _configMod = null;
 let _gitSafetyMod = null;
 let _diffStatsMod = null;
+let _sharedStateManagerMod = null;
+const SHARED_STATE_ACTIVE_STALE_THRESHOLD_MS =
+  Number(process.env.SHARED_STATE_STALE_THRESHOLD_MS) || 300_000;
+const TERMINAL_SHARED_STATE_STATUSES = new Set([
+  "complete",
+  "completed",
+  "failed",
+  "abandoned",
+  "released",
+]);
 
 async function ensureTaskClaimsMod() {
   if (!_taskClaimsMod) _taskClaimsMod = await import("../task/task-claims.mjs");
   return _taskClaimsMod;
 }
+async function ensureSharedStateManagerMod() {
+  if (!_sharedStateManagerMod) {
+    _sharedStateManagerMod = await import("../workspace/shared-state-manager.mjs");
+  }
+  return _sharedStateManagerMod;
+}
 function pickTaskString(...values) {
   for (const value of values) {
     const normalized = String(value || "").trim();
@@ -9512,21 +9598,91 @@ function resolveTaskRepositoryRoot(taskRepository, currentRepoRoot) {
   }
   return "";
 }
-async function ensureTaskClaimsInitialized(ctx, claims) {
+function sameResolvedPath(leftPath, rightPath) {
+  const left = resolve(String(leftPath || ""));
+  const right = resolve(String(rightPath || ""));
+  if (process.platform === "win32") {
+    return left.toLowerCase() === right.toLowerCase();
+  }
+  return left === right;
+}
+async function ensureTaskClaimsInitialized(ctx, claims, explicitRepoRoot = "") {
   if (typeof claims?.initTaskClaims !== "function") return;
-  if (!_taskClaimsInitPromise) {
-    const repoRoot = pickTaskString(
-      ctx?.data?.repoRoot,
-      ctx?.data?.workspace,
-      process.cwd(),
-    );
+  const requestedRepoRoot = pickTaskString(
+    explicitRepoRoot,
+    ctx?.data?.repoRoot,
+    ctx?.data?.workspace,
+    process.cwd(),
+  );
+  const repoRoot =
+    resolveTaskRepositoryRoot("", requestedRepoRoot)
+    || requestedRepoRoot
+    || process.cwd();
+  if (!_taskClaimsInitPromise || !sameResolvedPath(_taskClaimsInitRepoRoot, repoRoot)) {
+    _taskClaimsInitRepoRoot = repoRoot;
     _taskClaimsInitPromise = claims.initTaskClaims({ repoRoot }).catch((err) => {
       _taskClaimsInitPromise = null;
+      _taskClaimsInitRepoRoot = "";
       throw err;
     });
   }
   await _taskClaimsInitPromise;
 }
+function isSharedStateOwnershipActive(state, now = Date.now()) {
+  if (!state || typeof state !== "object") return false;
+  const ownerId = pickTaskString(state.ownerId, state.owner_id);
+  if (!ownerId) return false;
+  const attemptStatus = pickTaskString(state.attemptStatus, state.attempt_status).toLowerCase();
+  if (attemptStatus && TERMINAL_SHARED_STATE_STATUSES.has(attemptStatus)) return false;
+  const heartbeatText = pickTaskString(state.ownerHeartbeat, state.owner_heartbeat);
+  const heartbeatMs = Date.parse(heartbeatText);
+  if (!Number.isFinite(heartbeatMs)) return false;
+  if (now - heartbeatMs > SHARED_STATE_ACTIVE_STALE_THRESHOLD_MS) return false;
+  return true;
+}
+async function getPersistedOwnedTaskIds(node, ctx) {
+  const requestedRepoRoot = pickTaskString(
+    cfgOrCtx(node, ctx, "repoRoot"),
+    ctx?.data?.repoRoot,
+    ctx?.data?.workspace,
+    process.cwd(),
+  );
+  const repoRoot =
+    resolveTaskRepositoryRoot("", requestedRepoRoot)
+    || requestedRepoRoot
+    || process.cwd();
+  const activeTaskIds = new Set();
+  try {
+    const claims = await ensureTaskClaimsMod();
+    await ensureTaskClaimsInitialized(ctx, claims, repoRoot);
+    if (typeof claims.listClaims === "function") {
+      const persistedClaims = await claims.listClaims();
+      for (const claim of persistedClaims || []) {
+        const taskId = pickTaskString(claim?.task_id, claim?.taskId);
+        if (taskId) activeTaskIds.add(taskId);
+      }
+    }
+  } catch (err) {
+    ctx?.log?.(node.id, `Persisted claim filter warning: ${err?.message || err}`);
+  }
+  try {
+    const sharedStateManager = await ensureSharedStateManagerMod();
+    if (typeof sharedStateManager.getAllSharedStates === "function") {
+      const sharedStates = await sharedStateManager.getAllSharedStates(repoRoot);
+      const now = Date.now();
+      for (const [rawTaskId, state] of Object.entries(sharedStates || {})) {
+        const taskId = pickTaskString(state?.taskId, state?.task_id, rawTaskId);
+        if (!taskId) continue;
+        if (isSharedStateOwnershipActive(state, now)) {
+          activeTaskIds.add(taskId);
+        }
+      }
+    }
+  } catch (err) {
+    ctx?.log?.(node.id, `Shared state filter warning: ${err?.message || err}`);
+  }
+  return activeTaskIds;
+}
 async function ensureTaskComplexityMod() {
   if (!_taskComplexityMod) _taskComplexityMod = await import("../task/task-complexity.mjs");
   return _taskComplexityMod;
@@ -9877,7 +10033,7 @@ function refreshManagedWorktreeReuse(
   if (!existsSync(worktreePath) || shouldSkipGitRefreshForTests()) return existsSync(worktreePath);
   let refreshError = "";
   try {
-    execSync(`git pull --rebase origin ${baseBranchShort}`, {
+    execGitArgsSync(["pull", "--rebase", "origin", baseBranchShort], {
       cwd: worktreePath,
       encoding: "utf8",
       timeout: fetchTimeout,
@@ -10078,8 +10234,32 @@ registerBuiltinNodeType("trigger.task_available", {
       return true;
     });
 
+    let persistedOwnershipFilteredCount = 0;
+    if (status === "todo" && tasks.length > 0) {
+      const persistedOwnedTaskIds = await getPersistedOwnedTaskIds(node, ctx);
+      if (persistedOwnedTaskIds.size > 0) {
+        const beforeFilterCount = tasks.length;
+        tasks = tasks.filter((task) => {
+          const taskId = pickTaskString(task?.id, task?.task_id);
+          return taskId && !persistedOwnedTaskIds.has(taskId);
+        });
+        persistedOwnershipFilteredCount = beforeFilterCount - tasks.length;
+        if (persistedOwnershipFilteredCount > 0) {
+          ctx.log(
+            node.id,
+            `Persisted ownership filtered ${persistedOwnershipFilteredCount} task(s) with live claims/shared state`,
+          );
+        }
+      }
+    }
+
     if (tasks.length === 0) {
-      return { triggered: false, reason: "all_filtered", taskCount: 0 };
+      return {
+        triggered: false,
+        reason: "all_filtered",
+        taskCount: 0,
+        persistedOwnershipFilteredCount,
+      };
     }
 
     let benchmarkMode = null;
@@ -10343,6 +10523,7 @@ registerBuiltinNodeType("trigger.task_available", {
       taskCount: toDispatch.length,
       availableSlots: remaining,
       selectedTaskId: primaryTask ? pickTaskString(primaryTask.id, primaryTask.task_id) : "",
+      persistedOwnershipFilteredCount,
       auditEvents: startGuardAuditEvents,
       benchmarkMode,
     };
@@ -10956,7 +11137,7 @@ registerBuiltinNodeType("action.acquire_worktree", {
       const baseBranchShort = baseBranch.replace(/^origin\//, "");
       if (!shouldSkipGitRefreshForTests()) {
         try {
-          execSync(`git fetch origin ${baseBranchShort} --no-tags`, {
+          execGitArgsSync(["fetch", "origin", baseBranchShort, "--no-tags"], {
             cwd: repoRoot, encoding: "utf8",
             timeout: fetchTimeout,
             stdio: ["ignore", "pipe", "pipe"],
@@ -10973,7 +11154,7 @@ registerBuiltinNodeType("action.acquire_worktree", {
 
       // Ensure long paths are enabled for this repo before checkout.
       try {
-        execSync("git config --local core.longpaths true", {
+        execGitArgsSync(["config", "--local", "core.longpaths", "true"], {
           cwd: repoRoot,
           encoding: "utf8",
           timeout: 5000,
@@ -11017,18 +11198,66 @@ registerBuiltinNodeType("action.acquire_worktree", {
       // Create fresh worktree
       let attachedExistingBranch = false;
       try {
-        execSync(
-          `git worktree add "${worktreePath}" -b "${branch}" "${baseBranch}" 2>&1`,
+        execGitArgsSync(
+          ["worktree", "add", worktreePath, "-b", branch, baseBranch],
           { cwd: repoRoot, encoding: "utf8", timeout: worktreeTimeout },
         );
       } catch (createErr) {
         if (!isExistingBranchWorktreeError(createErr)) {
           throw new Error(`Worktree creation failed: ${formatExecSyncError(createErr)}`);
         }
+        const existingBranchWorktree = findExistingWorktreePathForBranch(repoRoot, branch);
+        if (existingBranchWorktree && existsSync(existingBranchWorktree)) {
+          const existingWorktreeIsBroken = (
+            !isValidGitWorktreePath(existingBranchWorktree) ||
+            hasUnresolvedGitOperation(existingBranchWorktree)
+          ) && isManagedBosunWorktree(existingBranchWorktree, repoRoot);
+          if (existingWorktreeIsBroken) {
+            ctx.log(
+              node.id,
+              `Existing branch worktree is invalid or unresolved, recreating managed path: ${existingBranchWorktree}`,
+            );
+            cleanupBrokenManagedWorktree(repoRoot, existingBranchWorktree);
+          }
+        }
+        if (existingBranchWorktree && existsSync(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;
+          ctx.data._worktreeManaged = true;
+          ctx.log(node.id, `Reusing existing branch worktree: ${existingBranchWorktree}`);
+          const cleared2 = clearBlockedWorktreeIdentity(existingBranchWorktree);
+          if (cleared2) ctx.log(node.id, `Cleared blocked test git identity from worktree: ${existingBranchWorktree}`);
+          return {
+            success: true,
+            worktreePath: existingBranchWorktree,
+            created: false,
+            reused: true,
+            reusedExistingBranch: true,
+            branch,
+            baseBranch,
+          };
+        }
         // Branch already exists — attach worktree to existing branch.
         try {
-          execSync(
-            `git worktree add "${worktreePath}" "${branch}" 2>&1`,
+          execGitArgsSync(
+            ["worktree", "add", worktreePath, branch],
             { cwd: repoRoot, encoding: "utf8", timeout: worktreeTimeout },
           );
           attachedExistingBranch = true;
@@ -11171,22 +11400,22 @@ registerBuiltinNodeType("action.release_worktree", {
     }
 
     try {
-      if (existsSync(worktreePath)) {
-        try {
-          execSync(`git worktree remove "${worktreePath}" --force`, {
-            cwd: repoRoot, encoding: "utf8", timeout: removeTimeout,
-            stdio: ["ignore", "pipe", "pipe"],
-          });
+    if (existsSync(worktreePath)) {
+      try {
+        execGitArgsSync(["worktree", "remove", String(worktreePath), "--force"], {
+          cwd: repoRoot, encoding: "utf8", timeout: removeTimeout,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
         } catch {
           /* best-effort — directory might already be gone */
         }
       }
 
-      if (shouldPrune) {
-        try {
-          execSync("git worktree prune", {
-            cwd: repoRoot, encoding: "utf8", timeout: 15000,
-          });
+    if (shouldPrune) {
+      try {
+        execGitArgsSync(["worktree", "prune"], {
+          cwd: repoRoot, encoding: "utf8", timeout: 15000,
+        });
         } catch { /* best-effort */ }
       }
 
@@ -11380,6 +11609,7 @@ registerBuiltinNodeType("action.build_task_prompt", {
       retryReason: { type: "string", description: "Reason for retry (if retrying)" },
       includeAgentsMd: { type: "boolean", default: true },
       includeComments: { type: "boolean", default: true },
+      includeGitContext: { type: "boolean", default: true },
       includeStatusEndpoint: { type: "boolean", default: true },
       promptTemplate: { type: "string", description: "Custom template (overrides)" },
     },
@@ -11396,7 +11626,10 @@ registerBuiltinNodeType("action.build_task_prompt", {
     const repoSlug = cfgOrCtx(node, ctx, "repoSlug");
     const retryReason = cfgOrCtx(node, ctx, "retryReason");
     const includeAgentsMd = node.config?.includeAgentsMd !== false;
+    const includeComments = node.config?.includeComments !== false;
+    const includeGitContext = node.config?.includeGitContext !== false;
     const includeStatusEndpoint = node.config?.includeStatusEndpoint !== false;
+    ctx.data._taskIncludeContext = includeComments;
     const customTemplate = cfgOrCtx(node, ctx, "promptTemplate");
     const taskPayload =
       ctx.data?.task && typeof ctx.data.task === "object"
@@ -11407,9 +11640,19 @@ registerBuiltinNodeType("action.build_task_prompt", {
         ? taskPayload.meta
         : null;
 
+    const TASK_TEMPLATE_PLACEHOLDER_RE = /^\{\{\s*[\w.-]+\s*\}\}$/;
+    const TASK_PROMPT_INVALID_VALUES = new Set([
+      "internal server error",
+      "{\"ok\":false,\"error\":\"internal server error\"}",
+      "{\"error\":\"internal server error\"}",
+    ]);
     const normalizeString = (value) => {
       if (value == null) return "";
-      return String(value).trim();
+      const text = String(value).trim();
+      if (!text) return "";
+      if (TASK_TEMPLATE_PLACEHOLDER_RE.test(text)) return "";
+      if (TASK_PROMPT_INVALID_VALUES.has(text.toLowerCase())) return "";
+      return text;
     };
     const pickFirstString = (...values) => {
       for (const value of values) {
@@ -11454,6 +11697,32 @@ registerBuiltinNodeType("action.build_task_prompt", {
       if (ctxValue != null && ctxValue !== "") return ctxValue;
       return null;
     };
+    const normalizedTaskId = pickFirstString(
+      resolvePromptValue("taskId"),
+      taskPayload?.id,
+      taskPayload?.taskId,
+      taskMeta?.taskId,
+      taskId,
+    );
+    const normalizedTaskTitle = pickFirstString(
+      resolvePromptValue("taskTitle"),
+      taskPayload?.title,
+      taskMeta?.taskTitle,
+      taskTitle,
+    ) || (normalizedTaskId ? `Task ${normalizedTaskId}` : "Untitled task");
+    const normalizedTaskDescription = pickFirstString(
+      resolvePromptValue("taskDescription"),
+      taskPayload?.description,
+      taskPayload?.body,
+      taskMeta?.taskDescription,
+      taskDescription,
+    );
+    const normalizedBranch = normalizeString(branch);
+    const normalizedBaseBranch = normalizeString(baseBranch);
+    const normalizedWorktreePath = normalizeString(worktreePath);
+    const normalizedRepoRoot = normalizeString(repoRoot) || process.cwd();
+    const normalizedRepoSlug = normalizeString(repoSlug);
+    const normalizedRetryReason = normalizeString(retryReason);
     const workspace = pickFirstString(
       resolvePromptValue("workspace"),
       taskPayload?.workspace,
@@ -11470,76 +11739,69 @@ registerBuiltinNodeType("action.build_task_prompt", {
       taskPayload?.repositories,
       taskMeta?.repositories,
     );
-    const primaryRepository = pickFirstString(repository, repoSlug);
+    const primaryRepository = pickFirstString(repository, normalizedRepoSlug);
     const allowedRepositories = normalizeStringArray(repositories, primaryRepository);
-    const matchedSkills = findRelevantSkills(repoRoot, taskTitle, taskDescription || "", {});
+    const matchedSkills = findRelevantSkills(
+      normalizedRepoRoot,
+      normalizedTaskTitle,
+      normalizedTaskDescription || "",
+      {},
+    );
     const activeSkillFiles = matchedSkills.map((skill) => skill.filename);
     const strictCacheAnchoring =
       String(process.env.BOSUN_CACHE_ANCHOR_MODE || "")
         .trim()
         .toLowerCase() === "strict";
+    const customTemplateValues = {
+      taskId: normalizedTaskId,
+      taskTitle: normalizedTaskTitle,
+      taskDescription: normalizedTaskDescription,
+      branch: normalizedBranch,
+      baseBranch: normalizedBaseBranch,
+      worktreePath: normalizedWorktreePath,
+      repoRoot: normalizedRepoRoot,
+      repoSlug: normalizedRepoSlug,
+      workspace,
+      repository: primaryRepository,
+      repositories: allowedRepositories.join(", "),
+      retryReason: normalizedRetryReason,
+    };
+    const renderCustomTemplate = (template) => {
+      const lookup = new Map();
+      const register = (key, value) => {
+        const normalizedKey = String(key || "").trim();
+        if (!normalizedKey) return;
+        const normalizedValue = normalizeString(value);
+        lookup.set(normalizedKey, normalizedValue);
+        lookup.set(normalizedKey.toLowerCase(), normalizedValue);
+        lookup.set(normalizedKey.toUpperCase(), normalizedValue);
+      };
+      for (const [key, value] of Object.entries(customTemplateValues)) {
+        register(key, value);
+        register(key.replace(/([a-z0-9])([A-Z])/g, "$1_$2"), value);
+      }
+      return String(template || "")
+        .replace(/\{\{\s*([A-Za-z0-9_.-]+)\s*\}\}/g, (_full, key) => {
+          const lookupKey = String(key || "").trim();
+          if (!lookupKey) return "";
+          if (lookup.has(lookupKey)) return lookup.get(lookupKey);
+          if (lookup.has(lookupKey.toLowerCase())) return lookup.get(lookupKey.toLowerCase());
+          if (lookup.has(lookupKey.toUpperCase())) return lookup.get(lookupKey.toUpperCase());
+          return "";
+        })
+        .split("\n")
+        .map((line) => line.replace(/[ \t]+$/g, ""))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    };
 
     const buildStableSystemPrompt = () => {
       const systemParts = [];
-      if (includeAgentsMd) {
-        const searchDirs = [repoRoot].filter(Boolean);
-        const docFiles = ["AGENTS.md", ".github/copilot-instructions.md"];
-        const loaded = new Set();
-        for (const dir of searchDirs) {
-          for (const doc of docFiles) {
-            if (loaded.has(doc)) continue;
-            const fullPath = resolve(dir, doc);
-            try {
-              if (!existsSync(fullPath)) continue;
-              const content = readFileSync(fullPath, "utf8").trim();
-              if (!content || content.length <= 10) continue;
-              loaded.add(doc);
-              systemParts.push(`## ${doc}`);
-              systemParts.push(content);
-              systemParts.push("");
-            } catch {
-              // best-effort only
-            }
-          }
-        }
-      }
-
-      if (includeStatusEndpoint) {
-        const port = process.env.AGENT_ENDPOINT_PORT || process.env.BOSUN_AGENT_ENDPOINT_PORT || "";
-        if (port) {
-          systemParts.push("## Agent Status Endpoint");
-          systemParts.push(`POST http://127.0.0.1:${port}/status — Report progress`);
-          systemParts.push(`POST http://127.0.0.1:${port}/heartbeat — Heartbeat ping`);
-          systemParts.push(`POST http://127.0.0.1:${port}/error — Report errors`);
-          systemParts.push(`POST http://127.0.0.1:${port}/complete — Signal completion`);
-          systemParts.push("");
-        }
-      }
-
-      systemParts.push("## Tool Discovery");
-      systemParts.push(
-        "Bosun uses a compact MCP discovery layer for external MCP servers and the custom tool library.",
-      );
-      systemParts.push(
-        "Preferred flow: `search` -> `get_schema` -> `execute`.",
-      );
-      systemParts.push(
-        "Only eager tools are preloaded below to keep context small. Use `call_discovered_tool` only as a direct fallback when orchestration code is unnecessary.",
-      );
+      systemParts.push("You are an autonomous software engineering agent inside the Bosun orchestrator.");
+      systemParts.push("Follow the project guidance provided in the user message and execute tasks end-to-end.");
       systemParts.push("");
 
-      const eagerToolBlock = getToolsPromptBlock(repoRoot, {
-        includeBuiltins: true,
-        eagerOnly: true,
-        discoveryMode: true,
-        emitReflectHint: true,
-        limit: 12,
-      });
-      if (eagerToolBlock) {
-        systemParts.push(eagerToolBlock);
-        systemParts.push("");
-      }
-
       systemParts.push("## Instructions");
       systemParts.push(
         "1. Follow the project instructions in AGENTS.md.\n" +
@@ -11550,23 +11812,78 @@ registerBuiltinNodeType("action.build_task_prompt", {
           "6. Never ask for user input — you are autonomous.\n" +
           "7. Use all available tools to verify your work.",
       );
-      systemParts.push("");
-      systemParts.push("## Git Attribution");
-      systemParts.push("Add this trailer to all commits:");
-      systemParts.push("Co-authored-by: bosun[bot] <bosun@virtengine.com>");
       return systemParts.join("\n").trim();
     };
 
+    const assertStableSystemPrompt = (candidate) => {
+      if (!strictCacheAnchoring) return;
+      const dynamicMarkers = [
+        normalizedTaskId,
+        normalizedTaskTitle,
+        normalizedTaskDescription,
+        normalizedRetryReason,
+        normalizedBranch,
+        normalizedBaseBranch,
+        normalizedWorktreePath,
+      ]
+        .map((value) => String(value || "").trim())
+        .filter(Boolean);
+      const leaked = dynamicMarkers.find((marker) => candidate.includes(marker));
+      if (leaked) {
+        throw new Error(
+          `BOSUN_CACHE_ANCHOR_MODE=strict violation: system prompt leaked task-specific marker "${leaked}"`,
+        );
+      }
+    };
+
+    const buildGitContextBlock = async () => {
+      if (!includeGitContext) return "";
+      const root = normalizedWorktreePath || normalizedRepoRoot;
+      if (!root) return "";
+      if (!existsSync(resolve(root, ".git"))) return "";
+
+      try {
+        const diffStatsMod = await ensureDiffStatsMod();
+        const commits =
+          diffStatsMod.getRecentCommits?.(root, 8) || [];
+        let diffSummary =
+          diffStatsMod.getCompactDiffSummary?.(root, {
+            baseBranch: normalizedBaseBranch || "origin/main",
+          }) || "";
+
+        if (diffSummary && diffSummary.length > 2000) {
+          diffSummary = `${diffSummary.slice(0, 2000)}…`;
+        }
+
+        const lines = ["## Git Context"];
+        if (Array.isArray(commits) && commits.length > 0) {
+          lines.push("### Recent Commits");
+          for (const commit of commits) lines.push(`- ${commit}`);
+        }
+        if (diffSummary && diffSummary !== "(no diff stats available)") {
+          lines.push("### Diff Summary");
+          lines.push("```");
+          lines.push(diffSummary);
+          lines.push("```");
+        }
+        return lines.length > 1 ? lines.join("\n") : "";
+      } catch {
+        return "";
+      }
+    };
+
     if (customTemplate) {
+      const renderedTemplate = renderCustomTemplate(customTemplate);
       const stableSystemPrompt = buildStableSystemPrompt();
-      ctx.data._taskPrompt = customTemplate;
-      ctx.data._taskUserPrompt = customTemplate;
+      assertStableSystemPrompt(stableSystemPrompt);
+      ctx.data._taskPrompt = renderedTemplate;
+      ctx.data._taskUserPrompt = renderedTemplate;
       ctx.data._taskSystemPrompt = stableSystemPrompt;
-      ctx.log(node.id, `Prompt from custom template (${customTemplate.length} chars)`);
+      ctx.log(node.id, `Prompt from custom template (${renderedTemplate.length} chars)`);
       return {
         success: true,
-        prompt: customTemplate,
-        userPrompt: customTemplate,
+        prompt: renderedTemplate,
+        userPrompt: renderedTemplate,
         systemPrompt: stableSystemPrompt,
         source: "custom",
       };
@@ -11575,33 +11892,48 @@ registerBuiltinNodeType("action.build_task_prompt", {
     const userParts = [];
 
     // Header
-    userParts.push(`# Task: ${taskTitle}`);
-    if (taskId) userParts.push(`Task ID: ${taskId}`);
+    userParts.push(`# Task: ${normalizedTaskTitle}`);
+    if (normalizedTaskId) userParts.push(`Task ID: ${normalizedTaskId}`);
     userParts.push("");
 
     // Retry context (if applicable)
-    if (retryReason) {
+    if (normalizedRetryReason) {
       userParts.push("## Retry Context");
-      userParts.push(`Previous attempt failed: ${retryReason}`);
+      userParts.push(`Previous attempt failed: ${normalizedRetryReason}`);
       userParts.push("Try a different approach this time.");
       userParts.push("");
     }
 
     // Description
-    if (taskDescription) {
+    if (normalizedTaskDescription) {
       userParts.push("## Description");
-      userParts.push(taskDescription);
+      userParts.push(normalizedTaskDescription);
+      userParts.push("");
+    }
+
+    if (includeComments) {
+      const taskContextBlock = buildTaskContextBlock(taskPayload);
+      if (taskContextBlock) {
+        userParts.push(taskContextBlock);
+        userParts.push("");
+        ctx.data._taskPromptIncludesTaskContext = true;
+      }
+    }
+
+    const gitContextBlock = await buildGitContextBlock();
+    if (gitContextBlock) {
+      userParts.push(gitContextBlock);
       userParts.push("");
     }
 
     // Environment context
     userParts.push("## Environment");
     const envLines = [];
-    if (worktreePath) envLines.push(`- **Working Directory:** ${worktreePath}`);
-    if (branch) envLines.push(`- **Branch:** ${branch}`);
-    if (baseBranch) envLines.push(`- **Base Branch:** ${baseBranch}`);
-    if (repoSlug) envLines.push(`- **Repository:** ${repoSlug}`);
-    if (repoRoot) envLines.push(`- **Repo Root:** ${repoRoot}`);
+    if (normalizedWorktreePath) envLines.push(`- **Working Directory:** ${normalizedWorktreePath}`);
+    if (normalizedBranch) envLines.push(`- **Branch:** ${normalizedBranch}`);
+    if (normalizedBaseBranch) envLines.push(`- **Base Branch:** ${normalizedBaseBranch}`);
+    if (normalizedRepoSlug) envLines.push(`- **Repository:** ${normalizedRepoSlug}`);
+    if (normalizedRepoRoot) envLines.push(`- **Repo Root:** ${normalizedRepoRoot}`);
     if (envLines.length) userParts.push(envLines.join("\n"));
     userParts.push("");
 
@@ -11617,11 +11949,11 @@ registerBuiltinNodeType("action.build_task_prompt", {
     } else {
       userParts.push("- **Allowed Repositories:** (not declared)");
     }
-    if (worktreePath) userParts.push(`- **Write Scope Root:** ${worktreePath}`);
+    if (normalizedWorktreePath) userParts.push(`- **Write Scope Root:** ${normalizedWorktreePath}`);
     userParts.push("");
     userParts.push("Hard boundaries:");
-    if (worktreePath) {
-      userParts.push(`1. Modify files only inside \`${worktreePath}\`.`);
+    if (normalizedWorktreePath) {
+      userParts.push(`1. Modify files only inside \`${normalizedWorktreePath}\`.`);
     } else {
       userParts.push("1. Modify files only inside the active repository working directory.");
     }
@@ -11653,7 +11985,7 @@ registerBuiltinNodeType("action.build_task_prompt", {
 
     // AGENTS.md + copilot-instructions.md
     if (includeAgentsMd) {
-      const searchDirs = [worktreePath || repoRoot, repoRoot].filter(Boolean);
+      const searchDirs = [normalizedWorktreePath || normalizedRepoRoot, normalizedRepoRoot].filter(Boolean);
       const docFiles = ["AGENTS.md", ".github/copilot-instructions.md"];
       const loaded = new Set();
       for (const dir of searchDirs) {
@@ -11688,10 +12020,36 @@ registerBuiltinNodeType("action.build_task_prompt", {
       }
     }
 
+    userParts.push("## Tool Discovery");
+    userParts.push(
+      "Bosun uses a compact MCP discovery layer for external MCP servers and the custom tool library.",
+    );
+    userParts.push(
+      "Preferred flow: `search` -> `get_schema` -> `execute`.",
+    );
+    userParts.push(
+      "Only eager tools are preloaded below to keep context small. Use `call_discovered_tool` only as a direct fallback when orchestration code is unnecessary.",
+    );
+    userParts.push("");
+
+    // Skill-driven eager tools belong with task context to preserve cache anchoring.
+    const taskScopedEagerTools = getToolsPromptBlock(normalizedRepoRoot, {
+      activeSkills: activeSkillFiles,
+      includeBuiltins: true,
+      eagerOnly: true,
+      discoveryMode: true,
+      emitReflectHint: true,
+      limit: 12,
+    });
+    if (taskScopedEagerTools) {
+      userParts.push(taskScopedEagerTools);
+      userParts.push("");
+    }
+
     const relevantSkillsBlock = buildRelevantSkillsPromptBlock(
-      repoRoot,
-      taskTitle,
-      taskDescription || "",
+      normalizedRepoRoot,
+      normalizedTaskTitle,
+      normalizedTaskDescription || "",
       {},
     );
     if (relevantSkillsBlock) {
@@ -11707,7 +12065,7 @@ registerBuiltinNodeType("action.build_task_prompt", {
     if (librarySkillIds.length > 0) {
       try {
         const library = await ensureLibraryManagerMod();
-        const libraryRoot = repoRoot || process.cwd();
+        const libraryRoot = normalizedRepoRoot || process.cwd();
         const fsSkillNames = new Set(matchedSkills.map((s) => String(s.filename || "").replace(/\.md$/i, "").toLowerCase()));
         const librarySkillParts = [];
         for (const skillId of librarySkillIds) {
@@ -11718,7 +12076,7 @@ registerBuiltinNodeType("action.build_task_prompt", {
           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,
+            taskId: normalizedTaskId,
             executor: ctx.data?.resolvedSdk,
             source: "library",
           });
@@ -11734,42 +12092,20 @@ registerBuiltinNodeType("action.build_task_prompt", {
         ctx.log(node.id, `Library skill injection failed (non-fatal): ${err.message}`);
       }
     }
-    // Skill-driven eager tools belong with task context to preserve cache anchoring.
-    const taskScopedEagerTools = getToolsPromptBlock(repoRoot, {
-      activeSkills: activeSkillFiles,
-      includeBuiltins: true,
-      eagerOnly: true,
-      discoveryMode: true,
-      emitReflectHint: false,
-      limit: 12,
-    });
-    if (taskScopedEagerTools) {
-      userParts.push(taskScopedEagerTools);
+
+    const coAuthorTrailer = shouldAddBosunCoAuthor({ taskId: normalizedTaskId })
+      ? getBosunCoAuthorTrailer()
+      : "";
+    if (coAuthorTrailer) {
+      userParts.push("## Git Attribution");
+      userParts.push("Add this trailer to all commits:");
+      userParts.push(coAuthorTrailer);
       userParts.push("");
     }
 
     const userPrompt = userParts.join("\n").trim();
     const systemPrompt = buildStableSystemPrompt();
-
-    if (strictCacheAnchoring) {
-      const dynamicMarkers = [
-        taskId,
-        taskTitle,
-        taskDescription,
-        retryReason,
-        branch,
-        baseBranch,
-        worktreePath,
-      ]
-        .map((value) => String(value || "").trim())
-        .filter(Boolean);
-      const leaked = dynamicMarkers.find((marker) => systemPrompt.includes(marker));
-      if (leaked) {
-        throw new Error(
-          `BOSUN_CACHE_ANCHOR_MODE=strict violation: system prompt leaked task-specific marker "${leaked}"`,
-        );
-      }
-    }
+    assertStableSystemPrompt(systemPrompt);
 
     ctx.data._taskPrompt = userPrompt;
     ctx.data._taskUserPrompt = userPrompt;