bosun 0.41.0 → 0.41.2

package/workflow/workflow-nodes.mjs

@@ -17,7 +17,13 @@
  *   schema → object                             — JSON Schema for node config
  */
 
-import { registerNodeType } from "./workflow-engine.mjs";
+import {
+  getNodeType,
+  listNodeTypes,
+  NodeStatus,
+  registerNodeType,
+  unregisterNodeType,
+} from "./workflow-engine.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";
@@ -35,8 +41,18 @@ import {
 import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
 import { clearBlockedWorktreeIdentity } from "../git/git-safety.mjs";
 import { getGitHubToken, invalidateTokenType } from "../github/github-auth-manager.mjs";
+import {
+  CUSTOM_NODE_DIR_NAME,
+  ensureCustomWorkflowNodesLoaded,
+  getCustomNodeDir,
+  scaffoldCustomNodeFile,
+  startCustomNodeDiscovery,
+  stopCustomNodeDiscovery,
+} from "./workflow-nodes/custom-loader.mjs";
 
 const TAG = "[workflow-nodes]";
+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 WORKFLOW_AGENT_HEARTBEAT_MS = (() => {
@@ -51,6 +67,394 @@ const WORKFLOW_AGENT_EVENT_PREVIEW_LIMIT = (() => {
 })();
 const BOSUN_ATTACHED_PR_LABEL = "bosun-attached";
 
+const HTML_TEXT_BREAK_TAGS = new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "br",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul",
+]);
+
+function decodeHtmlEntities(value = "") {
+  return String(value).replace(/&(?:nbsp|amp|lt|gt|quot|apos|#39|#\d+|#x[0-9a-f]+);/gi, (entity) => {
+    const normalized = entity.toLowerCase();
+    switch (normalized) {
+      case " ":
+        return " ";
+      case "&":
+        return "&";
+      case "<":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&quot;":
+        return '"';
+      case "&apos;":
+      case "&#39;":
+        return "'";
+      default:
+        if (normalized.startsWith("&#x")) {
+          return String.fromCodePoint(Number.parseInt(normalized.slice(3, -1), 16));
+        }
+        if (normalized.startsWith("&#")) {
+          return String.fromCodePoint(Number.parseInt(normalized.slice(2, -1), 10));
+        }
+        return entity;
+    }
+  });
+}
+
+function stripHtmlToText(html = "") {
+  const input = String(html ?? "");
+  let plain = "";
+  let index = 0;
+  let skippedTagName = null;
+
+  while (index < input.length) {
+    const tagStart = input.indexOf("<", index);
+    if (tagStart === -1) {
+      if (!skippedTagName) plain += input.slice(index);
+      break;
+    }
+
+    if (!skippedTagName && tagStart > index) {
+      plain += input.slice(index, tagStart);
+    }
+
+    const tagEnd = input.indexOf(">", tagStart + 1);
+    if (tagEnd === -1) {
+      if (!skippedTagName) plain += input.slice(tagStart).replace(/</g, " ");
+      break;
+    }
+
+    const rawTag = input.slice(tagStart + 1, tagEnd).trim();
+    const loweredTag = rawTag.toLowerCase();
+    const isClosingTag = loweredTag.startsWith("/");
+    const normalizedTag = isClosingTag ? loweredTag.slice(1).trimStart() : loweredTag;
+    const tagName = normalizedTag.match(/^[a-z0-9]+/i)?.[0] ?? "";
+
+    if (skippedTagName) {
+      if (isClosingTag && tagName === skippedTagName) {
+        skippedTagName = null;
+        plain += " ";
+      }
+      index = tagEnd + 1;
+      continue;
+    }
+
+    if (tagName === "script" || tagName === "style") {
+      if (!isClosingTag && !normalizedTag.endsWith("/")) {
+        skippedTagName = tagName;
+      }
+      index = tagEnd + 1;
+      continue;
+    }
+
+    if (HTML_TEXT_BREAK_TAGS.has(tagName)) {
+      plain += " ";
+    }
+
+    index = tagEnd + 1;
+  }
+
+  return decodeHtmlEntities(plain);
+}
+
+
+const PORT_TYPE_DESCRIPTIONS = Object.freeze({
+  Any: "Wildcard payload",
+  TaskDef: "Task definition/context payload",
+  TriggerEvent: "Event payload emitted by trigger nodes",
+  AgentResult: "Agent execution output",
+  String: "Text payload",
+  Boolean: "Boolean flag",
+  Number: "Numeric payload",
+  JSON: "Structured JSON payload",
+  GitRef: "Git branch/hash/ref payload",
+  PRUrl: "Pull request URL payload",
+  LogStream: "Log output or command transcript",
+  SessionRef: "Session identifier payload",
+  CommandResult: "Command execution result",
+});
+
+const PORT_TYPE_COLORS = Object.freeze({
+  Any: "#9ca3af",
+  TaskDef: "#10b981",
+  TriggerEvent: "#22c55e",
+  AgentResult: "#8b5cf6",
+  String: "#3b82f6",
+  Boolean: "#14b8a6",
+  Number: "#0ea5e9",
+  JSON: "#06b6d4",
+  GitRef: "#f97316",
+  PRUrl: "#f43f5e",
+  LogStream: "#eab308",
+  SessionRef: "#a855f7",
+  CommandResult: "#f59e0b",
+});
+
+function clonePortSpec(port, fallbackName = "default") {
+  if (!port || typeof port !== "object") {
+    const type = "Any";
+    return {
+      name: fallbackName,
+      label: fallbackName,
+      type,
+      description: PORT_TYPE_DESCRIPTIONS[type],
+      color: PORT_TYPE_COLORS[type] || null,
+      accepts: [],
+    };
+  }
+  const type = String(port.type || "Any").trim() || "Any";
+  return {
+    ...port,
+    name: String(port.name || fallbackName).trim() || fallbackName,
+    label: String(port.label || port.name || fallbackName).trim() || fallbackName,
+    type,
+    description: String(port.description || PORT_TYPE_DESCRIPTIONS[type] || "").trim(),
+    color: String(port.color || PORT_TYPE_COLORS[type] || "").trim() || null,
+    accepts: Array.isArray(port.accepts)
+      ? Array.from(new Set(port.accepts.map((value) => String(value || "").trim()).filter(Boolean)))
+      : [],
+  };
+}
+
+function makePort(name, type, description = "", extra = {}) {
+  return clonePortSpec({
+    name,
+    label: name,
+    type,
+    description: description || PORT_TYPE_DESCRIPTIONS[type] || "",
+    color: PORT_TYPE_COLORS[type] || null,
+    ...extra,
+  }, name || "default");
+}
+
+const CATEGORY_PORT_DEFAULTS = Object.freeze({
+  trigger: Object.freeze({
+    inputs: [],
+    outputs: [makePort("default", "TriggerEvent")],
+  }),
+  condition: Object.freeze({
+    inputs: [makePort("default", "JSON", "", { accepts: ["TriggerEvent", "TaskDef", "AgentResult", "String", "Any"] })],
+    outputs: [makePort("default", "Boolean")],
+  }),
+  action: Object.freeze({
+    inputs: [makePort("default", "TaskDef", "", { accepts: ["TriggerEvent", "JSON", "String", "Boolean", "Any"] })],
+    outputs: [makePort("default", "JSON")],
+  }),
+  validation: Object.freeze({
+    inputs: [makePort("default", "JSON", "", { accepts: ["TaskDef", "Any"] })],
+    outputs: [makePort("default", "Boolean")],
+  }),
+  transform: Object.freeze({
+    inputs: [makePort("default", "JSON", "", { accepts: ["Any", "String"] })],
+    outputs: [makePort("default", "JSON")],
+  }),
+  notify: Object.freeze({
+    inputs: [makePort("default", "String", "", { accepts: ["Any", "JSON", "AgentResult", "LogStream"] })],
+    outputs: [makePort("default", "Any")],
+  }),
+  flow: Object.freeze({
+    inputs: [makePort("default", "Any")],
+    outputs: [makePort("default", "Any")],
+  }),
+  loop: Object.freeze({
+    inputs: [makePort("default", "Any")],
+    outputs: [makePort("default", "Any")],
+  }),
+  meeting: Object.freeze({
+    inputs: [makePort("default", "SessionRef", "", { accepts: ["TriggerEvent", "Any"] })],
+    outputs: [makePort("default", "JSON")],
+  }),
+  agent: Object.freeze({
+    inputs: [makePort("default", "TaskDef", "", { accepts: ["TriggerEvent", "JSON", "String", "Any"] })],
+    outputs: [makePort("default", "AgentResult")],
+  }),
+});
+
+const NODE_PORT_OVERRIDES = Object.freeze({
+  "trigger.manual": {
+    outputs: [makePort("default", "TaskDef", "Manual dispatch payload")],
+  },
+  "trigger.event": {
+    outputs: [makePort("default", "TriggerEvent", "Event payload")],
+  },
+  "action.run_agent": {
+    inputs: [makePort("default", "TaskDef", "", { accepts: ["TriggerEvent", "String", "JSON", "Boolean", "Any"] })],
+    outputs: [makePort("default", "AgentResult", "Agent response payload")],
+  },
+  "action.run_command": {
+    inputs: [makePort("default", "String", "", { accepts: ["TaskDef", "JSON", "TriggerEvent", "Boolean", "Any"] })],
+    outputs: [makePort("default", "CommandResult", "Command execution output", { accepts: ["LogStream"] })],
+  },
+  "action.git_operations": {
+    inputs: [makePort("default", "GitRef", "", { accepts: ["TaskDef", "JSON", "TriggerEvent", "Boolean", "String", "Any"] })],
+    outputs: [makePort("default", "GitRef", "Git operation result/ref")],
+  },
+  "action.push_branch": {
+    inputs: [makePort("default", "GitRef", "", { accepts: ["TaskDef", "JSON", "TriggerEvent", "Boolean", "String", "Any"] })],
+    outputs: [makePort("default", "GitRef")],
+  },
+  "action.detect_new_commits": {
+    inputs: [makePort("default", "GitRef", "", { accepts: ["TaskDef", "JSON", "TriggerEvent", "Boolean", "String", "Any"] })],
+    outputs: [makePort("default", "GitRef", "Commit detection summary")],
+  },
+  "action.create_pr": {
+    inputs: [makePort("default", "GitRef", "", { accepts: ["TaskDef", "JSON", "TriggerEvent", "Boolean", "String", "Any"] })],
+    outputs: [makePort("default", "PRUrl", "Pull request link payload")],
+  },
+  "transform.json_parse": {
+    inputs: [makePort("default", "String", "", { accepts: ["JSON", "Any"] })],
+    outputs: [makePort("default", "JSON")],
+  },
+  "condition.expression": {
+    inputs: [makePort("default", "JSON", "", { accepts: ["TaskDef", "AgentResult", "Any"] })],
+    outputs: [makePort("default", "Boolean")],
+  },
+  "notify.log": {
+    inputs: [makePort("default", "LogStream", "", { accepts: ["String", "Any", "JSON"] })],
+    outputs: [makePort("default", "LogStream")],
+  },
+  "action.continue_session": {
+    inputs: [makePort("default", "SessionRef", "", { accepts: ["TaskDef", "Any"] })],
+    outputs: [makePort("default", "AgentResult")],
+  },
+  "action.restart_agent": {
+    inputs: [makePort("default", "SessionRef", "", { accepts: ["TaskDef", "Any"] })],
+    outputs: [makePort("default", "AgentResult")],
+  },
+});
+
+const NODE_PRIMARY_FIELD_OVERRIDES = Object.freeze({
+  "action.run_agent": ["model", "prompt", "stream"],
+  "condition.expression": ["expression"],
+  "trigger.event": ["eventType", "filter"],
+  "trigger.schedule": ["intervalMs", "cron"],
+  "trigger.scheduled_once": ["runAt", "timezone"],
+  "action.git_operations": ["operation", "branch", "targetBranch"],
+  "action.create_pr": ["title", "baseBranch", "headBranch"],
+  "action.run_command": ["command", "cwd"],
+  "notify.telegram": ["chatId", "message"],
+});
+
+function inferPrimaryFields(schemaProps = {}) {
+  const keys = Object.keys(schemaProps || {});
+  if (keys.length === 0) return [];
+  const priority = [
+    "model",
+    "expression",
+    "enabled",
+    "branch",
+    "branchName",
+    "baseBranch",
+    "headBranch",
+    "eventType",
+    "command",
+    "message",
+    "prompt",
+    "query",
+    "operation",
+    "timeout",
+  ];
+  const selected = [];
+  for (const key of priority) {
+    if (keys.includes(key) && !selected.includes(key)) selected.push(key);
+    if (selected.length >= 3) return selected;
+  }
+  for (const key of keys) {
+    const field = schemaProps[key] || {};
+    const type = String(field.type || "string");
+    const isShortString = type === "string" && !field.format && !String(key).toLowerCase().includes("path");
+    const isBoolean = type === "boolean";
+    if (field.enum || isShortString || isBoolean) {
+      if (!selected.includes(key)) selected.push(key);
+    }
+    if (selected.length >= 3) break;
+  }
+  return selected.slice(0, 3);
+}
+
+function buildNodePorts(type, handler) {
+  const explicitPorts = handler?.ports || {};
+  const explicitInputs = Array.isArray(handler?.inputs) ? handler.inputs : explicitPorts.inputs;
+  const explicitOutputs = Array.isArray(handler?.outputs) ? handler.outputs : explicitPorts.outputs;
+  if (Array.isArray(explicitInputs) || Array.isArray(explicitOutputs)) {
+    return {
+      inputs: (explicitInputs || []).map((port, index) => clonePortSpec(port, index === 0 ? "default" : `input-${index + 1}`)),
+      outputs: (explicitOutputs || []).map((port, index) => clonePortSpec(port, index === 0 ? "default" : `output-${index + 1}`)),
+    };
+  }
+
+  const override = NODE_PORT_OVERRIDES[type];
+  if (override) {
+    return {
+      inputs: (override.inputs || []).map((port, index) => clonePortSpec(port, index === 0 ? "default" : `input-${index + 1}`)),
+      outputs: (override.outputs || []).map((port, index) => clonePortSpec(port, index === 0 ? "default" : `output-${index + 1}`)),
+    };
+  }
+
+  const [category] = String(type || "").split(".");
+  const fallback = CATEGORY_PORT_DEFAULTS[category] || CATEGORY_PORT_DEFAULTS.flow;
+  return {
+    inputs: (fallback.inputs || []).map((port, index) => clonePortSpec(port, index === 0 ? "default" : `input-${index + 1}`)),
+    outputs: (fallback.outputs || []).map((port, index) => clonePortSpec(port, index === 0 ? "default" : `output-${index + 1}`)),
+  };
+}
+
+function buildNodeUi(type, handler) {
+  const schemaProps = handler?.schema?.properties || {};
+  const explicitPrimaryFields = Array.isArray(handler?.ui?.primaryFields)
+    ? handler.ui.primaryFields
+    : null;
+  const inferred = NODE_PRIMARY_FIELD_OVERRIDES[type] || inferPrimaryFields(schemaProps);
+  return {
+    ...(handler?.ui || {}),
+    primaryFields: (explicitPrimaryFields || inferred)
+      .map((value) => String(value || "").trim())
+      .filter(Boolean),
+  };
+}
+
+function registerBuiltinNodeType(type, handler) {
+  const ports = buildNodePorts(type, handler);
+  const ui = buildNodeUi(type, handler);
+  handler.ports = ports;
+  handler.ui = ui;
+  registerNodeType(type, handler);
+}
+
 function shouldBypassGhPrCreationForTests() {
   return Boolean(process.env.VITEST) && process.env.BOSUN_TEST_ALLOW_GH !== "true";
 }
@@ -885,7 +1289,25 @@ function normalizeLegacyWorkflowCommand(command) {
 }
 
 function resolveWorkflowNodeValue(value, ctx) {
-  if (typeof value === "string") return ctx.resolve(value);
+  if (typeof value === "string") {
+    const resolved = ctx.resolve(value);
+    if (resolved !== value) return resolved;
+
+    const exactExpr = value.match(/^\{\{([\s\S]+)\}\}$/);
+    if (exactExpr) {
+      const expr = String(exactExpr[1] || "").trim();
+      if (expr.includes("$ctx") || expr.includes("$data") || expr.includes("$output")) {
+        try {
+          const fn = new Function("$data", "$ctx", "$output", `return (${expr});`);
+          const evalResult = fn(ctx.data || {}, ctx, null);
+          if (evalResult !== undefined) return evalResult;
+        } catch {
+          // Fall through to unresolved template string when expression is invalid.
+        }
+      }
+    }
+    return resolved;
+  }
   if (Array.isArray(value)) {
     return value.map((item) => resolveWorkflowNodeValue(item, ctx));
   }
@@ -1152,7 +1574,7 @@ function buildWorkflowAgentToolContract(rootDir, agentProfileId = "") {
 //  TRIGGERS — Events that initiate a workflow
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("trigger.manual", {
+registerBuiltinNodeType("trigger.manual", {
   describe: () => "Manual trigger — workflow starts on user request",
   schema: {
     type: "object",
@@ -1164,7 +1586,7 @@ registerNodeType("trigger.manual", {
   },
 });
 
-registerNodeType("trigger.task_low", {
+registerBuiltinNodeType("trigger.task_low", {
   describe: () =>
     "Fires when backlog task count drops below threshold. Self-queries kanban " +
     "when todoCount is not pre-populated in context data. Workspace-aware: " +
@@ -1230,7 +1652,7 @@ registerNodeType("trigger.task_low", {
   },
 });
 
-registerNodeType("trigger.schedule", {
+registerBuiltinNodeType("trigger.schedule", {
   describe: () => "Fires on a cron-like schedule (checked by supervisor loop)",
   schema: {
     type: "object",
@@ -1249,7 +1671,7 @@ registerNodeType("trigger.schedule", {
   },
 });
 
-registerNodeType("trigger.event", {
+registerBuiltinNodeType("trigger.event", {
   describe: () => "Fires on a specific bosun event (task.complete, pr.merged, etc.)",
   schema: {
     type: "object",
@@ -1274,7 +1696,7 @@ registerNodeType("trigger.event", {
   },
 });
 
-registerNodeType("trigger.meeting.wake_phrase", {
+registerBuiltinNodeType("trigger.meeting.wake_phrase", {
   describe: () => "Fires when a transcript/event payload contains the configured wake phrase",
   schema: {
     type: "object",
@@ -1433,7 +1855,7 @@ registerNodeType("trigger.meeting.wake_phrase", {
   },
 });
 
-registerNodeType("trigger.webhook", {
+registerBuiltinNodeType("trigger.webhook", {
   describe: () => "Fires when a webhook is received at the workflow's endpoint",
   schema: {
     type: "object",
@@ -1447,7 +1869,7 @@ registerNodeType("trigger.webhook", {
   },
 });
 
-registerNodeType("trigger.pr_event", {
+registerBuiltinNodeType("trigger.pr_event", {
   describe: () => "Fires on PR events (opened, merged, review requested, etc.)",
   schema: {
     type: "object",
@@ -1484,7 +1906,7 @@ registerNodeType("trigger.pr_event", {
   },
 });
 
-registerNodeType("trigger.task_assigned", {
+registerBuiltinNodeType("trigger.task_assigned", {
   describe: () => "Fires when a task is assigned to an agent",
   schema: {
     type: "object",
@@ -1500,7 +1922,7 @@ registerNodeType("trigger.task_assigned", {
   },
 });
 
-registerNodeType("trigger.anomaly", {
+registerBuiltinNodeType("trigger.anomaly", {
   describe: () => "Fires when the anomaly detector reports an anomaly matching the configured criteria",
   schema: {
     type: "object",
@@ -1540,7 +1962,7 @@ registerNodeType("trigger.anomaly", {
   },
 });
 
-registerNodeType("trigger.scheduled_once", {
+registerBuiltinNodeType("trigger.scheduled_once", {
   describe: () => "Fires once at or after a specific scheduled time (persistent — survives restarts)",
   schema: {
     type: "object",
@@ -1577,7 +1999,7 @@ registerNodeType("trigger.scheduled_once", {
   },
 });
 
-registerNodeType("trigger.workflow_call", {
+registerBuiltinNodeType("trigger.workflow_call", {
   describe: () =>
     "Fires when this workflow is invoked by another workflow via action.execute_workflow. " +
     "Defines expected input parameters that callers should provide.",
@@ -1642,7 +2064,7 @@ registerNodeType("trigger.workflow_call", {
 //  CONDITIONS — Branching / routing logic
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("condition.expression", {
+registerBuiltinNodeType("condition.expression", {
   describe: () => "Evaluate a JS expression to branch workflow execution",
   schema: {
     type: "object",
@@ -1667,7 +2089,7 @@ registerNodeType("condition.expression", {
   },
 });
 
-registerNodeType("condition.task_has_tag", {
+registerBuiltinNodeType("condition.task_has_tag", {
   describe: () => "Check if current task has a specific tag or label",
   schema: {
     type: "object",
@@ -1689,7 +2111,7 @@ registerNodeType("condition.task_has_tag", {
   },
 });
 
-registerNodeType("condition.file_exists", {
+registerBuiltinNodeType("condition.file_exists", {
   describe: () => "Check if a file or directory exists in the workspace",
   schema: {
     type: "object",
@@ -1706,7 +2128,7 @@ registerNodeType("condition.file_exists", {
   },
 });
 
-registerNodeType("condition.switch", {
+registerBuiltinNodeType("condition.switch", {
   describe: () => "Multi-way branch based on a value matching cases",
   schema: {
     type: "object",
@@ -1759,12 +2181,13 @@ registerNodeType("condition.switch", {
 //  ACTIONS — Side-effect operations
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("action.run_agent", {
+registerBuiltinNodeType("action.run_agent", {
   describe: () => "Run a bosun agent with a prompt to perform work",
   schema: {
     type: "object",
     properties: {
       prompt: { type: "string", description: "Agent prompt (supports {{variables}})" },
+      systemPrompt: { type: "string", description: "Optional stable system prompt for cache anchoring" },
       sdk: { type: "string", enum: ["codex", "copilot", "claude", "auto"], default: "auto" },
       model: { type: "string", description: "Optional model override for the selected SDK" },
       taskId: { type: "string", description: "Optional task ID used for task metadata lookup" },
@@ -1822,8 +2245,16 @@ registerNodeType("action.run_agent", {
       ? Math.max(1000, Math.trunc(Number(resolvedTimeoutMs)))
       : 3600000;
     const includeTaskContext = node.config?.includeTaskContext !== false;
+    const configuredSystemPrompt =
+      ctx.resolve(node.config?.systemPrompt || "") ||
+      ctx.data?._taskSystemPrompt ||
+      "";
     const toolContract = buildWorkflowAgentToolContract(cwd, agentProfileId);
-    let finalPrompt = `${toolContract}\n\n${prompt}`;
+    const effectiveSystemPrompt = [configuredSystemPrompt, toolContract]
+      .map((value) => String(value || "").trim())
+      .filter(Boolean)
+      .join("\n\n");
+    let finalPrompt = prompt;
     if (includeTaskContext) {
       const explicitContext =
         ctx.data?.taskContext ||
@@ -1831,7 +2262,7 @@ registerNodeType("action.run_agent", {
         null;
       const task = ctx.data?.task || ctx.data?.taskDetail || ctx.data?.taskInfo || null;
       const contextBlock = explicitContext || buildTaskContextBlock(task);
-      if (contextBlock) finalPrompt = `${prompt}\n\n${contextBlock}`;
+      if (contextBlock) finalPrompt = `${finalPrompt}\n\n${contextBlock}`;
     }
 
     ctx.log(node.id, `Running agent (${sdk}) in ${cwd}`);
@@ -2167,6 +2598,7 @@ registerNodeType("action.run_agent", {
               sdk: sdkOverride,
               model: modelOverride,
               onEvent: launchExtra.onEvent,
+              systemPrompt: effectiveSystemPrompt,
             });
           }
 
@@ -2178,10 +2610,12 @@ registerNodeType("action.run_agent", {
               sdk: sdkOverride,
               model: modelOverride,
               onEvent: launchExtra.onEvent,
+              systemPrompt: effectiveSystemPrompt,
             });
           }
 
           if (!result) {
+            launchExtra.systemPrompt = effectiveSystemPrompt;
             result = await agentPool.launchEphemeralThread(passPrompt, cwd, timeoutMs, launchExtra);
           }
           success = result?.success === true;
@@ -2477,13 +2911,14 @@ registerNodeType("action.run_agent", {
   },
 });
 
-registerNodeType("action.run_command", {
+registerBuiltinNodeType("action.run_command", {
   describe: () => "Execute a shell command in the workspace",
   schema: {
     type: "object",
     properties: {
       command: { type: "string", description: "Shell command to run" },
       cwd: { type: "string", description: "Working directory" },
+      env: { type: "object", description: "Environment variables passed to the command (supports templates)", additionalProperties: true },
       timeoutMs: { type: "number", default: 300000 },
       shell: { type: "string", default: "auto", enum: ["auto", "bash", "pwsh", "cmd"] },
       captureOutput: { type: "boolean", default: true },
@@ -2495,6 +2930,20 @@ registerNodeType("action.run_command", {
     const resolvedCommand = ctx.resolve(node.config?.command || "");
     const command = normalizeLegacyWorkflowCommand(resolvedCommand);
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
+    const resolvedEnvConfig = resolveWorkflowNodeValue(node.config?.env ?? {}, ctx);
+    const commandEnv = { ...process.env };
+    if (resolvedEnvConfig && typeof resolvedEnvConfig === "object" && !Array.isArray(resolvedEnvConfig)) {
+      for (const [key, value] of Object.entries(resolvedEnvConfig)) {
+        const name = String(key || "").trim();
+        if (!name) continue;
+        if (value == null) {
+          delete commandEnv[name];
+          continue;
+        }
+        commandEnv[name] = typeof value === "string" ? value : JSON.stringify(value);
+      }
+    }
+
     const timeout = node.config?.timeoutMs || 300000;
 
     if (command !== resolvedCommand) {
@@ -2508,6 +2957,7 @@ registerNodeType("action.run_command", {
         encoding: "utf8",
         maxBuffer: 10 * 1024 * 1024,
         stdio: node.config?.captureOutput !== false ? "pipe" : "inherit",
+        env: commandEnv,
       });
       ctx.log(node.id, `Command succeeded`);
       return { success: true, output: output?.trim(), exitCode: 0 };
@@ -2530,7 +2980,7 @@ registerNodeType("action.run_command", {
   },
 });
 
-registerNodeType("action.execute_workflow", {
+registerBuiltinNodeType("action.execute_workflow", {
   describe: () => "Execute another workflow by ID (synchronously or dispatch mode)",
   schema: {
     type: "object",
@@ -2751,7 +3201,313 @@ registerNodeType("action.execute_workflow", {
   },
 });
 
-registerNodeType("meeting.start", {
+registerBuiltinNodeType("action.inline_workflow", {
+  describe: () =>
+    "Execute an embedded workflow definition inline (sync or dispatch) without saving it. " +
+    "Useful for parent workflows that need a local subgraph with its own run/context boundary.",
+  schema: {
+    type: "object",
+    properties: {
+      workflow: {
+        type: "object",
+        description:
+          "Embedded workflow definition fragment. Supports { name, variables, nodes, edges, trigger, metadata }.",
+        additionalProperties: true,
+      },
+      mode: { type: "string", enum: ["sync", "dispatch"], default: "sync" },
+      input: {
+        type: "object",
+        description: "Input payload passed to the embedded workflow",
+        additionalProperties: true,
+      },
+      inheritContext: {
+        type: "boolean",
+        default: false,
+        description: "Copy parent workflow context data into child input before applying input overrides",
+      },
+      includeKeys: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional allow-list of parent context keys to inherit when inheritContext=true",
+      },
+      outputVariable: {
+        type: "string",
+        description: "Optional context key to store execution summary output",
+      },
+      failOnChildError: {
+        type: "boolean",
+        default: true,
+        description: "In sync mode, throw when the embedded workflow completes with errors",
+      },
+      forwardFields: {
+        type: "array",
+        items: { type: "string" },
+        description:
+          "Optional allow-list of top-level fields from the embedded workflow's extracted outputs " +
+          "to promote onto this node's output.",
+      },
+      extractFromNodes: {
+        type: "array",
+        items: { type: "string" },
+        description:
+          "Optional child node IDs to extract outputs from. When omitted, the last completed " +
+          "child node output is used.",
+      },
+      allowRecursive: {
+        type: "boolean",
+        default: false,
+        description: "Allow recursive embedded workflow execution when true",
+      },
+    },
+    required: ["workflow"],
+  },
+  async execute(node, ctx, engine) {
+    const workflowDef = resolveWorkflowNodeValue(node.config?.workflow ?? null, ctx);
+    const modeRaw = String(ctx.resolve(node.config?.mode || "sync") || "sync")
+      .trim()
+      .toLowerCase();
+    const mode = modeRaw || "sync";
+    const outputVariable = String(ctx.resolve(node.config?.outputVariable || "") || "").trim();
+    const inheritContext = parseBooleanSetting(
+      resolveWorkflowNodeValue(node.config?.inheritContext ?? false, ctx),
+      false,
+    );
+    const failOnChildError = parseBooleanSetting(
+      resolveWorkflowNodeValue(node.config?.failOnChildError ?? true, ctx),
+      true,
+    );
+    const allowRecursive = parseBooleanSetting(
+      resolveWorkflowNodeValue(node.config?.allowRecursive ?? false, ctx),
+      false,
+    );
+    const includeKeys = Array.isArray(node.config?.includeKeys)
+      ? node.config.includeKeys
+          .map((value) => String(resolveWorkflowNodeValue(value, ctx) || "").trim())
+          .filter(Boolean)
+      : [];
+    const forwardFields = Array.isArray(node.config?.forwardFields)
+      ? node.config.forwardFields
+          .map((value) => String(resolveWorkflowNodeValue(value, ctx) || "").trim())
+          .filter(Boolean)
+      : [];
+    const extractFromNodes = Array.isArray(node.config?.extractFromNodes)
+      ? node.config.extractFromNodes
+          .map((value) => String(resolveWorkflowNodeValue(value, ctx) || "").trim())
+          .filter(Boolean)
+      : [];
+
+    if (!workflowDef || typeof workflowDef !== "object" || Array.isArray(workflowDef)) {
+      throw new Error("action.inline_workflow: 'workflow' must resolve to an object");
+    }
+    if (mode !== "sync" && mode !== "dispatch") {
+      throw new Error(`action.inline_workflow: invalid mode "${mode}". Expected "sync" or "dispatch".`);
+    }
+    if (!engine || typeof engine.executeDefinition !== "function") {
+      throw new Error("action.inline_workflow: workflow engine is not available");
+    }
+
+    const resolvedInputConfig = resolveWorkflowNodeValue(node.config?.input ?? {}, ctx);
+    if (
+      resolvedInputConfig != null &&
+      (typeof resolvedInputConfig !== "object" || Array.isArray(resolvedInputConfig))
+    ) {
+      throw new Error("action.inline_workflow: 'input' must resolve to an object");
+    }
+    const configuredInput =
+      resolvedInputConfig && typeof resolvedInputConfig === "object"
+        ? resolvedInputConfig
+        : {};
+
+    const sourceData =
+      ctx.data && typeof ctx.data === "object"
+        ? ctx.data
+        : {};
+    const inheritedInput = {};
+    if (inheritContext) {
+      if (includeKeys.length > 0) {
+        for (const key of includeKeys) {
+          if (Object.prototype.hasOwnProperty.call(sourceData, key)) {
+            inheritedInput[key] = sourceData[key];
+          }
+        }
+      } else {
+        Object.assign(inheritedInput, sourceData);
+      }
+    }
+
+    const parentWorkflowId = String(ctx.data?._workflowId || "").trim() || "inline-parent";
+    const workflowStack = normalizeWorkflowStack(ctx.data?._workflowStack);
+    if (parentWorkflowId && workflowStack[workflowStack.length - 1] !== parentWorkflowId) {
+      workflowStack.push(parentWorkflowId);
+    }
+    const inlineWorkflowId = String(workflowDef.id || `inline:${parentWorkflowId}:${node.id}`).trim();
+    if (!allowRecursive && workflowStack.includes(inlineWorkflowId)) {
+      const cyclePath = [...workflowStack, inlineWorkflowId].join(" -> ");
+      throw new Error(
+        `action.inline_workflow: recursive inline workflow call blocked (${cyclePath}). ` +
+          "Set allowRecursive=true to override.",
+      );
+    }
+
+    const childInput = {
+      ...inheritedInput,
+      ...configuredInput,
+      _workflowStack: [...workflowStack, inlineWorkflowId],
+      _parentWorkflowId: parentWorkflowId,
+    };
+
+    const inlineName = String(workflowDef.name || node.label || `Inline ${node.id}`).trim() || inlineWorkflowId;
+    const executeInline = () => engine.executeDefinition({
+      trigger: workflowDef.trigger || "trigger.workflow_call",
+      ...workflowDef,
+      id: inlineWorkflowId,
+      name: inlineName,
+      metadata: {
+        ...(workflowDef.metadata || {}),
+        inline: true,
+        sourceNodeId: node.id,
+        parentWorkflowId,
+      },
+    }, childInput, {
+      force: true,
+      sourceNodeId: node.id,
+      inlineWorkflowId,
+      inlineWorkflowName: inlineName,
+    });
+
+    const extractChildOutputs = (childCtx) => {
+      const childOutputs = childCtx?.nodeOutputs instanceof Map
+        ? Object.fromEntries(childCtx.nodeOutputs)
+        : childCtx?.nodeOutputs && typeof childCtx.nodeOutputs === "object"
+          ? { ...childCtx.nodeOutputs }
+          : {};
+
+      let extracted = {};
+      if (extractFromNodes.length > 0) {
+        for (const childNodeId of extractFromNodes) {
+          if (Object.prototype.hasOwnProperty.call(childOutputs, childNodeId)) {
+            extracted[childNodeId] = childOutputs[childNodeId];
+          }
+        }
+        if (extractFromNodes.length === 1) {
+          const single = extracted[extractFromNodes[0]];
+          if (
+            single &&
+            typeof single === "object" &&
+            single._workflowEnd === true &&
+            single.output &&
+            typeof single.output === "object" &&
+            !Array.isArray(single.output)
+          ) {
+            extracted = { ...single.output };
+          }
+        }
+      } else {
+        const completedNodeIds = Array.from(childCtx?.nodeStatuses?.entries?.() || [])
+          .filter(([, status]) => status === NodeStatus.COMPLETED)
+          .map(([childNodeId]) => childNodeId);
+        const lastCompletedNodeId = completedNodeIds[completedNodeIds.length - 1];
+        if (lastCompletedNodeId && Object.prototype.hasOwnProperty.call(childOutputs, lastCompletedNodeId)) {
+          const candidate = childOutputs[lastCompletedNodeId];
+          if (
+            candidate &&
+            typeof candidate === "object" &&
+            candidate._workflowEnd === true &&
+            candidate.output &&
+            typeof candidate.output === "object" &&
+            !Array.isArray(candidate.output)
+          ) {
+            extracted = { ...candidate.output };
+          } else if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+            extracted = { ...candidate };
+          } else {
+            extracted = { result: candidate };
+          }
+        }
+      }
+
+      if (forwardFields.length > 0 && extracted && typeof extracted === "object") {
+        return Object.fromEntries(
+          forwardFields
+            .filter((field) => Object.prototype.hasOwnProperty.call(extracted, field))
+            .map((field) => [field, extracted[field]]),
+        );
+      }
+      return extracted;
+    };
+
+    if (mode === "dispatch") {
+      ctx.log(node.id, `Dispatching inline workflow "${inlineWorkflowId}"`);
+      let dispatched;
+      try {
+        dispatched = Promise.resolve(executeInline());
+      } catch (err) {
+        dispatched = Promise.reject(err);
+      }
+      dispatched
+        .then((childCtx) => {
+          const status = childCtx?.errors?.length ? "failed" : "completed";
+          ctx.log(node.id, `Dispatched inline workflow "${inlineWorkflowId}" finished with status=${status}`);
+        })
+        .catch((err) => {
+          ctx.log(node.id, `Dispatched inline workflow "${inlineWorkflowId}" failed: ${err.message}`, "error");
+        });
+
+      const output = {
+        success: true,
+        dispatched: true,
+        mode: "dispatch",
+        workflowId: inlineWorkflowId,
+        matchedPort: "default",
+        port: "default",
+      };
+      if (outputVariable) {
+        ctx.data[outputVariable] = output;
+      }
+      return output;
+    }
+
+    ctx.log(node.id, `Executing inline workflow "${inlineWorkflowId}" (sync)`);
+    const childCtx = await executeInline();
+    const childErrors = Array.isArray(childCtx?.errors)
+      ? childCtx.errors.map((entry) => ({
+          nodeId: entry?.nodeId || null,
+          error: String(entry?.error || "unknown child workflow error"),
+        }))
+      : [];
+    const status = childErrors.length > 0 ? "failed" : "completed";
+    const extracted = extractChildOutputs(childCtx);
+    const output = {
+      success: status === "completed",
+      dispatched: false,
+      mode: "sync",
+      workflowId: inlineWorkflowId,
+      runId: childCtx?.id || null,
+      status,
+      errorCount: childErrors.length,
+      errors: childErrors,
+      matchedPort: status === "completed" ? "default" : "error",
+      port: status === "completed" ? "default" : "error",
+      childOutputs: extracted,
+      ...(extracted && typeof extracted === "object" ? extracted : {}),
+    };
+
+    if (outputVariable) {
+      ctx.data[outputVariable] = output;
+    }
+
+    if (status === "failed" && failOnChildError) {
+      const reason = childErrors[0]?.error || "inline workflow failed";
+      const err = new Error(`action.inline_workflow: child inline workflow "${inlineWorkflowId}" failed: ${reason}`);
+      err.childWorkflow = output;
+      throw err;
+    }
+
+    return output;
+  },
+});
+
+registerBuiltinNodeType("meeting.start", {
   describe: () => "Create or reuse a meeting session for workflow-driven voice/video orchestration",
   schema: {
     type: "object",
@@ -2831,7 +3587,7 @@ registerNodeType("meeting.start", {
   },
 });
 
-registerNodeType("meeting.send", {
+registerBuiltinNodeType("meeting.send", {
   describe: () => "Send a meeting message through the meeting session dispatcher",
   schema: {
     type: "object",
@@ -2908,7 +3664,7 @@ registerNodeType("meeting.send", {
   },
 });
 
-registerNodeType("meeting.transcript", {
+registerBuiltinNodeType("meeting.transcript", {
   describe: () => "Fetch meeting transcript pages and optionally project as plain text",
   schema: {
     type: "object",
@@ -2979,7 +3735,7 @@ registerNodeType("meeting.transcript", {
   },
 });
 
-registerNodeType("meeting.vision", {
+registerBuiltinNodeType("meeting.vision", {
   describe: () => "Analyze a meeting video frame and persist a vision summary",
   schema: {
     type: "object",
@@ -3076,7 +3832,7 @@ registerNodeType("meeting.vision", {
   },
 });
 
-registerNodeType("meeting.finalize", {
+registerBuiltinNodeType("meeting.finalize", {
   describe: () => "Finalize a meeting session with status and optional note",
   schema: {
     type: "object",
@@ -3128,7 +3884,7 @@ registerNodeType("meeting.finalize", {
   },
 });
 
-registerNodeType("action.create_task", {
+registerBuiltinNodeType("action.create_task", {
   describe: () => "Create a new task in the kanban board",
   schema: {
     type: "object",
@@ -3174,7 +3930,7 @@ registerNodeType("action.create_task", {
   },
 });
 
-registerNodeType("action.update_task_status", {
+registerBuiltinNodeType("action.update_task_status", {
   describe: () => "Update the status of an existing task",
   schema: {
     type: "object",
@@ -3323,7 +4079,7 @@ registerNodeType("action.update_task_status", {
   },
 });
 
-registerNodeType("action.git_operations", {
+registerBuiltinNodeType("action.git_operations", {
   describe: () => "Perform git operations (commit, push, create branch, etc.)",
   schema: {
     type: "object",
@@ -3423,7 +4179,7 @@ registerNodeType("action.git_operations", {
   },
 });
 
-registerNodeType("action.create_pr", {
+registerBuiltinNodeType("action.create_pr", {
   describe: () =>
     "Create a pull request via GitHub CLI. Falls back to Bosun-managed handoff " +
     "when gh is unavailable or the operation fails with failOnError=false.",
@@ -3445,6 +4201,26 @@ registerNodeType("action.create_pr", {
         oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
         description: "Comma-separated or array of reviewer handles",
       },
+      enableAutoMerge: {
+        type: "boolean",
+        default: false,
+        description: "Enable gh auto-merge immediately after PR creation/linking",
+      },
+      autoMerge: {
+        type: "boolean",
+        description: "Legacy alias for enableAutoMerge",
+      },
+      autoMergeMethod: {
+        type: "string",
+        enum: ["merge", "squash", "rebase"],
+        default: "squash",
+        description: "Merge method used with gh pr merge --auto",
+      },
+      mergeMethod: {
+        type: "string",
+        enum: ["merge", "squash", "rebase"],
+        description: "Legacy alias for autoMergeMethod",
+      },
       cwd: { type: "string" },
       failOnError: { type: "boolean", default: false, description: "If true, throw on gh failure instead of falling back" },
     },
@@ -3460,6 +4236,16 @@ registerNodeType("action.create_pr", {
     ).trim();
     const draft = node.config?.draft === true;
     const failOnError = node.config?.failOnError === true;
+    const enableAutoMerge = parseBooleanSetting(
+      resolveWorkflowNodeValue(node.config?.enableAutoMerge ?? node.config?.autoMerge ?? false, ctx),
+      false,
+    );
+    const autoMergeMethodRaw = String(
+      ctx.resolve(node.config?.autoMergeMethod || node.config?.mergeMethod || "squash"),
+    ).trim().toLowerCase();
+    const autoMergeMethod = ["merge", "squash", "rebase"].includes(autoMergeMethodRaw)
+      ? autoMergeMethodRaw
+      : "squash";
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
 
     // Normalize labels/reviewers to arrays
@@ -3502,6 +4288,46 @@ registerNodeType("action.create_pr", {
       stdio: ["pipe", "pipe", "pipe"],
     };
 
+    const maybeEnableAutoMerge = (prNumber) => {
+      if (!enableAutoMerge) {
+        return { enabled: false, attempted: false, success: false };
+      }
+      if (draft) {
+        return { enabled: true, attempted: false, success: false, reason: "draft_pr", method: autoMergeMethod };
+      }
+      const parsedPrNumber = Number.parseInt(String(prNumber || ""), 10);
+      if (!Number.isFinite(parsedPrNumber) || parsedPrNumber <= 0) {
+        return { enabled: true, attempted: false, success: false, reason: "missing_pr_number", method: autoMergeMethod };
+      }
+      if (shouldBypassGhPrCreationForTests()) {
+        return { enabled: true, attempted: false, success: false, reason: "test_runtime_skip", method: autoMergeMethod };
+      }
+      try {
+        const mergeArgs = ["pr", "merge", String(parsedPrNumber), "--auto", `--${autoMergeMethod}`];
+        if (repoSlug) mergeArgs.push("--repo", repoSlug);
+        execFileSync("gh", mergeArgs, execOptions);
+        ctx.log(node.id, `Auto-merge requested for PR #${parsedPrNumber} (${autoMergeMethod})`);
+        return {
+          enabled: true,
+          attempted: true,
+          success: true,
+          method: autoMergeMethod,
+          prNumber: parsedPrNumber,
+        };
+      } catch (err) {
+        const error = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
+        ctx.log(node.id, `Auto-merge request failed for PR #${parsedPrNumber}: ${error}`);
+        return {
+          enabled: true,
+          attempted: true,
+          success: false,
+          method: autoMergeMethod,
+          prNumber: parsedPrNumber,
+          error,
+        };
+      }
+    };
+
     /** Re-resolve token after invalidating the current one (401 retry). */
     const retryWithFallbackToken = async () => {
       if (!resolvedTokenType) return false;
@@ -3557,6 +4383,7 @@ registerNodeType("action.create_pr", {
           } catch {
           }
         }
+        const autoMergeState = maybeEnableAutoMerge(prNumber);
         return {
           success: true,
           existing: true,
@@ -3570,6 +4397,7 @@ registerNodeType("action.create_pr", {
           labels,
           reviewers,
           output: String(existing?.url || `existing-pr-${prNumber}`),
+          autoMerge: autoMergeState,
         };
       } catch {
         return null;
@@ -3610,6 +4438,13 @@ registerNodeType("action.create_pr", {
         cwd,
         repoSlug: repoSlug || null,
         ghError: "skipped_in_test_runtime",
+        autoMerge: {
+          enabled: enableAutoMerge,
+          attempted: false,
+          success: false,
+          reason: "test_runtime_skip",
+          method: autoMergeMethod,
+        },
       };
     }
 
@@ -3620,6 +4455,7 @@ registerNodeType("action.create_pr", {
       const urlMatch = trimmed.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
       const prNumber = urlMatch ? parseInt(urlMatch[1], 10) : null;
       const prUrl = urlMatch ? urlMatch[0] : trimmed;
+      const autoMergeState = maybeEnableAutoMerge(prNumber);
       ctx.log(node.id, `PR created: ${prUrl}`);
       return {
         success: true,
@@ -3633,6 +4469,7 @@ registerNodeType("action.create_pr", {
         labels,
         reviewers,
         output: trimmed,
+        autoMerge: autoMergeState,
       };
     } catch (err) {
       const errorMsg = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
@@ -3649,6 +4486,7 @@ registerNodeType("action.create_pr", {
             const urlMatch = trimmed.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
             const prNumber = urlMatch ? parseInt(urlMatch[1], 10) : null;
             const prUrl = urlMatch ? urlMatch[0] : trimmed;
+            const autoMergeState = maybeEnableAutoMerge(prNumber);
             ctx.log(node.id, `PR created (after auth retry): ${prUrl}`);
             return {
               success: true,
@@ -3662,6 +4500,7 @@ registerNodeType("action.create_pr", {
               labels,
               reviewers,
               output: trimmed,
+              autoMerge: autoMergeState,
             };
           } catch (retryErr) {
             const retryMsg = retryErr?.stderr?.toString?.()?.trim() || retryErr?.message || String(retryErr);
@@ -3701,12 +4540,19 @@ registerNodeType("action.create_pr", {
         reviewers,
         cwd,
         ghError: errorMsg,
+        autoMerge: {
+          enabled: enableAutoMerge,
+          attempted: false,
+          success: false,
+          reason: "pr_creation_failed",
+          method: autoMergeMethod,
+        },
       };
     }
   },
 });
 
-registerNodeType("action.write_file", {
+registerBuiltinNodeType("action.write_file", {
   describe: () => "Write content to a file in the workspace",
   schema: {
     type: "object",
@@ -3735,7 +4581,7 @@ registerNodeType("action.write_file", {
   },
 });
 
-registerNodeType("action.read_file", {
+registerBuiltinNodeType("action.read_file", {
   describe: () => "Read content from a file",
   schema: {
     type: "object",
@@ -3754,7 +4600,7 @@ registerNodeType("action.read_file", {
   },
 });
 
-registerNodeType("action.set_variable", {
+registerBuiltinNodeType("action.set_variable", {
   describe: () => "Set a variable in the workflow context for downstream nodes",
   schema: {
     type: "object",
@@ -3784,7 +4630,7 @@ registerNodeType("action.set_variable", {
   },
 });
 
-registerNodeType("action.delay", {
+registerBuiltinNodeType("action.delay", {
   describe: () => "Wait for a specified duration before continuing (supports ms, seconds, minutes, hours)",
   schema: {
     type: "object",
@@ -3837,7 +4683,7 @@ registerNodeType("action.delay", {
 //  VALIDATION — Verification gates
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("validation.screenshot", {
+registerBuiltinNodeType("validation.screenshot", {
   describe: () => "Take a screenshot for visual verification and store in evidence",
   schema: {
     type: "object",
@@ -3951,7 +4797,7 @@ registerNodeType("validation.screenshot", {
   },
 });
 
-registerNodeType("validation.model_review", {
+registerBuiltinNodeType("validation.model_review", {
   describe: () => "Send evidence (screenshots, code, logs) to a non-agent model for independent verification",
   schema: {
     type: "object",
@@ -4069,7 +4915,7 @@ Respond with exactly one of:
   },
 });
 
-registerNodeType("validation.tests", {
+registerBuiltinNodeType("validation.tests", {
   describe: () => "Run test suite and verify results",
   schema: {
     type: "object",
@@ -4098,7 +4944,7 @@ registerNodeType("validation.tests", {
   },
 });
 
-registerNodeType("validation.build", {
+registerBuiltinNodeType("validation.build", {
   describe: () => "Run build and verify it succeeds with 0 errors",
   schema: {
     type: "object",
@@ -4132,7 +4978,7 @@ registerNodeType("validation.build", {
   },
 });
 
-registerNodeType("validation.lint", {
+registerBuiltinNodeType("validation.lint", {
   describe: () => "Run linter and verify results",
   schema: {
     type: "object",
@@ -4161,7 +5007,7 @@ registerNodeType("validation.lint", {
 //  TRANSFORM — Data manipulation
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("transform.json_parse", {
+registerBuiltinNodeType("transform.json_parse", {
   describe: () => "Parse JSON from a previous node's output",
   schema: {
     type: "object",
@@ -4183,7 +5029,7 @@ registerNodeType("transform.json_parse", {
   },
 });
 
-registerNodeType("transform.template", {
+registerBuiltinNodeType("transform.template", {
   describe: () => "Render a text template with context variables",
   schema: {
     type: "object",
@@ -4198,7 +5044,7 @@ registerNodeType("transform.template", {
   },
 });
 
-registerNodeType("transform.aggregate", {
+registerBuiltinNodeType("transform.aggregate", {
   describe: () => "Aggregate outputs from multiple nodes into a single object",
   schema: {
     type: "object",
@@ -4216,7 +5062,7 @@ registerNodeType("transform.aggregate", {
   },
 });
 
-registerNodeType("transform.llm_parse", {
+registerBuiltinNodeType("transform.llm_parse", {
   describe: () =>
     "Parse unstructured LLM output into structured fields using regex patterns " +
     "or keyword extraction. Essential for routing decisions based on LLM verdicts " +
@@ -4327,7 +5173,7 @@ registerNodeType("transform.llm_parse", {
 //  NOTIFY — Notifications
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("notify.log", {
+registerBuiltinNodeType("notify.log", {
   describe: () => "Log a message (to console and workflow run log)",
   schema: {
     type: "object",
@@ -4346,7 +5192,7 @@ registerNodeType("notify.log", {
   },
 });
 
-registerNodeType("notify.telegram", {
+registerBuiltinNodeType("notify.telegram", {
   describe: () => "Send a message to Telegram chat",
   schema: {
     type: "object",
@@ -4374,42 +5220,154 @@ registerNodeType("notify.telegram", {
       );
       return { sent: true, message };
     }
-    ctx.log(node.id, "Telegram service not available", "warn");
-    return { sent: false, reason: "no_telegram" };
-  },
-});
+    ctx.log(node.id, "Telegram service not available", "warn");
+    return { sent: false, reason: "no_telegram" };
+  },
+});
+
+registerBuiltinNodeType("notify.webhook_out", {
+  describe: () => "Send an HTTP webhook notification",
+  schema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "Webhook URL" },
+      method: { type: "string", default: "POST" },
+      body: { type: "object", description: "Request body (supports {{variables}} in string values)" },
+      headers: { type: "object" },
+    },
+    required: ["url"],
+  },
+  async execute(node, ctx) {
+    const url = ctx.resolve(node.config?.url || "");
+    const method = node.config?.method || "POST";
+    const body = node.config?.body ? JSON.stringify(node.config.body) : undefined;
+
+    ctx.log(node.id, `Webhook ${method} to ${url}`);
+    try {
+      const resp = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...node.config?.headers,
+        },
+        body,
+      });
+      return { success: resp.ok, status: resp.status };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  },
+});
+
+registerNodeType("action.emit_event", {
+  describe: () =>
+    "Emit an internal workflow event and optionally dispatch matching trigger.event workflows",
+  schema: {
+    type: "object",
+    properties: {
+      eventType: { type: "string", description: "Event type to emit (for example session-stuck)" },
+      payload: {
+        type: "object",
+        description: "Event payload object forwarded to matching workflows",
+        additionalProperties: true,
+      },
+      dispatch: {
+        type: "boolean",
+        default: true,
+        description: "When true, evaluate and execute matching event-trigger workflows",
+      },
+      includeCurrentWorkflow: {
+        type: "boolean",
+        default: false,
+        description: "Allow dispatching the currently running workflow if it matches",
+      },
+      outputVariable: {
+        type: "string",
+        description: "Optional context key where event output will be stored",
+      },
+    },
+    required: ["eventType"],
+  },
+  async execute(node, ctx, engine) {
+    const eventType = String(ctx.resolve(node.config?.eventType || "") || "").trim();
+    if (!eventType) throw new Error("action.emit_event: 'eventType' is required");
+
+    const payload = resolveWorkflowNodeValue(node.config?.payload ?? {}, ctx);
+    const shouldDispatch = parseBooleanSetting(
+      resolveWorkflowNodeValue(node.config?.dispatch ?? true, ctx),
+      true,
+    );
+    const includeCurrentWorkflow = parseBooleanSetting(
+      resolveWorkflowNodeValue(node.config?.includeCurrentWorkflow ?? false, ctx),
+      false,
+    );
+    const currentWorkflowId = String(ctx.data?._workflowId || "").trim();
+
+    const output = {
+      success: true,
+      eventType,
+      payload,
+      dispatched: false,
+      dispatchCount: 0,
+      matched: [],
+      runs: [],
+    };
+
+    if (shouldDispatch && engine?.evaluateTriggers && engine?.execute) {
+      const matched = await engine.evaluateTriggers(eventType, payload || {});
+      output.matched = matched;
+      for (const trigger of matched) {
+        const workflowId = String(trigger?.workflowId || "").trim();
+        if (!workflowId) continue;
+        if (!includeCurrentWorkflow && currentWorkflowId && workflowId === currentWorkflowId) {
+          continue;
+        }
+        try {
+          const childCtx = await engine.execute(
+            workflowId,
+            {
+              ...(payload && typeof payload === "object" ? payload : {}),
+              eventType,
+              _triggerSource: "workflow.emit_event",
+              _triggeredByWorkflowId: currentWorkflowId || null,
+              _triggeredByRunId: ctx.id,
+            },
+            { force: true },
+          );
+          const childErrors = Array.isArray(childCtx?.errors) ? childCtx.errors : [];
+          output.runs.push({
+            workflowId,
+            runId: childCtx?.id || null,
+            status: childErrors.length > 0 ? "failed" : "completed",
+          });
+        } catch (err) {
+          output.runs.push({
+            workflowId,
+            runId: null,
+            status: "failed",
+            error: err?.message || String(err),
+          });
+        }
+      }
+      output.dispatchCount = output.runs.length;
+      output.dispatched = output.dispatchCount > 0;
+    }
 
-registerNodeType("notify.webhook_out", {
-  describe: () => "Send an HTTP webhook notification",
-  schema: {
-    type: "object",
-    properties: {
-      url: { type: "string", description: "Webhook URL" },
-      method: { type: "string", default: "POST" },
-      body: { type: "object", description: "Request body (supports {{variables}} in string values)" },
-      headers: { type: "object" },
-    },
-    required: ["url"],
-  },
-  async execute(node, ctx) {
-    const url = ctx.resolve(node.config?.url || "");
-    const method = node.config?.method || "POST";
-    const body = node.config?.body ? JSON.stringify(node.config.body) : undefined;
+    if (ctx?.data && typeof ctx.data === "object") {
+      ctx.data.eventType = eventType;
+      ctx.data.eventPayload = payload;
+    }
 
-    ctx.log(node.id, `Webhook ${method} to ${url}`);
-    try {
-      const resp = await fetch(url, {
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          ...node.config?.headers,
-        },
-        body,
-      });
-      return { success: resp.ok, status: resp.status };
-    } catch (err) {
-      return { success: false, error: err.message };
+    const outputVariable = String(ctx.resolve(node.config?.outputVariable || "") || "").trim();
+    if (outputVariable) {
+      ctx.data[outputVariable] = output;
     }
+
+    ctx.log(
+      node.id,
+      `Emitted event ${eventType} (dispatch=${output.dispatched}, runs=${output.dispatchCount})`,
+    );
+    return output;
   },
 });
 
@@ -4417,7 +5375,7 @@ registerNodeType("notify.webhook_out", {
 //  AGENT-SPECIFIC — Specialized agent operations
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("agent.select_profile", {
+registerBuiltinNodeType("agent.select_profile", {
   describe: () => "Select an agent profile based on task characteristics",
   schema: {
     type: "object",
@@ -4659,8 +5617,50 @@ function normalizePlannerTaskForCreation(task, index) {
     }
     return normalized;
   };
+  const normalizeScore = (value) => {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) return null;
+    return Math.max(0, Math.min(10, Math.round(numeric)));
+  };
+  const normalizeRiskLevel = (value) => {
+    const raw = String(value || "").trim().toLowerCase();
+    if (["low", "medium", "high", "critical"].includes(raw)) return raw;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) return null;
+    if (numeric >= 9) return "critical";
+    if (numeric >= 7) return "high";
+    if (numeric >= 4) return "medium";
+    return "low";
+  };
+  const normalizeArchetype = (value) => {
+    const normalized = String(value || "")
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "_")
+      .replace(/^_+|_+$/g, "");
+    return normalized || "";
+  };
+  const inferArchetype = () => {
+    const explicit =
+      task.archetype ||
+      task.task_archetype ||
+      task.taskArchetype ||
+      task.pattern ||
+      "";
+    const normalizedExplicit = normalizeArchetype(explicit);
+    if (normalizedExplicit) return normalizedExplicit;
+    const conventional = title
+      .toLowerCase()
+      .match(/^(?:\[[^\]]+\]\s*)?([a-z][a-z0-9_-]*)(?:\([^)]*\))?:/);
+    if (conventional?.[1]) return normalizeArchetype(conventional[1]);
+    if (title.toLowerCase().includes("test")) return "test";
+    if (title.toLowerCase().includes("doc")) return "docs";
+    if (title.toLowerCase().includes("refactor")) return "refactor";
+    return "general";
+  };
   const scoreMode = inferPlannerTaskScoreMode(task);
   const preferTenScaleIntegers = scoreMode === PLANNER_SCORE_MODE_TEN;
+
   const lines = [];
   const description = String(task.description || "").trim();
   if (description) lines.push(description);
@@ -4676,6 +5676,7 @@ function normalizePlannerTaskForCreation(task, index) {
   const estimatedEffort = String(task.estimated_effort || task.estimatedEffort || "").trim().toLowerCase();
   const whyNow = String(task.why_now || task.whyNow || "").trim();
   const killCriteria = normalizeStringList(task.kill_criteria || task.killCriteria);
+  const archetype = inferArchetype();
 
   const appendList = (heading, values) => {
     if (!Array.isArray(values) || values.length === 0) return;
@@ -4727,6 +5728,7 @@ function normalizePlannerTaskForCreation(task, index) {
     impact,
     confidence,
     risk,
+    archetype,
     estimatedEffort: estimatedEffort || null,
     whyNow: whyNow || null,
     killCriteria: killCriteria.length > 0 ? killCriteria : null,
@@ -4830,6 +5832,401 @@ function resolvePlannerFeedbackContext(value) {
   return String(value).trim();
 }
 
+function resolvePlannerFeedbackObject(value) {
+  if (!value) return null;
+  if (typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizePlannerTaskArchetype(task) {
+  const explicitArchetype = String(
+    task?.archetype || task?.taskArchetype || task?.task_archetype || "",
+  )
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9()_-]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  if (explicitArchetype) return explicitArchetype;
+  const title = String(task?.title || "").trim().toLowerCase();
+  if (!title) return "general";
+  const withoutPrefix = title.replace(/^\[[^\]]+\]\s*/, "").trim();
+  const scoped = withoutPrefix.match(/^([a-z][a-z0-9_-]*)\(([^)]+)\)\s*:/);
+  if (scoped) return scoped[1];
+  const typed = withoutPrefix.match(/^([a-z][a-z0-9_-]*)\s*:/);
+  if (typed) return typed[1];
+  const fallback = withoutPrefix
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim()
+    .split(/\s+/)
+    .slice(0, 2)
+    .join("_");
+  return fallback || "general";
+}
+
+function resolvePlannerPatternKeys(task) {
+  const archetype = normalizePlannerTaskArchetype(task);
+  const areas = resolveTaskRepoAreas(task);
+  const normalizedAreas = areas.length > 0
+    ? areas.map((area) => normalizePlannerAreaKey(area)).filter(Boolean)
+    : ["global"];
+  return normalizedAreas.map((area) => `${area}::${archetype}`);
+}
+
+function resolvePlannerDebtTrendSignal(task) {
+  const numericCandidates = [
+    task?.debt_trend,
+    task?.debtTrend,
+    task?.meta?.debt_trend,
+    task?.meta?.debtTrend,
+    task?.meta?.planner?.debt_trend,
+    task?.meta?.planner?.debtTrend,
+    task?.meta?.planner?.debt_growth,
+    task?.meta?.planner?.debtGrowth,
+  ];
+  for (const candidate of numericCandidates) {
+    const numeric = Number(candidate);
+    if (Number.isFinite(numeric)) {
+      return Math.max(0, Math.min(5, Math.abs(numeric)));
+    }
+  }
+
+  const textCandidates = [
+    task?.debt_trend,
+    task?.debtTrend,
+    task?.meta?.debt_trend,
+    task?.meta?.debtTrend,
+    task?.meta?.planner?.debt_trend,
+    task?.meta?.planner?.debtTrend,
+    task?.meta?.planner?.why_now,
+    task?.meta?.planner?.whyNow,
+    task?.description,
+  ]
+    .map((value) => String(value || "").trim().toLowerCase())
+    .filter(Boolean);
+  for (const text of textCandidates) {
+    if (/(worsen|worsening|increase|increasing|growth|growing|upward|regress)/.test(text)) {
+      return 2;
+    }
+    if (/(stable|flat|neutral|steady)/.test(text)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+function hasTaskCommitEvidence(task) {
+  const commitCandidates = [
+    task?.hasCommits,
+    task?.meta?.hasCommits,
+    task?.meta?.execution?.hasCommits,
+    task?.meta?.execution?.commitCount,
+    task?.meta?.execution?.commits,
+    task?.commitCount,
+    task?.commits,
+    task?.meta?.commits,
+  ];
+  for (const candidate of commitCandidates) {
+    if (typeof candidate === "boolean") return candidate;
+    const numeric = Number(candidate);
+    if (Number.isFinite(numeric) && numeric > 0) return true;
+    if (Array.isArray(candidate) && candidate.length > 0) return true;
+  }
+  return false;
+}
+
+function createEmptyPlannerPatternPrior() {
+  return {
+    failureCount: 0,
+    successCount: 0,
+    failureWeight: 0,
+    successWeight: 0,
+    failureCounter: 0,
+    commitlessFailureCount: 0,
+    commitlessSuccessCount: 0,
+    commitlessFailureCounter: 0,
+    signalTotals: {
+      agentAttempts: 0,
+      consecutiveNoCommits: 0,
+      blockedReason: 0,
+      debtTrend: 0,
+    },
+    lastUpdatedAt: null,
+  };
+}
+
+function normalizePlannerPatternPrior(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    return createEmptyPlannerPatternPrior();
+  }
+  const base = createEmptyPlannerPatternPrior();
+  const signalTotals = entry.signalTotals && typeof entry.signalTotals === "object"
+    ? entry.signalTotals
+    : {};
+  return {
+    ...base,
+    ...entry,
+    signalTotals: {
+      agentAttempts: Number(signalTotals.agentAttempts || 0),
+      consecutiveNoCommits: Number(signalTotals.consecutiveNoCommits || 0),
+      blockedReason: Number(signalTotals.blockedReason || 0),
+      debtTrend: Number(signalTotals.debtTrend || 0),
+    },
+  };
+}
+
+function resolvePlannerOutcomeSignals(task, weights) {
+  const attempts = Math.max(0, Number(task?.agentAttempts || task?.meta?.agentAttempts || 0));
+  const noCommits = Math.max(
+    0,
+    Number(task?.consecutiveNoCommits || task?.meta?.consecutiveNoCommits || 0),
+  );
+  const blockedReason = String(task?.blockedReason || task?.meta?.blockedReason || "").trim();
+  const debtTrendSignal = resolvePlannerDebtTrendSignal(task);
+  const commitEvidence = hasTaskCommitEvidence(task);
+  const status = String(task?.status || "").trim().toLowerCase();
+  const completedStatus = ["done", "completed", "closed", "merged"].includes(status);
+  const agentAttemptsPenalty = commitEvidence ? 0 : (attempts * weights.agentAttempts);
+  const consecutiveNoCommitsPenalty = noCommits * weights.consecutiveNoCommits;
+  const blockedPenalty = blockedReason ? weights.blockedReason : 0;
+  const debtTrendPenalty = debtTrendSignal * weights.debtTrend;
+
+  const failureWeight =
+    agentAttemptsPenalty +
+    consecutiveNoCommitsPenalty +
+    blockedPenalty +
+    debtTrendPenalty;
+  const successWeight =
+    (commitEvidence ? weights.commitSuccess : 0) +
+    ((completedStatus && !blockedReason) ? weights.completedSuccess : 0);
+  const commitlessFailureEvent = attempts > 0 && !commitEvidence;
+
+  return {
+    attempts,
+    noCommits,
+    blockedReason,
+    debtTrendSignal,
+    commitEvidence,
+    commitlessFailureEvent,
+    failureWeight,
+    successWeight,
+    failureComponents: {
+      agentAttemptsPenalty,
+      consecutiveNoCommitsPenalty,
+      blockedPenalty,
+      debtTrendPenalty,
+    },
+  };
+}
+
+function resolvePlannerPriorStatePath() {
+  const configured = String(process.env.BOSUN_PLANNER_PATTERN_PRIORS_FILE || "").trim();
+  if (configured) return configured;
+  return resolve(process.cwd(), ".bosun", "workflow-runs", "planner-pattern-priors.json");
+}
+
+function shouldPersistPlannerPriorState() {
+  if (String(process.env.BOSUN_DISABLE_PLANNER_PATTERN_PRIORS || "").trim().toLowerCase() === "true") {
+    return false;
+  }
+  if (process.env.VITEST && process.env.BOSUN_TEST_ENABLE_PLANNER_PRIOR_PERSISTENCE !== "true") {
+    return false;
+  }
+  return true;
+}
+
+function loadPlannerPriorState(statePath) {
+  const base = { version: 1, patterns: {}, outcomes: {} };
+  if (!statePath || !existsSync(statePath)) return base;
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return base;
+    return {
+      version: 1,
+      patterns:
+        parsed.patterns && typeof parsed.patterns === "object"
+          ? Object.fromEntries(
+            Object.entries(parsed.patterns).map(([key, value]) => [
+              key,
+              normalizePlannerPatternPrior(value),
+            ]),
+          )
+          : {},
+      outcomes: parsed.outcomes && typeof parsed.outcomes === "object" ? parsed.outcomes : {},
+    };
+  } catch {
+    return base;
+  }
+}
+
+function savePlannerPriorState(statePath, state) {
+  if (!statePath) return;
+  try {
+    mkdirSync(dirname(statePath), { recursive: true });
+    writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  } catch {
+    // Best-effort persistence only.
+  }
+}
+
+function replayPlannerOutcomes(existingTasks, priorState, weights) {
+  if (!Array.isArray(existingTasks) || existingTasks.length === 0) return;
+  const nowIso = new Date().toISOString();
+  const maxOutcomes = 5000;
+
+  for (const task of existingTasks) {
+    const taskId = String(task?.id || task?.task_id || "").trim();
+    if (!taskId) continue;
+    const keys = resolvePlannerPatternKeys(task);
+    if (!keys.length) continue;
+    const signals = resolvePlannerOutcomeSignals(task, weights);
+    const signature = JSON.stringify({
+      status: String(task?.status || "").trim().toLowerCase(),
+      attempts: signals.attempts,
+      noCommits: signals.noCommits,
+      blockedReason: signals.blockedReason.toLowerCase(),
+      debtTrendSignal: signals.debtTrendSignal,
+      hasCommits: hasTaskCommitEvidence(task),
+    });
+    if (priorState.outcomes?.[taskId]?.signature === signature) continue;
+    priorState.outcomes[taskId] = { signature, updatedAt: nowIso };
+
+    for (const key of keys) {
+      const current = normalizePlannerPatternPrior(priorState.patterns[key]);
+      const priorCounter = Math.max(0, Number(current.failureCounter || 0));
+      const priorCommitlessCounter = Math.max(0, Number(current.commitlessFailureCounter || 0));
+      if (signals.failureWeight > 0) {
+        current.failureCount = Number(current.failureCount || 0) + 1;
+        current.failureWeight = Number(current.failureWeight || 0) + signals.failureWeight;
+        current.signalTotals.agentAttempts += signals.failureComponents.agentAttemptsPenalty;
+        current.signalTotals.consecutiveNoCommits += signals.failureComponents.consecutiveNoCommitsPenalty;
+        current.signalTotals.blockedReason += signals.failureComponents.blockedPenalty;
+        current.signalTotals.debtTrend += signals.failureComponents.debtTrendPenalty;
+      }
+      if (signals.successWeight > 0) {
+        current.successCount = Number(current.successCount || 0) + 1;
+        current.successWeight = Number(current.successWeight || 0) + signals.successWeight;
+      }
+      if (signals.commitlessFailureEvent) {
+        current.commitlessFailureCount = Number(current.commitlessFailureCount || 0) + 1;
+      }
+      if (signals.commitEvidence) {
+        current.commitlessSuccessCount = Number(current.commitlessSuccessCount || 0) + 1;
+      }
+      current.failureCounter = Number(
+        Math.max(
+          0,
+          (priorCounter * 0.82) + signals.failureWeight - (signals.successWeight * 0.95),
+        ).toFixed(3),
+      );
+      current.commitlessFailureCounter = Number(
+        Math.max(
+          0,
+          (priorCommitlessCounter * 0.86) +
+            (signals.commitlessFailureEvent ? 1.25 : 0) -
+            (signals.commitEvidence ? 1.1 : 0),
+        ).toFixed(3),
+      );
+      current.lastUpdatedAt = nowIso;
+      priorState.patterns[key] = current;
+    }
+  }
+
+  const outcomeEntries = Object.entries(priorState.outcomes || {});
+  if (outcomeEntries.length > maxOutcomes) {
+    outcomeEntries
+      .sort((a, b) => String(a[1]?.updatedAt || "").localeCompare(String(b[1]?.updatedAt || "")))
+      .slice(0, outcomeEntries.length - maxOutcomes)
+      .forEach(([id]) => {
+        delete priorState.outcomes[id];
+      });
+  }
+}
+
+function rankPlannerTaskCandidates(tasks, priorState, rankingConfig) {
+  const scored = (Array.isArray(tasks) ? tasks : []).map((task) => {
+    const impact = Number.isFinite(task?.impact) ? Number(task.impact) : 5;
+    const confidence = Number.isFinite(task?.confidence) ? Number(task.confidence) : 5;
+    const riskLevel = String(task?.risk || "").trim().toLowerCase();
+    const riskPenalty = ({ low: 0, medium: 0.4, high: 0.9, critical: 1.6 })[riskLevel] || 0;
+    const baseScore = (impact * 1.15) + (confidence * 0.85) - riskPenalty;
+
+    const keys = resolvePlannerPatternKeys(task);
+    const penalties = keys.map((key) => {
+      const prior = priorState?.patterns?.[key];
+      if (!prior || typeof prior !== "object") return { key, signalPenalty: 0, negativePrior: 0 };
+      const failureCount = Number(prior.failureCount || 0);
+      const successCount = Number(prior.successCount || 0);
+      const failureWeight = Number(prior.failureWeight || 0);
+      const successWeight = Number(prior.successWeight || 0);
+      const failureCounter = Number(prior.failureCounter || 0);
+      const commitlessFailureCounter = Number(prior.commitlessFailureCounter || 0);
+      const commitlessFailureCount = Number(prior.commitlessFailureCount || 0);
+      const commitlessSuccessCount = Number(prior.commitlessSuccessCount || 0);
+      const netFailureEvents = Math.max(0, failureCount - successCount);
+      const netFailureWeight = Math.max(0, failureWeight - successWeight);
+      const netCommitlessEvents = Math.max(0, commitlessFailureCount - commitlessSuccessCount);
+      const repeatedFailureSignal = Math.max(
+        netFailureEvents,
+        Math.max(0, failureCounter),
+        netCommitlessEvents,
+        Math.max(0, commitlessFailureCounter),
+      );
+      const signalPenalty = Math.max(
+        netFailureWeight * rankingConfig.signalPenaltyScale,
+        Math.max(0, failureCounter) * rankingConfig.signalPenaltyScale,
+      );
+      const negativePrior =
+        repeatedFailureSignal >= rankingConfig.failureThreshold
+          ? Math.min(
+            rankingConfig.maxNegativePrior,
+            rankingConfig.failurePriorStep * (repeatedFailureSignal - rankingConfig.failureThreshold + 1),
+          )
+          : 0;
+      return {
+        key,
+        signalPenalty,
+        negativePrior,
+        failureCounter: Math.max(0, failureCounter),
+        commitlessFailureCounter: Math.max(0, commitlessFailureCounter),
+        netCommitlessEvents,
+      };
+    });
+    const totalPenalty = penalties.reduce(
+      (sum, item) => sum + item.signalPenalty + item.negativePrior,
+      0,
+    );
+    const averagePenalty = penalties.length > 0 ? totalPenalty / penalties.length : 0;
+    const rankScore = baseScore - averagePenalty;
+
+    return {
+      ...task,
+      _ranking: {
+        baseScore: Number(baseScore.toFixed(3)),
+        penalty: Number(averagePenalty.toFixed(3)),
+        score: Number(rankScore.toFixed(3)),
+        patternKeys: keys,
+        penalties,
+      },
+    };
+  });
+
+  scored.sort((a, b) => {
+    if ((b?._ranking?.score || 0) !== (a?._ranking?.score || 0)) {
+      return (b?._ranking?.score || 0) - (a?._ranking?.score || 0);
+    }
+    return Number(a?.index || 0) - Number(b?.index || 0);
+  });
+  return scored;
+}
+
 function buildPlannerSkipReasonHistogram(skipped = []) {
   const histogram = {};
   for (const entry of skipped) {
@@ -4839,7 +6236,7 @@ function buildPlannerSkipReasonHistogram(skipped = []) {
   return histogram;
 }
 
-registerNodeType("action.materialize_planner_tasks", {
+registerBuiltinNodeType("action.materialize_planner_tasks", {
   describe: () => "Parse planner JSON output and create backlog tasks in Kanban",
   schema: {
     type: "object",
@@ -4854,6 +6251,10 @@ registerNodeType("action.materialize_planner_tasks", {
       minImpactScore: { type: "number", default: CALIBRATED_MIN_IMPACT_SCORE, description: "Minimum planner impact score required for creation; accepts 0-1 or 0-10 scales" },
       maxRiskWithoutHuman: { type: "string", default: CALIBRATED_MAX_RISK_WITHOUT_HUMAN, description: "Maximum planner risk level allowed for auto-creation (low|medium|high|critical)" },
       maxConcurrentRepoAreaTasks: { type: "number", default: 0, description: "Maximum concurrent backlog tasks per repo area (0 disables limit)" },
+      failurePriorThreshold: { type: "number", default: 2, description: "Net repeated failures required before applying negative priors" },
+      failurePriorStep: { type: "number", default: 1.5, description: "Penalty added per repeated failure beyond threshold" },
+      maxFailurePriorPenalty: { type: "number", default: 8, description: "Cap for repeated-failure negative prior penalty" },
+      feedbackSignalScale: { type: "number", default: 0.12, description: "Scale factor applied to weighted feedback signal penalties" },
     },
   },
   async execute(node, ctx, engine) {
@@ -4875,6 +6276,35 @@ registerNodeType("action.materialize_planner_tasks", {
       { preferTenScaleIntegers: true },
     ) || CALIBRATED_MAX_RISK_WITHOUT_HUMAN;
     const maxConcurrentRepoAreaTasks = Number(ctx.resolve(node.config?.maxConcurrentRepoAreaTasks ?? 0));
+    const rankingConfig = {
+      failureThreshold: Math.max(1, Number(ctx.resolve(node.config?.failurePriorThreshold ?? 2)) || 2),
+      failurePriorStep: Math.max(0, Number(ctx.resolve(node.config?.failurePriorStep ?? 1.5)) || 1.5),
+      maxNegativePrior: Math.max(0, Number(ctx.resolve(node.config?.maxFailurePriorPenalty ?? 8)) || 8),
+      signalPenaltyScale: Math.max(0, Number(ctx.resolve(node.config?.feedbackSignalScale ?? 0.12)) || 0.12),
+    };
+    const plannerFeedback = resolvePlannerFeedbackObject(ctx.data?._plannerFeedback);
+    const feedbackWeights = {
+      agentAttempts: Math.max(
+        0,
+        Number(plannerFeedback?.rankingSignals?.weights?.agentAttempts || 0.6),
+      ),
+      consecutiveNoCommits: Math.max(
+        0,
+        Number(
+          plannerFeedback?.rankingSignals?.weights?.consecutiveNoCommits || 1.3,
+        ),
+      ),
+      blockedReason: Math.max(
+        0,
+        Number(plannerFeedback?.rankingSignals?.weights?.blockedReason || 1.8),
+      ),
+      debtTrend: Math.max(
+        0,
+        Number(plannerFeedback?.rankingSignals?.weights?.debtTrend || 0.7),
+      ),
+      commitSuccess: 2.2,
+      completedSuccess: 0.8,
+    };
     const materializationDefaults = resolvePlannerMaterializationDefaults(ctx);
 
     const parsedTasks = extractPlannerTasksFromWorkflowOutput(outputText, maxTasks);
@@ -4904,14 +6334,19 @@ registerNodeType("action.materialize_planner_tasks", {
 
     const existingTitleSet = new Set();
     const existingBacklogAreaCounts = new Map();
+    let existingRows = [];
     const shouldFetchExistingTasks =
       Boolean(kanban?.listTasks)
-      && (dedupEnabled || (Number.isFinite(maxConcurrentRepoAreaTasks) && maxConcurrentRepoAreaTasks > 0));
+      && (
+        dedupEnabled
+        || (Number.isFinite(maxConcurrentRepoAreaTasks) && maxConcurrentRepoAreaTasks > 0)
+        || (Number.isFinite(rankingConfig.failureThreshold) && rankingConfig.failureThreshold > 0)
+      );
     if (shouldFetchExistingTasks) {
       try {
         const existing = await kanban.listTasks(projectId, {});
-        const rows = Array.isArray(existing) ? existing : [];
-        for (const row of rows) {
+        existingRows = Array.isArray(existing) ? existing : [];
+        for (const row of existingRows) {
           const title = String(row?.title || "").trim().toLowerCase();
           if (dedupEnabled && title) existingTitleSet.add(title);
           const rowStatus = String(row?.status || "").trim().toLowerCase();
@@ -4928,12 +6363,79 @@ registerNodeType("action.materialize_planner_tasks", {
         ctx.log(node.id, `Could not prefetch tasks for dedup: ${err.message}`, "warn");
       }
     }
+    const priorStatePath = shouldPersistPlannerPriorState()
+      ? resolvePlannerPriorStatePath()
+      : "";
+    const priorState = loadPlannerPriorState(priorStatePath);
+    replayPlannerOutcomes(existingRows, priorState, feedbackWeights);
+    const feedbackHotTasks = Array.isArray(plannerFeedback?.taskStore?.hotTasks)
+      ? plannerFeedback.taskStore.hotTasks
+      : [];
+    replayPlannerOutcomes(feedbackHotTasks, priorState, feedbackWeights);
+    const feedbackPatterns = Array.isArray(plannerFeedback?.rankingSignals?.patterns)
+      ? plannerFeedback.rankingSignals.patterns
+      : [];
+    for (const pattern of feedbackPatterns) {
+      if (!pattern || typeof pattern !== "object") continue;
+      const key = String(
+        pattern.key ||
+          buildPlannerPatternKey(
+            pattern.repoArea || pattern.repo_area || "global",
+            pattern.archetype || "general",
+          ),
+      ).trim();
+      if (!key) continue;
+      const entry = normalizePlannerPatternPrior(priorState.patterns[key]);
+      const incomingCounter = Math.max(0, Number(pattern.failureCounter || 0));
+      const incomingFailures = Math.max(0, Number(pattern.failures || 0));
+      const incomingSuccesses = Math.max(0, Number(pattern.successes || 0));
+      const incomingCommitlessCounter = Math.max(
+        0,
+        Number(pattern.commitlessFailureCounter || pattern.commitless_counter || 0),
+      );
+      const incomingCommitlessFailures = Math.max(
+        0,
+        Number(pattern.commitlessFailures || pattern.commitless_failures || 0),
+      );
+      const incomingCommitlessSuccesses = Math.max(
+        0,
+        Number(pattern.commitlessSuccesses || pattern.commitless_successes || 0),
+      );
+      entry.failureCounter = Number(
+        Math.max(entry.failureCounter || 0, incomingCounter).toFixed(3),
+      );
+      entry.failureCount = Math.max(
+        Number(entry.failureCount || 0),
+        incomingFailures,
+      );
+      entry.successCount = Math.max(
+        Number(entry.successCount || 0),
+        incomingSuccesses,
+      );
+      entry.commitlessFailureCounter = Number(
+        Math.max(entry.commitlessFailureCounter || 0, incomingCommitlessCounter).toFixed(3),
+      );
+      entry.commitlessFailureCount = Math.max(
+        Number(entry.commitlessFailureCount || 0),
+        incomingCommitlessFailures,
+      );
+      entry.commitlessSuccessCount = Math.max(
+        Number(entry.commitlessSuccessCount || 0),
+        incomingCommitlessSuccesses,
+      );
+      entry.lastUpdatedAt = new Date().toISOString();
+      priorState.patterns[key] = entry;
+    }
+    if (priorStatePath) {
+      savePlannerPriorState(priorStatePath, priorState);
+    }
+    const rankedTasks = rankPlannerTaskCandidates(parsedTasks, priorState, rankingConfig);
 
     const created = [];
     const skipped = [];
     const materializationOutcomes = [];
     const createdAreaCounts = new Map();
-    for (const task of parsedTasks) {
+    for (const task of rankedTasks) {
       const baseOutcome = {
         title: task.title,
         impact: task.impact,
@@ -5038,10 +6540,12 @@ registerNodeType("action.materialize_planner_tasks", {
       existingMeta.planner = {
         nodeId: plannerNodeId,
         index: task.index,
+        archetype: task.archetype || null,
         impact: task.impact,
         confidence: task.confidence,
         risk: task.risk,
         estimated_effort: task.estimatedEffort,
+        archetype: task.archetype,
         repo_areas: task.repoAreas,
         why_now: task.whyNow,
         kill_criteria: task.killCriteria,
@@ -5087,10 +6591,17 @@ registerNodeType("action.materialize_planner_tasks", {
       created,
       skipped,
       tasks: parsedTasks,
+      rankedTasks: rankedTasks.map((task) => ({
+        title: task.title,
+        archetype: task.archetype || null,
+        score: task?._ranking?.score,
+        penalty: task?._ranking?.penalty,
+        patternKeys: task?._ranking?.patternKeys || [],
+      })),
     };
   },
 });
-registerNodeType("agent.run_planner", {
+registerBuiltinNodeType("agent.run_planner", {
   describe: () => "Run the task planner agent to generate new backlog tasks",
   schema: {
     type: "object",
@@ -5233,7 +6744,7 @@ registerNodeType("agent.run_planner", {
     };
   },
 });
-registerNodeType("agent.evidence_collect", {
+registerBuiltinNodeType("agent.evidence_collect", {
   describe: () => "Collect all evidence from .bosun/evidence for review",
   schema: {
     type: "object",
@@ -5270,7 +6781,7 @@ registerNodeType("agent.evidence_collect", {
 //  FLOW CONTROL — Gates, barriers, and routing
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("flow.gate", {
+registerBuiltinNodeType("flow.gate", {
   describe: () => "Pause workflow execution until a condition is met or manual approval is given",
   schema: {
     type: "object",
@@ -5341,7 +6852,7 @@ registerNodeType("flow.gate", {
   },
 });
 
-registerNodeType("flow.join", {
+registerBuiltinNodeType("flow.join", {
   describe: () => "Explicitly join multiple branches before continuing",
   schema: {
     type: "object",
@@ -5440,7 +6951,7 @@ registerNodeType("flow.join", {
   },
 });
 
-registerNodeType("flow.end", {
+registerBuiltinNodeType("flow.end", {
   describe: () => "End the workflow immediately with explicit terminal status",
   schema: {
     type: "object",
@@ -5596,14 +7107,14 @@ const UNIVERSAL_FLOW_NODE = {
   },
 };
 
-registerNodeType("flow.universal", UNIVERSAL_FLOW_NODE);
-registerNodeType("flow.universial", UNIVERSAL_FLOW_NODE);
+registerBuiltinNodeType("flow.universal", UNIVERSAL_FLOW_NODE);
+registerBuiltinNodeType("flow.universial", UNIVERSAL_FLOW_NODE);
 
 // ═══════════════════════════════════════════════════════════════════════════
 //  LOOP / ITERATION
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("loop.for_each", {
+registerBuiltinNodeType("loop.for_each", {
   describe: () =>
     "Iterate over an array, executing a sub-workflow for each item. " +
     "Supports parallel fan-out via maxConcurrent and provides per-item " +
@@ -5696,7 +7207,7 @@ registerNodeType("loop.for_each", {
   },
 });
 
-registerNodeType("loop.while", {
+registerBuiltinNodeType("loop.while", {
   describe: () =>
     "Repeat a sub-workflow until a condition evaluates to false or max iterations " +
     "are reached. Enables convergence loops (generate→verify→revise) by executing " +
@@ -5836,7 +7347,7 @@ registerNodeType("loop.while", {
 //  SESSION / AGENT MANAGEMENT — Direct session control
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("action.continue_session", {
+registerBuiltinNodeType("action.continue_session", {
   describe: () => "Re-attach to an existing agent session and send a continuation prompt",
   schema: {
     type: "object",
@@ -5894,7 +7405,7 @@ registerNodeType("action.continue_session", {
   },
 });
 
-registerNodeType("action.restart_agent", {
+registerBuiltinNodeType("action.restart_agent", {
   describe: () => "Kill and restart an agent session from scratch",
   schema: {
     type: "object",
@@ -5950,7 +7461,7 @@ registerNodeType("action.restart_agent", {
   },
 });
 
-registerNodeType("action.bosun_cli", {
+registerBuiltinNodeType("action.bosun_cli", {
   describe: () => "Run a bosun CLI command (task, monitor, agent, etc.)",
   schema: {
     type: "object",
@@ -6020,7 +7531,7 @@ async function getKanbanMod() {
 // input/output. Unlike action.bosun_cli (which shells out), this executes
 // the tool script directly in-process and returns parsed, structured data.
 
-registerNodeType("action.bosun_tool", {
+registerBuiltinNodeType("action.bosun_tool", {
   describe: () =>
     "Invoke a Bosun built-in or custom tool programmatically. Returns " +
     "structured output that downstream workflow nodes can consume via " +
@@ -6223,7 +7734,7 @@ registerNodeType("action.bosun_tool", {
 // simpler ergonomics for the common case of "run workflow X and pipe
 // its output to the next node".
 
-registerNodeType("action.invoke_workflow", {
+registerBuiltinNodeType("action.invoke_workflow", {
   describe: () =>
     "Invoke another workflow and pipe its output to downstream nodes. " +
     "Simpler than action.execute_workflow — designed for workflow-to-workflow " +
@@ -6649,7 +8160,7 @@ const BOSUN_FUNCTION_REGISTRY = Object.freeze({
   },
 });
 
-registerNodeType("action.bosun_function", {
+registerBuiltinNodeType("action.bosun_function", {
   describe: () =>
     "Invoke an internal Bosun function directly (tasks, git, tools, workflows, config). " +
     "Returns structured output that downstream nodes can consume. More powerful " +
@@ -6762,7 +8273,7 @@ registerNodeType("action.bosun_function", {
   },
 });
 
-registerNodeType("action.handle_rate_limit", {
+registerBuiltinNodeType("action.handle_rate_limit", {
   describe: () => "Intelligently handle API rate limits with exponential backoff and provider rotation",
   schema: {
     type: "object",
@@ -6809,7 +8320,7 @@ registerNodeType("action.handle_rate_limit", {
   },
 });
 
-registerNodeType("action.ask_user", {
+registerBuiltinNodeType("action.ask_user", {
   describe: () => "Pause workflow and ask the user for input via Telegram or UI",
   schema: {
     type: "object",
@@ -6855,7 +8366,7 @@ registerNodeType("action.ask_user", {
   },
 });
 
-registerNodeType("action.analyze_errors", {
+registerBuiltinNodeType("action.analyze_errors", {
   describe: () => "Run the error detector on recent logs and classify failures",
   schema: {
     type: "object",
@@ -6917,7 +8428,7 @@ registerNodeType("action.analyze_errors", {
   },
 });
 
-registerNodeType("action.refresh_worktree", {
+registerBuiltinNodeType("action.refresh_worktree", {
   describe: () => "Refresh git worktree state — fetch, pull, or reset to clean state",
   schema: {
     type: "object",
@@ -7198,7 +8709,7 @@ async function _executeMcpToolCall(serverId, toolName, input, timeoutMs, ctx) {
   };
 }
 
-registerNodeType("action.mcp_tool_call", {
+registerBuiltinNodeType("action.mcp_tool_call", {
   describe: () =>
     "Call a tool on an installed MCP server with structured output extraction. " +
     "Supports field extraction, output mapping, type coercion, and port-based " +
@@ -7350,7 +8861,7 @@ registerNodeType("action.mcp_tool_call", {
   },
 });
 
-registerNodeType("action.mcp_list_tools", {
+registerBuiltinNodeType("action.mcp_list_tools", {
   describe: () =>
     "List available tools on an installed MCP server, including their input " +
     "schemas. Useful for dynamic tool discovery and auto-wiring in pipelines.",
@@ -7435,7 +8946,7 @@ registerNodeType("action.mcp_list_tools", {
 
 // ── action.mcp_pipeline — Chain multiple MCP tool calls with data piping ──
 
-registerNodeType("action.mcp_pipeline", {
+registerBuiltinNodeType("action.mcp_pipeline", {
   describe: () =>
     "Execute a chain of MCP tool calls in sequence, piping structured output " +
     "from each step to the next. Each step can extract specific fields from " +
@@ -7659,7 +9170,7 @@ registerNodeType("action.mcp_pipeline", {
 
 // ── transform.mcp_extract — Extract structured data from any MCP output ──
 
-registerNodeType("transform.mcp_extract", {
+registerBuiltinNodeType("transform.mcp_extract", {
   describe: () =>
     "Extract and reshape structured data from an upstream MCP tool call or " +
     "any node output. Supports dot-path fields, JSON pointers, array wildcards, " +
@@ -8112,14 +9623,76 @@ function isValidGitWorktreePath(worktreePath) {
       timeout: 5000,
       stdio: ["ignore", "pipe", "pipe"],
     }).trim().toLowerCase();
-    return inside === "true";
+    if (inside !== "true") return false;
+    // A nested folder inside the main repo also returns inside-work-tree=true.
+    // Reuse is safe only when the path itself is the git top-level root.
+    const topLevel = execGitArgsSync(["rev-parse", "--show-toplevel"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    const normalize = (value) =>
+      resolve(String(value || ""))
+        .replace(/\\/g, "/")
+        .replace(/\/+$/, "");
+    return normalize(topLevel) === normalize(worktreePath);
   } catch {
     return false;
   }
 }
 
+function resolveGitDirForWorktree(worktreePath) {
+  if (!worktreePath || !existsSync(worktreePath)) return "";
+  try {
+    const topLevel = execGitArgsSync(["rev-parse", "--show-toplevel"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    const normalize = (value) =>
+      resolve(String(value || ""))
+        .replace(/\\/g, "/")
+        .replace(/\/+$/, "")
+        .toLowerCase();
+    if (normalize(topLevel) !== normalize(worktreePath)) return "";
+    const gitDir = execGitArgsSync(["rev-parse", "--git-dir"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    if (!gitDir) return "";
+    return resolve(worktreePath, gitDir);
+  } catch {
+    return "";
+  }
+}
+
+function hasUnresolvedGitOperation(worktreePath) {
+  if (!worktreePath || !existsSync(worktreePath)) return false;
+  try {
+    const gitDir = resolveGitDirForWorktree(worktreePath);
+    if (!gitDir || !existsSync(gitDir)) return true;
+    for (const marker of ["rebase-merge", "rebase-apply", "MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
+      if (existsSync(resolve(gitDir, marker))) return true;
+    }
+    const unmerged = execGitArgsSync(["diff", "--name-only", "--diff-filter=U"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    return Boolean(unmerged);
+  } catch {
+    return true;
+  }
+}
+
 function cleanupBrokenManagedWorktree(repoRoot, worktreePath) {
   if (!worktreePath) return;
+  const linkedGitDir = resolveGitDirForWorktree(worktreePath);
   try {
     execGitArgsSync(["worktree", "remove", String(worktreePath), "--force"], {
       cwd: repoRoot,
@@ -8135,6 +9708,13 @@ function cleanupBrokenManagedWorktree(repoRoot, worktreePath) {
   } catch {
     /* best-effort */
   }
+  try {
+    if (linkedGitDir && existsSync(linkedGitDir)) {
+      rmSync(linkedGitDir, { recursive: true, force: true });
+    }
+  } catch {
+    /* best-effort */
+  }
   try {
     execGitArgsSync(["worktree", "prune"], {
       cwd: repoRoot,
@@ -8163,7 +9743,7 @@ const STRICT_START_GUARD_MISSING_TASK = /^(1|true|yes|on)$/i.test(
 
 // ── trigger.task_available ──────────────────────────────────────────────────
 
-registerNodeType("trigger.task_available", {
+registerBuiltinNodeType("trigger.task_available", {
   describe: () =>
     "Polling trigger that fires when todo tasks are available. Handles " +
     "slot limits, anti-thrash filtering, cooldowns, task sorting (fire " +
@@ -8544,7 +10124,7 @@ registerNodeType("trigger.task_available", {
 });
 // ── condition.slot_available ────────────────────────────────────────────────
 
-registerNodeType("condition.slot_available", {
+registerBuiltinNodeType("condition.slot_available", {
   describe: () =>
     "Gate checking both global and per-base-branch concurrency limits.",
   schema: {
@@ -8579,7 +10159,7 @@ registerNodeType("condition.slot_available", {
 
 // ── action.allocate_slot ────────────────────────────────────────────────────
 
-registerNodeType("action.allocate_slot", {
+registerBuiltinNodeType("action.allocate_slot", {
   describe: () =>
     "Reserve a parallel execution slot. Saves process env snapshot for " +
     "parallel isolation and stores slot metadata in workflow context.",
@@ -8637,7 +10217,7 @@ registerNodeType("action.allocate_slot", {
 
 // ── action.release_slot ─────────────────────────────────────────────────────
 
-registerNodeType("action.release_slot", {
+registerBuiltinNodeType("action.release_slot", {
   describe: () =>
     "Release a previously allocated execution slot. Restores saved env vars " +
     "for parallel isolation. Idempotent — safe on double-call.",
@@ -8672,7 +10252,7 @@ registerNodeType("action.release_slot", {
 
 // ── action.claim_task ───────────────────────────────────────────────────────
 
-registerNodeType("action.claim_task", {
+registerBuiltinNodeType("action.claim_task", {
   describe: () =>
     "Acquire a distributed task claim with auto-renewal. Prevents duplicate " +
     "execution across orchestrators. Stores claim token + renewal timer in " +
@@ -8802,7 +10382,7 @@ registerNodeType("action.claim_task", {
 
 // ── action.release_claim ────────────────────────────────────────────────────
 
-registerNodeType("action.release_claim", {
+registerBuiltinNodeType("action.release_claim", {
   describe: () =>
     "Release a distributed task claim + cancel renewal timer. Idempotent.",
   schema: {
@@ -8866,7 +10446,7 @@ registerNodeType("action.release_claim", {
 
 // ── action.resolve_executor ─────────────────────────────────────────────────
 
-registerNodeType("action.resolve_executor", {
+registerBuiltinNodeType("action.resolve_executor", {
   describe: () =>
     "Pick SDK + model via complexity routing, env overrides, or defaults.",
   schema: {
@@ -8893,6 +10473,12 @@ registerNodeType("action.resolve_executor", {
       description: cfgOrCtx(node, ctx, "taskDescription"),
       tags: Array.isArray(ctx.data?.task?.tags) ? ctx.data.task.tags : [],
     };
+    const requestedAgentProfileId = String(
+      cfgOrCtx(node, ctx, "agentProfile")
+      || ctx.data?.task?.agentProfile
+      || ctx.data?.agentProfile
+      || "",
+    ).trim();
     let profileDecision = null;
     let configuredExecutorPreference = null;
 
@@ -8917,12 +10503,32 @@ registerNodeType("action.resolve_executor", {
           title: task.title,
           description: task.description,
           tags: task.tags,
+          agentType: ctx.data?.task?.agentType || ctx.data?.agentType || "",
           repoRoot,
         },
-        { topN: 1 },
+        { topN: Math.max(10, requestedAgentProfileId ? 25 : 10) },
       );
-      const profile = match?.best?.profile || null;
-      const profileId = String(match?.best?.id || "").trim();
+      const candidates = Array.isArray(match?.candidates) ? match.candidates : [];
+      const bestCandidate = match?.best || null;
+      const autoMinScore = Number(match?.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) {
+        ctx.log(
+          node.id,
+          `Profile match below auto threshold; ignoring candidate ${String(bestCandidate.id || "unknown")}`,
+        );
+      }
+      const profile = matchedCandidate?.profile || null;
+      const profileId = String(matchedCandidate?.id || "").trim();
+      if (requestedAgentProfileId && !profileId) {
+        ctx.log(
+          node.id,
+          `Requested agent profile "${requestedAgentProfileId}" not found; falling back to executor defaults`,
+        );
+      }
       if (profileId && profile) {
         profileDecision = { id: profileId, profile };
         ctx.data.agentProfile = profileId;
@@ -9049,7 +10655,7 @@ registerNodeType("action.resolve_executor", {
 
 // ── action.acquire_worktree ─────────────────────────────────────────────────
 
-registerNodeType("action.acquire_worktree", {
+registerBuiltinNodeType("action.acquire_worktree", {
   describe: () =>
     "Create or checkout a git worktree for isolated task execution. " +
     "Fetches base branch, creates worktree, handles branch conflicts.",
@@ -9126,6 +10732,9 @@ registerNodeType("action.acquire_worktree", {
         if (!isValidGitWorktreePath(worktreePath)) {
           ctx.log(node.id, `Managed worktree is invalid, recreating: ${worktreePath}`);
           cleanupBrokenManagedWorktree(repoRoot, worktreePath);
+        } else if (hasUnresolvedGitOperation(worktreePath)) {
+          ctx.log(node.id, `Managed worktree has unresolved git state, recreating: ${worktreePath}`);
+          cleanupBrokenManagedWorktree(repoRoot, worktreePath);
         }
       }
 
@@ -9141,14 +10750,20 @@ registerNodeType("action.acquire_worktree", {
           } 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);
+          }
+        }
+        if (existsSync(worktreePath)) {
+          ctx.data.worktreePath = worktreePath;
+          ctx.data._worktreeCreated = false;
+          ctx.data._worktreeManaged = true;
+          ctx.log(node.id, `Reusing worktree: ${worktreePath}`);
+          const cleared1 = clearBlockedWorktreeIdentity(worktreePath);
+          if (cleared1) ctx.log(node.id, `Cleared blocked test git identity from worktree: ${worktreePath}`);
+          return { success: true, worktreePath, created: false, reused: true, branch, baseBranch };
         }
-        ctx.data.worktreePath = worktreePath;
-        ctx.data._worktreeCreated = false;
-        ctx.data._worktreeManaged = true;
-        ctx.log(node.id, `Reusing worktree: ${worktreePath}`);
-        const cleared1 = clearBlockedWorktreeIdentity(worktreePath);
-        if (cleared1) ctx.log(node.id, `Cleared blocked test git identity from worktree: ${worktreePath}`);
-        return { success: true, worktreePath, created: false, reused: true, branch, baseBranch };
       }
 
       // Create fresh worktree
@@ -9223,7 +10838,7 @@ registerNodeType("action.acquire_worktree", {
 
 // ── action.release_worktree ─────────────────────────────────────────────────
 
-registerNodeType("action.release_worktree", {
+registerBuiltinNodeType("action.release_worktree", {
   describe: () =>
     "Release a git worktree. Idempotent. Optionally prunes stale entries.",
   schema: {
@@ -9434,7 +11049,7 @@ registerNodeType("action.workflow_contract_validation", workflowContractValidati
 
 // ── action.build_task_prompt ────────────────────────────────────────────────
 
-registerNodeType("action.build_task_prompt", {
+registerBuiltinNodeType("action.build_task_prompt", {
   describe: () =>
     "Compose the full agent prompt from task data, AGENTS.md, comments, " +
     "copilot-instructions.md, agent status endpoint, and co-author trailer.",
@@ -9554,70 +11169,161 @@ registerNodeType("action.build_task_prompt", {
     const allowedRepositories = normalizeStringArray(repositories, primaryRepository);
     const matchedSkills = findRelevantSkills(repoRoot, taskTitle, taskDescription || "", {});
     const activeSkillFiles = matchedSkills.map((skill) => skill.filename);
+    const strictCacheAnchoring =
+      String(process.env.BOSUN_CACHE_ANCHOR_MODE || "")
+        .trim()
+        .toLowerCase() === "strict";
+
+    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("");
+
+      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" +
+          "2. Use the discovery MCP tools for non-eager MCP/custom tools before assuming a capability is unavailable.\n" +
+          "3. Implement the required changes.\n" +
+          "4. Ensure tests pass and build is clean with 0 warnings.\n" +
+          "5. Commit your changes using conventional commits.\n" +
+          "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();
+    };
 
     if (customTemplate) {
+      const stableSystemPrompt = buildStableSystemPrompt();
       ctx.data._taskPrompt = customTemplate;
+      ctx.data._taskUserPrompt = customTemplate;
+      ctx.data._taskSystemPrompt = stableSystemPrompt;
       ctx.log(node.id, `Prompt from custom template (${customTemplate.length} chars)`);
-      return { success: true, prompt: customTemplate, source: "custom" };
+      return {
+        success: true,
+        prompt: customTemplate,
+        userPrompt: customTemplate,
+        systemPrompt: stableSystemPrompt,
+        source: "custom",
+      };
     }
 
-    const parts = [];
+    const userParts = [];
 
     // Header
-    parts.push(`# Task: ${taskTitle}`);
-    if (taskId) parts.push(`Task ID: ${taskId}`);
-    parts.push("");
+    userParts.push(`# Task: ${taskTitle}`);
+    if (taskId) userParts.push(`Task ID: ${taskId}`);
+    userParts.push("");
 
     // Retry context (if applicable)
     if (retryReason) {
-      parts.push("## Retry Context");
-      parts.push(`Previous attempt failed: ${retryReason}`);
-      parts.push("Try a different approach this time.");
-      parts.push("");
+      userParts.push("## Retry Context");
+      userParts.push(`Previous attempt failed: ${retryReason}`);
+      userParts.push("Try a different approach this time.");
+      userParts.push("");
     }
 
     // Description
     if (taskDescription) {
-      parts.push("## Description");
-      parts.push(taskDescription);
-      parts.push("");
+      userParts.push("## Description");
+      userParts.push(taskDescription);
+      userParts.push("");
     }
 
     // Environment context
-    parts.push("## Environment");
+    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 (envLines.length) parts.push(envLines.join("\n"));
-    parts.push("");
+    if (envLines.length) userParts.push(envLines.join("\n"));
+    userParts.push("");
 
     // Workspace and repository scope guardrails.
-    parts.push("## Workspace Scope Contract");
-    if (workspace) parts.push(`- **Workspace:** ${workspace}`);
-    if (primaryRepository) parts.push(`- **Primary Repository:** ${primaryRepository}`);
+    userParts.push("## Workspace Scope Contract");
+    if (workspace) userParts.push(`- **Workspace:** ${workspace}`);
+    if (primaryRepository) userParts.push(`- **Primary Repository:** ${primaryRepository}`);
     if (allowedRepositories.length > 0) {
-      parts.push("- **Allowed Repositories:**");
+      userParts.push("- **Allowed Repositories:**");
       for (const allowedRepo of allowedRepositories) {
-        parts.push(`  - ${allowedRepo}`);
+        userParts.push(`  - ${allowedRepo}`);
       }
     } else {
-      parts.push("- **Allowed Repositories:** (not declared)");
+      userParts.push("- **Allowed Repositories:** (not declared)");
     }
-    if (worktreePath) parts.push(`- **Write Scope Root:** ${worktreePath}`);
-    parts.push("");
-    parts.push("Hard boundaries:");
+    if (worktreePath) userParts.push(`- **Write Scope Root:** ${worktreePath}`);
+    userParts.push("");
+    userParts.push("Hard boundaries:");
     if (worktreePath) {
-      parts.push(`1. Modify files only inside \`${worktreePath}\`.`);
+      userParts.push(`1. Modify files only inside \`${worktreePath}\`.`);
     } else {
-      parts.push("1. Modify files only inside the active repository working directory.");
+      userParts.push("1. Modify files only inside the active repository working directory.");
     }
-    parts.push("2. Modify code only in the allowed repositories listed above.");
-    parts.push("3. If required work depends on an unlisted repository, stop and report `blocked: cross-repo dependency`.");
-    parts.push("4. In completion notes, list every repository you touched and why.");
-    parts.push("");
+    userParts.push("2. Modify code only in the allowed repositories listed above.");
+    userParts.push("3. If required work depends on an unlisted repository, stop and report `blocked: cross-repo dependency`.");
+    userParts.push("4. In completion notes, list every repository you touched and why.");
+    userParts.push("");
 
     let workflowContractPromptBlock = String(ctx.data?._workflowContractPromptBlock || "").trim();
     if (!workflowContractPromptBlock) {
@@ -9636,8 +11342,8 @@ registerNodeType("action.build_task_prompt", {
       }
     }
     if (workflowContractPromptBlock) {
-      parts.push(workflowContractPromptBlock);
-      parts.push("");
+      userParts.push(workflowContractPromptBlock);
+      userParts.push("");
     }
 
     // AGENTS.md + copilot-instructions.md
@@ -9654,9 +11360,9 @@ registerNodeType("action.build_task_prompt", {
               const content = readFileSync(fullPath, "utf8").trim();
               if (content && content.length > 10) {
                 loaded.add(doc);
-                parts.push(`## ${doc}`);
-                parts.push(content);
-                parts.push("");
+                userParts.push(`## ${doc}`);
+                userParts.push(content);
+                userParts.push("");
               }
             }
           } catch { /* best-effort */ }
@@ -9668,12 +11374,12 @@ registerNodeType("action.build_task_prompt", {
     if (includeStatusEndpoint) {
       const port = process.env.AGENT_ENDPOINT_PORT || process.env.BOSUN_AGENT_ENDPOINT_PORT || "";
       if (port) {
-        parts.push("## Agent Status Endpoint");
-        parts.push(`POST http://127.0.0.1:${port}/status — Report progress`);
-        parts.push(`POST http://127.0.0.1:${port}/heartbeat — Heartbeat ping`);
-        parts.push(`POST http://127.0.0.1:${port}/error — Report errors`);
-        parts.push(`POST http://127.0.0.1:${port}/complete — Signal completion`);
-        parts.push("");
+        userParts.push("## Agent Status Endpoint");
+        userParts.push(`POST http://127.0.0.1:${port}/status — Report progress`);
+        userParts.push(`POST http://127.0.0.1:${port}/heartbeat — Heartbeat ping`);
+        userParts.push(`POST http://127.0.0.1:${port}/error — Report errors`);
+        userParts.push(`POST http://127.0.0.1:${port}/complete — Signal completion`);
+        userParts.push("");
       }
     }
 
@@ -9684,8 +11390,8 @@ registerNodeType("action.build_task_prompt", {
       {},
     );
     if (relevantSkillsBlock) {
-      parts.push(relevantSkillsBlock);
-      parts.push("");
+      userParts.push(relevantSkillsBlock);
+      userParts.push("");
     }
 
     // Inject library-resolved skills from agent.select_profile.
@@ -9711,70 +11417,73 @@ registerNodeType("action.build_task_prompt", {
           librarySkillParts.push("");
         }
         if (librarySkillParts.length > 0) {
-          parts.push("## Library Skills");
-          parts.push(...librarySkillParts);
+          userParts.push("## Library Skills");
+          userParts.push(...librarySkillParts);
         }
       } catch (err) {
         ctx.log(node.id, `Library skill injection failed (non-fatal): ${err.message}`);
       }
     }
-
-    parts.push("## Tool Discovery");
-    parts.push(
-      "Bosun uses a compact MCP discovery layer for external MCP servers and the custom tool library.",
-    );
-    parts.push(
-      "Preferred flow: `search` -> `get_schema` -> `execute`.",
-    );
-    parts.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.",
-    );
-    parts.push("");
-
-    const eagerToolBlock = getToolsPromptBlock(repoRoot, {
+    // 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: true,
+      emitReflectHint: false,
       limit: 12,
     });
-    if (eagerToolBlock) {
-      parts.push(eagerToolBlock);
-      parts.push("");
-    }
-
-    // Instructions
-    parts.push("## Instructions");
-    parts.push(
-      "1. Read and understand the task description above.\n" +
-      "2. Follow the project instructions in AGENTS.md.\n" +
-      "3. Respect the Workspace Scope Contract and never cross repository boundaries.\n" +
-      "4. Load and apply the matched important skills already inlined above.\n" +
-      "5. Use the discovery MCP tools for non-eager MCP/custom tools before assuming a capability is unavailable.\n" +
-      "6. Implement the required changes.\n" +
-      "7. Ensure tests pass and build is clean with 0 warnings.\n" +
-      "8. Commit your changes using conventional commits.\n" +
-      "9. Never ask for user input — you are autonomous.\n" +
-      "10. Use all available tools to verify your work.",
-    );
-    parts.push("");
+    if (taskScopedEagerTools) {
+      userParts.push(taskScopedEagerTools);
+      userParts.push("");
+    }
 
-    // Co-author trailer
-    parts.push("## Git Attribution");
-    parts.push("Add this trailer to all commits:");
-    parts.push("Co-authored-by: bosun[bot] <bosun@virtengine.com>");
+    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}"`,
+        );
+      }
+    }
 
-    const prompt = parts.join("\n");
-    ctx.data._taskPrompt = prompt;
-    ctx.log(node.id, `Prompt built (${prompt.length} chars)`);
-    return { success: true, prompt, source: "generated", length: prompt.length };
+    ctx.data._taskPrompt = userPrompt;
+    ctx.data._taskUserPrompt = userPrompt;
+    ctx.data._taskSystemPrompt = systemPrompt;
+    ctx.log(
+      node.id,
+      `Prompt built (user=${userPrompt.length} chars, system=${systemPrompt.length} chars, strict=${strictCacheAnchoring})`,
+    );
+    return {
+      success: true,
+      prompt: userPrompt,
+      userPrompt,
+      systemPrompt,
+      source: "generated",
+      length: userPrompt.length,
+      systemLength: systemPrompt.length,
+      cacheAnchorMode: strictCacheAnchoring ? "strict" : "default",
+    };
   },
 });
 
 // ── action.detect_new_commits ───────────────────────────────────────────────
 
-registerNodeType("action.detect_new_commits", {
+registerBuiltinNodeType("action.detect_new_commits", {
   describe: () =>
     "Compare pre/post execution HEAD to detect new commits. Also checks " +
     "for unpushed commits vs base and collects diff stats.",
@@ -9898,7 +11607,7 @@ registerNodeType("action.detect_new_commits", {
 
 // ── action.push_branch ──────────────────────────────────────────────────────
 
-registerNodeType("action.push_branch", {
+registerBuiltinNodeType("action.push_branch", {
   describe: () =>
     "Push the current branch to the remote. Includes rebase-before-push, " +
     "empty-diff guard, protected branch safety, and optional main-branch sync.",
@@ -9910,6 +11619,7 @@ registerNodeType("action.push_branch", {
       baseBranch: { type: "string", description: "Base branch to rebase onto" },
       remote: { type: "string", default: "origin", description: "Remote name" },
       forceWithLease: { type: "boolean", default: true, description: "Use --force-with-lease" },
+      skipHooks: { type: "boolean", default: true, description: "Skip git pre-push hooks (--no-verify)" },
       rebaseBeforePush: { type: "boolean", default: true, description: "Rebase onto base before push" },
       emptyDiffGuard: { type: "boolean", default: true, description: "Abort if no files changed vs base" },
       syncMainForModuleBranch: { type: "boolean", default: false, description: "Also sync base with main" },
@@ -9928,6 +11638,7 @@ registerNodeType("action.push_branch", {
     const baseBranch = cfgOrCtx(node, ctx, "baseBranch", "origin/main");
     const remote = node.config?.remote || "origin";
     const forceWithLease = node.config?.forceWithLease !== false;
+    const skipHooks = node.config?.skipHooks !== false;
     const rebaseBeforePush = node.config?.rebaseBeforePush !== false;
     const emptyDiffGuard = node.config?.emptyDiffGuard !== false;
     const syncMain = node.config?.syncMainForModuleBranch === true;
@@ -10039,8 +11750,10 @@ registerNodeType("action.push_branch", {
     }
 
     // ── Push ──
-    const pushFlags = forceWithLease ? "--force-with-lease" : "";
-    const cmd = `git push ${pushFlags} --set-upstream ${remote} HEAD`.trim();
+    const pushFlags = [];
+    if (forceWithLease) pushFlags.push("--force-with-lease");
+    if (skipHooks) pushFlags.push("--no-verify");
+    const cmd = `git push ${pushFlags.join(" ")} --set-upstream ${remote} HEAD`.trim();
 
     try {
       const output = execSync(cmd, {
@@ -10072,7 +11785,7 @@ registerNodeType("action.push_branch", {
 //  WEB SEARCH — Structured web search for research workflows
 // ═══════════════════════════════════════════════════════════════════════════
 
-registerNodeType("action.web_search", {
+registerBuiltinNodeType("action.web_search", {
   describe: () =>
     "Perform a structured web search query and return results. Useful for " +
     "research workflows (e.g., Aletheia-style math/science agents) that need " +
@@ -10255,5 +11968,24 @@ registerNodeType("action.web_search", {
 // ═══════════════════════════════════════════════════════════════════════════
 
 export { registerNodeType, getNodeType, listNodeTypes } from "./workflow-engine.mjs";
-
 export { evaluateTaskAssignedTriggerConfig };
+export {
+  CUSTOM_NODE_DIR_NAME,
+  getCustomNodeDir,
+  scaffoldCustomNodeFile,
+  startCustomNodeDiscovery,
+  stopCustomNodeDiscovery,
+  unregisterNodeType,
+};
+
+export async function ensureWorkflowNodeTypesLoaded(options = {}) {
+  if (!customLoadPromise || options.forceReload) {
+    customLoadPromise = ensureCustomWorkflowNodesLoaded(options);
+  }
+  await customLoadPromise;
+  if (!customDiscoveryStarted) {
+    startCustomNodeDiscovery(options);
+    customDiscoveryStarted = true;
+  }
+  return listNodeTypes();
+}