bosun 0.42.2 → 0.42.4

package/workflow/workflow-nodes.mjs

@@ -39,6 +39,7 @@ import { getToolsPromptBlock } from "../agent/agent-custom-tools.mjs";
 import { buildRelevantSkillsPromptBlock, emitSkillInvokeEvent, findRelevantSkills } from "../agent/bosun-skills.mjs";
 import { readBenchmarkModeState, taskMatchesBenchmarkMode } from "../bench/benchmark-mode.mjs";
 import { getSessionTracker } from "../infra/session-tracker.mjs";
+import { runInIsolatedRunner } from "../infra/container-runner.mjs";
 import { recordWorktreeRecoveryEvent } from "../infra/worktree-recovery-state.mjs";
 import {
   appendKnowledgeEntry,
@@ -57,7 +58,7 @@ import { loadConfig } from "../config/config.mjs";
 import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
 import { clearBlockedWorktreeIdentity, normalizeBaseBranch } from "../git/git-safety.mjs";
 import { getBosunCoAuthorTrailer, shouldAddBosunCoAuthor } from "../git/git-commit-helpers.mjs";
-import { buildArchitectEditorFrame } from "../lib/repo-map.mjs";
+import { buildArchitectEditorFrame, buildRepoTopologyContext, hasRepoMapContext } from "../lib/repo-map.mjs";
 import { getGitHubToken, invalidateTokenType } from "../github/github-auth-manager.mjs";
 import {
   CUSTOM_NODE_DIR_NAME,
@@ -1448,6 +1449,208 @@ async function compactWorkflowCommandResult({
   };
 }
 
+function isValidationSandboxFailureText(text) {
+  return /(?:sandbox|operation not permitted|permission denied|access is denied|read-only file system|EPERM|EACCES|denied by policy|seccomp)/i.test(
+    String(text || ""),
+  );
+}
+
+function isValidationBootstrapFailureText(text) {
+  return /(?:\bENOENT\b|spawn\s+.+\s+ENOENT|not recognized as an internal or external command|is not recognized as a name of a cmdlet|command not found|executable file not found|no such file or directory|cannot find the file|failed to start|startup failure)/i.test(
+    String(text || ""),
+  );
+}
+
+function buildValidationFailureDiagnostic({
+  command = "",
+  args = [],
+  status = "error",
+  exitCode = null,
+  stderr = "",
+  output = "",
+  timeoutMs = null,
+  blocked = false,
+  failureDiagnostic = null,
+} = {}) {
+  if (failureDiagnostic && typeof failureDiagnostic === "object") return failureDiagnostic;
+  const normalizedStatus = String(status || "error").trim().toLowerCase();
+  if (!blocked && normalizedStatus === "success" && Number(exitCode ?? 0) === 0) {
+    return null;
+  }
+  const combinedText = [stderr, output]
+    .map((value) => String(value || "").trim())
+    .find(Boolean) || "";
+
+  let category = "command_failure";
+  let retryable = false;
+  let summary = `Validation command exited with code ${exitCode ?? "unknown"}.`;
+
+  if (blocked || normalizedStatus === "blocked") {
+    category = "runner_unavailable";
+    retryable = true;
+    summary = "Isolated runner was unavailable before the validation command started.";
+  } else if (normalizedStatus === "timeout" || /(?:timed out|ETIMEDOUT|SIGTERM)/i.test(combinedText)) {
+    category = "timeout";
+    retryable = true;
+    const numericTimeoutMs = timeoutMs != null ? Number(timeoutMs) : NaN;
+    if (Number.isFinite(numericTimeoutMs) && numericTimeoutMs > 0) {
+      summary = `Validation timed out after ${numericTimeoutMs}ms.`;
+    } else {
+      summary = "Validation timed out after the configured timeout.";
+    }
+  } else if (isValidationSandboxFailureText(combinedText)) {
+    category = "sandbox_error";
+    retryable = false;
+    summary = "Validation was blocked by sandbox or filesystem restrictions.";
+  } else if (isValidationBootstrapFailureText(combinedText) || normalizedStatus === "error" && (exitCode == null || Number(exitCode) < 0)) {
+    category = "bootstrap_failure";
+    retryable = true;
+    summary = "Validation could not start cleanly.";
+  }
+
+  const detail = String(combinedText || "").trim().split(/\r?\n/).find(Boolean) || "";
+  return {
+    category,
+    retryable,
+    summary,
+    detail,
+    status: normalizedStatus,
+    exitCode: exitCode ?? null,
+    blocked: blocked === true,
+    command,
+    args: Array.isArray(args) ? [...args] : [],
+  };
+}
+
+function didValidationCommandPass(result = {}) {
+  if (!result || result.blocked === true || result.failureDiagnostic) return false;
+  const status = String(result.status || "success").trim().toLowerCase();
+  if (status && status !== "success") return false;
+  return Number(result.exitCode ?? 0) === 0;
+}
+
+function buildValidationResult({
+  passed,
+  exitCode = null,
+  blocked = false,
+  compacted = {},
+  extras = {},
+  failureDiagnostic = null,
+} = {}) {
+  return {
+    passed,
+    exitCode,
+    blocked,
+    ...(failureDiagnostic
+      ? {
+          failureKind: failureDiagnostic.category || null,
+          retryable: failureDiagnostic.retryable === true,
+          failureDiagnostic,
+        }
+      : {}),
+    ...compacted,
+    ...extras,
+  };
+}
+
+function buildIsolatedRunnerResultExtras(result, lane) {
+  const artifacts = Array.isArray(result?.artifacts) ? result.artifacts : [];
+  return {
+    isolatedRunner: {
+      lane: lane?.lane || "main",
+      reason: lane?.reason || "unknown",
+      provider: result?.provider || null,
+      leaseId: result?.leaseId || null,
+      artifactRoot: result?.artifactRoot || null,
+      attempts: result?.attempts || 1,
+      blocked: result?.blocked === true,
+      failureDiagnostic: result?.failureDiagnostic || null,
+      artifacts,
+    },
+    artifactRoot: result?.artifactRoot || null,
+    artifacts,
+    artifactPaths: artifacts.map((artifact) => artifact.path).filter(Boolean),
+    artifactRetrieveCommands: artifacts
+      .map((artifact) => artifact.retrieveCommand)
+      .filter(Boolean),
+  };
+}
+
+function resolveWorkflowCommandLane({ nodeType, commandType, command, engine }) {
+  const scheduler = engine?.services?.scheduler;
+  if (scheduler && typeof scheduler.selectWorkflowLane === "function") {
+    return scheduler.selectWorkflowLane({ nodeType, commandType, command });
+  }
+
+  const normalizedNodeType = String(nodeType || "").trim();
+  if (['validation.tests', 'validation.build', 'validation.lint'].includes(normalizedNodeType)) {
+    return { lane: "isolated", reason: `workflow_node:${normalizedNodeType}`, heavy: true };
+  }
+
+  const normalizedCommandType = String(commandType || "").trim();
+  if (["test", "build", "qualityGate"].includes(normalizedCommandType)) {
+    return { lane: "isolated", reason: `command_type:${normalizedCommandType}`, heavy: true };
+  }
+
+  const rawCommand = String(command || "");
+  if (/(?:\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b|\b(?:npm|pnpm|yarn|bun)\s+run\s+build\b|\b(?:npm|pnpm|yarn|bun)\s+run\s+lint\b|\bpre-?push\b|\bgit\s+diff\b|\bvitest\b|\bjest\b|\btsc\b)/i.test(rawCommand)) {
+    return { lane: "isolated", reason: "command_pattern:default", heavy: true };
+  }
+
+  return { lane: "main", reason: "lightweight", heavy: false };
+}
+
+async function maybeRunWorkflowCommandInIsolation({
+  node,
+  ctx,
+  engine,
+  nodeType,
+  command,
+  args = [],
+  cwd,
+  timeoutMs,
+  env = {},
+  commandType = "",
+  sessionType = "flow",
+} = {}) {
+  const lane = resolveWorkflowCommandLane({ nodeType, commandType, command, engine });
+  if (lane?.lane !== "isolated") return null;
+
+  ctx.log(node.id, `Offloading ${commandType || nodeType} to isolated runner (${lane.reason})`);
+  const runner = engine?.services?.isolatedRunner;
+  const execute = typeof runner?.run === "function" ? runner.run.bind(runner) : runInIsolatedRunner;
+  const isolated = await execute({
+    command,
+    args,
+    cwd,
+    timeoutMs,
+    env,
+    requestType: commandType || nodeType,
+    taskId: `${node.id || nodeType || "validation"}`,
+    metadata: {
+      nodeId: node.id || null,
+      nodeType,
+      commandType,
+    },
+  });
+  const compacted = await compactWorkflowCommandResult({
+    command,
+    args,
+    output: isolated?.stdout || "",
+    stderr: isolated?.stderr || isolated?.error || "",
+    exitCode: isolated?.exitCode,
+    durationMs: isolated?.duration,
+    sessionType,
+  });
+
+  return {
+    lane,
+    isolated,
+    compacted,
+    extras: buildIsolatedRunnerResultExtras(isolated, lane),
+  };
+}
+
 function resolveWorkflowNodeValue(value, ctx) {
   if (typeof value === "string") {
     const resolved = ctx.resolve(value);
@@ -1872,7 +2075,7 @@ registerBuiltinNodeType("trigger.manual", {
     type: "object",
     properties: {},
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     ctx.log(node.id, "Manual trigger fired");
     return { triggered: true, reason: "manual" };
   },
@@ -1892,7 +2095,7 @@ registerBuiltinNodeType("trigger.task_low", {
       countDraftTasks: { type: "boolean", default: false, description: "Also count draft tasks toward threshold" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const threshold = node.config?.threshold ?? 3;
     const status = node.config?.status ?? "todo";
     const countDrafts = node.config?.countDraftTasks === true;
@@ -1953,7 +2156,7 @@ registerBuiltinNodeType("trigger.schedule", {
       cron: { type: "string", description: "Cron expression (future support)" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const interval = node.config?.intervalMs ?? 3600000;
     const lastRun = ctx.data?._lastRunAt ?? 0;
     const elapsed = Date.now() - lastRun;
@@ -1972,7 +2175,7 @@ registerBuiltinNodeType("trigger.event", {
       filter: { type: "string", description: "Optional filter expression" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const expected = node.config?.eventType;
     const actual = ctx.data?.eventType || ctx.eventType;
     const triggered = expected === actual;
@@ -2018,7 +2221,7 @@ registerBuiltinNodeType("trigger.meeting.wake_phrase", {
       },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const eventData = ctx.data && typeof ctx.data === "object" ? ctx.data : {};
     const resolveValue = (value) => (
       typeof ctx?.resolve === "function" ? ctx.resolve(value) : value
@@ -2156,7 +2359,7 @@ registerBuiltinNodeType("trigger.webhook", {
       method: { type: "string", default: "POST", enum: ["GET", "POST"] },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     return { triggered: true, payload: ctx.data?.webhookPayload || {} };
   },
 });
@@ -2175,7 +2378,7 @@ registerBuiltinNodeType("trigger.pr_event", {
       branchPattern: { type: "string", description: "Branch name regex filter" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const expectedEvents = [
       node.config?.event,
       ...(Array.isArray(node.config?.events) ? node.config.events : []),
@@ -2208,7 +2411,7 @@ registerBuiltinNodeType("trigger.task_assigned", {
       filter: { type: "string", description: "JS expression filter (e.g., \"task.tags?.includes('backend')\")" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const triggered = evaluateTaskAssignedTriggerConfig(node.config, ctx.data);
     return { triggered, task: ctx.data };
   },
@@ -2224,7 +2427,7 @@ registerBuiltinNodeType("trigger.anomaly", {
       agentFilter: { type: "string", description: "Regex to match agent ID or name" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const expected = node.config?.anomalyType;
     const actual = ctx.data?.anomalyType || ctx.data?.type;
     const typeMatch = !expected || expected === actual;
@@ -2264,7 +2467,7 @@ registerBuiltinNodeType("trigger.scheduled_once", {
     },
     required: ["runAt"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const rawRunAt = ctx.resolve(node.config?.runAt || "");
     let runAtMs;
 
@@ -2315,7 +2518,7 @@ registerBuiltinNodeType("trigger.workflow_call", {
       },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     // Validate required inputs from _triggerVars or context data
     const inputDefs = node.config?.inputs || {};
     const callerVars = ctx.data?._triggerVars || ctx.data || {};
@@ -2365,7 +2568,7 @@ registerBuiltinNodeType("condition.expression", {
     },
     required: ["expression"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const expr = node.config?.expression;
     if (!expr) throw new Error("Expression is required");
     try {
@@ -2391,7 +2594,7 @@ registerBuiltinNodeType("condition.task_has_tag", {
     },
     required: ["tag"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const tag = node.config?.tag?.toLowerCase();
     const field = node.config?.field || "tags";
     let haystack = ctx.data?.task?.[field] || ctx.data?.[field] || "";
@@ -2412,7 +2615,7 @@ registerBuiltinNodeType("condition.file_exists", {
     },
     required: ["path"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const filePath = ctx.resolve(node.config?.path || "");
     const exists = existsSync(filePath);
     ctx.log(node.id, `File check: "${filePath}" → ${exists}`);
@@ -2436,7 +2639,7 @@ registerBuiltinNodeType("condition.switch", {
     },
     required: [],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     let value;
     const expr = node.config?.value || node.config?.expression || "";
     if (expr) {
@@ -2615,10 +2818,12 @@ registerBuiltinNodeType("action.run_agent", {
       );
     }
     let finalPrompt = prompt;
+    const promptHasRepoMapContext = hasRepoMapContext(finalPrompt);
     const architectEditorFrame = buildArchitectEditorFrame({
       executionRole: ctx.resolve(node.config?.executionRole || ""),
       architectPlan,
       planSummary: architectPlan,
+      includeRepoMap: !promptHasRepoMapContext,
       repoMap: node.config?.repoMap || ctx.data?.repoMap || null,
       repoMapFileLimit: node.config?.repoMapFileLimit,
       repoMapQuery: ctx.resolve(node.config?.repoMapQuery || ""),
@@ -3343,7 +3548,7 @@ registerBuiltinNodeType("action.run_command", {
     },
     required: ["command"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const resolvedCommand = ctx.resolve(node.config?.command || "");
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
     const commandType = typeof node.config?.commandType === "string" ? node.config.commandType.trim() : "";
@@ -3409,7 +3614,43 @@ registerBuiltinNodeType("action.run_command", {
     if (command !== autoResolvedCommand) {
       ctx.log(node.id, `Normalized legacy command for portability: ${command}`);
     }
-    ctx.log(node.id, `Running: ${usedArgv ? `${command} ${commandArgs.join(" ")}`.trim() : command}`);
+    const displayCommand = usedArgv ? `${command} ${commandArgs.join(" ")}`.trim() : command;
+    ctx.log(node.id, `Running: ${displayCommand}`);
+    const isolatedRun = await maybeRunWorkflowCommandInIsolation({
+      node,
+      ctx,
+      engine,
+      nodeType: "action.run_command",
+      command,
+      args: commandArgs,
+      cwd,
+      timeoutMs: timeout,
+      env: commandEnv,
+      commandType,
+    });
+    if (isolatedRun) {
+      if (shouldParseJson) {
+        const parsedOutput = parseOutput(isolatedRun.isolated?.stdout || isolatedRun.compacted.output || "");
+        return {
+          success: isolatedRun.isolated?.blocked !== true && Number(isolatedRun.isolated?.exitCode ?? 0) === 0,
+          exitCode: isolatedRun.isolated?.exitCode ?? null,
+          output: parsedOutput,
+          ...isolatedRun.extras,
+        };
+      }
+      const result = {
+        success: isolatedRun.isolated?.blocked !== true && Number(isolatedRun.isolated?.exitCode ?? 0) === 0,
+        exitCode: isolatedRun.isolated?.exitCode ?? null,
+        blocked: isolatedRun.isolated?.blocked === true,
+        error: isolatedRun.isolated?.error || null,
+        ...isolatedRun.compacted,
+        ...isolatedRun.extras,
+      };
+      if (node.config?.failOnError && !result.success) {
+        throw new Error(trimLogText(result.output || result.error || "command failed", 400));
+      }
+      return result;
+    }
     const startedAt = Date.now();
     try {
       const output = usedArgv
@@ -4594,7 +4835,7 @@ registerBuiltinNodeType("action.git_operations", {
     },
     required: [],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
     const resolveOpCommand = (opConfig = {}) => {
       const op = String(opConfig.op || opConfig.operation || "").trim();
@@ -4736,7 +4977,7 @@ registerBuiltinNodeType("action.create_pr", {
     },
     required: ["title"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const title = ctx.resolve(node.config?.title || "");
     const body = ctx.resolve(node.config?.body || "");
     const baseInput = ctx.resolve(node.config?.base || node.config?.baseBranch || "main");
@@ -5079,7 +5320,7 @@ registerBuiltinNodeType("action.write_file", {
     },
     required: ["path", "content"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const filePath = ctx.resolve(node.config?.path || "");
     const content = ctx.resolve(node.config?.content || "");
     if (node.config?.mkdir) {
@@ -5105,7 +5346,7 @@ registerBuiltinNodeType("action.read_file", {
     },
     required: ["path"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const filePath = ctx.resolve(node.config?.path || "");
     if (!existsSync(filePath)) {
       return { success: false, error: `File not found: ${filePath}` };
@@ -5126,7 +5367,7 @@ registerBuiltinNodeType("action.set_variable", {
     },
     required: ["key"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const key = node.config?.key;
     let value = node.config?.value || "";
     if (node.config?.isExpression) {
@@ -5161,7 +5402,7 @@ registerBuiltinNodeType("action.delay", {
       message: { type: "string", description: "Legacy alias for reason" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const baseMs = Number(
       node.config?.ms ??
       node.config?.delayMs ??
@@ -5218,7 +5459,7 @@ registerBuiltinNodeType("validation.screenshot", {
     },
     required: ["url"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const url = ctx.resolve(node.config?.url || "http://localhost:3000");
     const outDir = ctx.resolve(node.config?.outputDir || ".bosun/evidence");
     const filename = ctx.resolve(node.config?.filename || `screenshot-${Date.now()}.png`);
@@ -5441,12 +5682,42 @@ registerBuiltinNodeType("validation.tests", {
       requiredPassRate: { type: "number", default: 1.0, description: "Minimum pass rate (0-1)" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const command = ctx.resolve(node.config?.command || "npm test");
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
     const timeout = node.config?.timeoutMs || 600000;
 
     ctx.log(node.id, `Running tests: ${command}`);
+    const isolatedRun = await maybeRunWorkflowCommandInIsolation({
+      node,
+      ctx,
+      engine,
+      nodeType: "validation.tests",
+      command,
+      cwd,
+      timeoutMs: timeout,
+      commandType: "test",
+    });
+    if (isolatedRun) {
+      const failureDiagnostic = buildValidationFailureDiagnostic({
+        command,
+        status: isolatedRun.isolated?.status,
+        exitCode: isolatedRun.isolated?.exitCode,
+        stderr: isolatedRun.isolated?.stderr || isolatedRun.isolated?.error || "",
+        output: isolatedRun.isolated?.stdout || "",
+        timeoutMs: timeout,
+        blocked: isolatedRun.isolated?.blocked === true,
+        failureDiagnostic: isolatedRun.isolated?.failureDiagnostic,
+      });
+      return buildValidationResult({
+        passed: didValidationCommandPass({ ...isolatedRun.isolated, failureDiagnostic }),
+        exitCode: isolatedRun.isolated?.exitCode ?? null,
+        blocked: isolatedRun.isolated?.blocked === true,
+        compacted: isolatedRun.compacted,
+        extras: isolatedRun.extras,
+        failureDiagnostic,
+      });
+    }
     const startedAt = Date.now();
     try {
       const output = execSync(command, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
@@ -5467,7 +5738,20 @@ registerBuiltinNodeType("validation.tests", {
         exitCode: err.status,
         durationMs: Date.now() - startedAt,
       });
-      return { passed: false, exitCode: err.status, ...compacted };
+      const failureDiagnostic = buildValidationFailureDiagnostic({
+        command,
+        status: /(?:timed out|ETIMEDOUT|SIGTERM)/i.test(String(err?.message || "")) ? "timeout" : "error",
+        exitCode: err.status,
+        stderr: err.stderr?.toString() || err.message,
+        output,
+        timeoutMs: timeout,
+      });
+      return buildValidationResult({
+        passed: false,
+        exitCode: err.status,
+        compacted,
+        failureDiagnostic,
+      });
     }
   },
 });
@@ -5483,7 +5767,7 @@ registerBuiltinNodeType("validation.build", {
       zeroWarnings: { type: "boolean", default: false, description: "Fail on warnings too" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const resolvedCommand = ctx.resolve(node.config?.command || "npm run build");
     const command = normalizeLegacyWorkflowCommand(resolvedCommand);
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
@@ -5493,6 +5777,48 @@ registerBuiltinNodeType("validation.build", {
       ctx.log(node.id, `Normalized legacy command for portability: ${command}`);
     }
     ctx.log(node.id, `Building: ${command}`);
+    const isolatedRun = await maybeRunWorkflowCommandInIsolation({
+      node,
+      ctx,
+      engine,
+      nodeType: "validation.build",
+      command,
+      cwd,
+      timeoutMs: timeout,
+      commandType: "build",
+    });
+    if (isolatedRun) {
+      const combinedOutput = `${isolatedRun.isolated?.stdout || ""}\n${isolatedRun.isolated?.stderr || ""}`;
+      const hasWarnings = /warning/i.test(combinedOutput);
+      if (node.config?.zeroWarnings && hasWarnings) {
+        return {
+          passed: false,
+          reason: "warnings_found",
+          exitCode: isolatedRun.isolated?.exitCode ?? 0,
+          blocked: isolatedRun.isolated?.blocked === true,
+          ...isolatedRun.compacted,
+          ...isolatedRun.extras,
+        };
+      }
+      const failureDiagnostic = buildValidationFailureDiagnostic({
+        command,
+        status: isolatedRun.isolated?.status,
+        exitCode: isolatedRun.isolated?.exitCode,
+        stderr: isolatedRun.isolated?.stderr || isolatedRun.isolated?.error || "",
+        output: isolatedRun.isolated?.stdout || "",
+        timeoutMs: timeout,
+        blocked: isolatedRun.isolated?.blocked === true,
+        failureDiagnostic: isolatedRun.isolated?.failureDiagnostic,
+      });
+      return buildValidationResult({
+        passed: didValidationCommandPass({ ...isolatedRun.isolated, failureDiagnostic }),
+        exitCode: isolatedRun.isolated?.exitCode ?? null,
+        blocked: isolatedRun.isolated?.blocked === true,
+        compacted: isolatedRun.compacted,
+        extras: isolatedRun.extras,
+        failureDiagnostic,
+      });
+    }
     const startedAt = Date.now();
     try {
       const output = execSync(command, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
@@ -5515,7 +5841,20 @@ registerBuiltinNodeType("validation.build", {
         exitCode: err.status,
         durationMs: Date.now() - startedAt,
       });
-      return { passed: false, exitCode: err.status, ...compacted };
+      const failureDiagnostic = buildValidationFailureDiagnostic({
+        command,
+        status: /(?:timed out|ETIMEDOUT|SIGTERM)/i.test(String(err?.message || "")) ? "timeout" : "error",
+        exitCode: err.status,
+        stderr: err.stderr?.toString() || err.message,
+        output: err.stdout?.toString() || "",
+        timeoutMs: timeout,
+      });
+      return buildValidationResult({
+        passed: false,
+        exitCode: err.status,
+        compacted,
+        failureDiagnostic,
+      });
     }
   },
 });
@@ -5530,15 +5869,46 @@ registerBuiltinNodeType("validation.lint", {
       timeoutMs: { type: "number", default: 120000 },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const command = ctx.resolve(node.config?.command || "npm run lint");
     if (!command || !command.trim()) {
       return { passed: true, output: "no lint configured", skipped: true };
     }
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
+    const timeout = node.config?.timeoutMs || 120000;
+    const isolatedRun = await maybeRunWorkflowCommandInIsolation({
+      node,
+      ctx,
+      engine,
+      nodeType: "validation.lint",
+      command,
+      cwd,
+      timeoutMs: timeout,
+      commandType: "qualityGate",
+    });
+    if (isolatedRun) {
+      const failureDiagnostic = buildValidationFailureDiagnostic({
+        command,
+        status: isolatedRun.isolated?.status,
+        exitCode: isolatedRun.isolated?.exitCode,
+        stderr: isolatedRun.isolated?.stderr || isolatedRun.isolated?.error || "",
+        output: isolatedRun.isolated?.stdout || "",
+        timeoutMs: timeout,
+        blocked: isolatedRun.isolated?.blocked === true,
+        failureDiagnostic: isolatedRun.isolated?.failureDiagnostic,
+      });
+      return buildValidationResult({
+        passed: didValidationCommandPass({ ...isolatedRun.isolated, failureDiagnostic }),
+        exitCode: isolatedRun.isolated?.exitCode ?? null,
+        blocked: isolatedRun.isolated?.blocked === true,
+        compacted: isolatedRun.compacted,
+        extras: isolatedRun.extras,
+        failureDiagnostic,
+      });
+    }
     const startedAt = Date.now();
     try {
-      const output = execSync(command, { cwd, timeout: node.config?.timeoutMs || 120000, encoding: "utf8", stdio: "pipe" });
+      const output = execSync(command, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
       const compacted = await compactWorkflowCommandResult({
         command,
         output: output?.trim() || "",
@@ -5554,7 +5924,20 @@ registerBuiltinNodeType("validation.lint", {
         exitCode: err.status,
         durationMs: Date.now() - startedAt,
       });
-      return { passed: false, ...compacted };
+      const failureDiagnostic = buildValidationFailureDiagnostic({
+        command,
+        status: /(?:timed out|ETIMEDOUT|SIGTERM)/i.test(String(err?.message || "")) ? "timeout" : "error",
+        exitCode: err.status,
+        stderr: err.stderr?.toString() || err.message,
+        output: err.stdout?.toString() || "",
+        timeoutMs: timeout,
+      });
+      return buildValidationResult({
+        passed: false,
+        exitCode: err.status,
+        compacted,
+        failureDiagnostic,
+      });
     }
   },
 });
@@ -5572,7 +5955,7 @@ registerBuiltinNodeType("transform.json_parse", {
       field: { type: "string", description: "Field in source output containing JSON" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const sourceId = node.config?.input;
     const field = node.config?.field || "output";
     let raw = sourceId ? ctx.getNodeOutput(sourceId)?.[field] : ctx.resolve(node.config?.value || "");
@@ -5594,7 +5977,7 @@ registerBuiltinNodeType("transform.template", {
     },
     required: ["template"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const result = ctx.resolve(node.config?.template || "");
     return { text: result };
   },
@@ -5608,7 +5991,7 @@ registerBuiltinNodeType("transform.aggregate", {
       sources: { type: "array", items: { type: "string" }, description: "Node IDs to aggregate" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const sources = node.config?.sources || [];
     const aggregated = {};
     for (const src of sources) {
@@ -5662,7 +6045,7 @@ registerBuiltinNodeType("transform.llm_parse", {
     },
     required: [],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     // Resolve the input text
     let text = "";
     const inputRef = ctx.resolve(node.config?.input || "");
@@ -5739,7 +6122,7 @@ registerBuiltinNodeType("notify.log", {
     },
     required: ["message"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const message = ctx.resolve(node.config?.message || "");
     const level = node.config?.level || "info";
     ctx.log(node.id, message, level);
@@ -5793,7 +6176,7 @@ registerBuiltinNodeType("notify.webhook_out", {
     },
     required: ["url"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const url = ctx.resolve(node.config?.url || "");
     const method = node.config?.method || "POST";
     const body = node.config?.body ? JSON.stringify(node.config.body) : undefined;
@@ -5954,7 +6337,7 @@ registerBuiltinNodeType("agent.select_profile", {
       default: { type: "string", default: "general", description: "Default profile if no match" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const profiles = node.config?.profiles || {};
     const taskTitle = (ctx.data?.taskTitle || "").toLowerCase();
     const taskTags = (ctx.data?.taskTags || []).map((t) => t.toLowerCase());
@@ -7169,6 +7552,9 @@ registerBuiltinNodeType("agent.run_planner", {
       context: { type: "string", description: "Additional context for the planner" },
       prompt: { type: "string", description: "Optional explicit planner prompt override" },
       outputVariable: { type: "string", description: "Optional context key to store planner output text" },
+      repoMap: { type: "object", description: "Optional explicit repo map context" },
+      repoMapQuery: { type: "string", description: "Optional query used to select a compact repo topology" },
+      repoMapFileLimit: { type: "number", default: 8, description: "Maximum repo-map files to include" },
       projectId: { type: "string" },
       dedup: { type: "boolean", default: true },
       timeoutMs: { type: "number", default: 960000, description: "Node timeout in ms (recommended >= agentTimeoutMs)" },
@@ -7184,6 +7570,7 @@ registerBuiltinNodeType("agent.run_planner", {
     const plannerFeedback = resolvePlannerFeedbackContext(ctx.data?._plannerFeedback);
     const explicitPrompt = ctx.resolve(node.config?.prompt || "");
     const outputVariable = ctx.resolve(node.config?.outputVariable || "");
+    const repoMapQuery = ctx.resolve(node.config?.repoMapQuery || "");
     const configuredNodeTimeout = Number(ctx.resolve(node.config?.timeoutMs || node.config?.timeout || 0));
     const configuredAgentTimeout = Number(ctx.resolve(node.config?.agentTimeoutMs || 0));
 
@@ -7199,20 +7586,51 @@ registerBuiltinNodeType("agent.run_planner", {
     // This delegates to the existing planner prompt flow
     const agentPool = engine.services?.agentPool;
     const plannerPrompt = engine.services?.prompts?.planner;
+    const basePrompt = explicitPrompt || plannerPrompt || "";
+    const fullPromptForRepoMapCheck = [basePrompt, context, plannerFeedback].filter(Boolean).join("\n\n");
+    const promptHasRepoMap = hasRepoMapContext(fullPromptForRepoMapCheck);
+    const repoTopologyContext = (node.config?.repoMap || repoMapQuery)
+      && !promptHasRepoMap
+      ? buildRepoTopologyContext({
+        repoMap: node.config?.repoMap || ctx.data?.repoMap || null,
+        repoMapFileLimit: node.config?.repoMapFileLimit ?? 8,
+        repoMapQuery,
+        query: [context, explicitPrompt, plannerPrompt].filter(Boolean).join(" "),
+        prompt: explicitPrompt || plannerPrompt || "",
+        userMessage: context,
+        taskTitle: ctx.data?.taskTitle || ctx.data?.task?.title || "",
+        taskDescription:
+          ctx.data?.taskDescription ||
+          ctx.data?.task?.description ||
+          ctx.data?.task?.body ||
+          ctx.data?.taskDetail?.description ||
+          ctx.data?.taskInfo?.description ||
+          "",
+        changedFiles:
+          (Array.isArray(ctx.data?.changedFiles) ? ctx.data.changedFiles : null) ||
+          (Array.isArray(ctx.data?.task?.changedFiles) ? ctx.data.task.changedFiles : null) ||
+          [],
+        cwd: process.cwd(),
+        repoRoot: ctx.data?.repoRoot || process.cwd(),
+      })
+      : "";
     // Enforce strict output instructions to ensure the downstream materialize node
     // can parse the planner output. The planner prompt already defines the contract,
     // but we reinforce it here to prevent agents from wrapping output in prose.
     const outputEnforcement =
       `\n\n## CRITICAL OUTPUT REQUIREMENT\n` +
       `Generate exactly ${count} new tasks.\n` +
-      ((context || plannerFeedback)
-        ? `${[context, plannerFeedback ? `Planner feedback context:\n${plannerFeedback}` : ""].filter(Boolean).join("\n\n")}\n\n`
+      ((context || plannerFeedback || repoTopologyContext)
+        ? `${[
+          context,
+          plannerFeedback ? `Planner feedback context:\n${plannerFeedback}` : "",
+          repoTopologyContext,
+        ].filter(Boolean).join("\n\n")}\n\n`
         : "\n") +
       `Your response MUST be a single fenced JSON block with shape { "tasks": [...] }.\n` +
       `Do NOT include status updates, analysis notes, tool commentary, questions, or prose outside the JSON block.\n` +
       `Do NOT reference or use legacy ve-kanban integration commands or scripts.\n` +
       `The downstream system will parse your output as JSON — any extra text will cause task creation to fail.`;
-    const basePrompt = explicitPrompt || plannerPrompt || "";
     const promptText = basePrompt
       ? `${basePrompt}${outputEnforcement}`
       : "";
@@ -7312,7 +7730,7 @@ registerBuiltinNodeType("agent.evidence_collect", {
       types: { type: "array", items: { type: "string" }, default: ["png", "jpg", "json", "log", "txt"] },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const dir = ctx.resolve(node.config?.evidenceDir || ".bosun/evidence");
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
@@ -7443,7 +7861,7 @@ registerBuiltinNodeType("flow.join", {
       },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const mode = String(ctx.resolve(node.config?.mode || "all") || "all").toLowerCase();
     const includeSkipped = parseBooleanSetting(
       resolveWorkflowNodeValue(node.config?.includeSkipped ?? true, ctx),
@@ -7526,7 +7944,7 @@ registerBuiltinNodeType("flow.end", {
       },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const rawStatus = String(ctx.resolve(node.config?.status || "completed") || "completed")
       .trim()
       .toLowerCase();
@@ -7620,6 +8038,54 @@ const UNIVERSAL_FLOW_NODE = {
       ...configuredInput,
     }, workflowId);
     const childRunOpts = makeChildWorkflowExecuteOptions(ctx, { childWorkflowId: workflowId });
+    const trackedTaskId = String(
+      ctx.data?.taskId ||
+      ctx.data?.task?.id ||
+      ctx.data?.taskDetail?.id ||
+      ctx.data?.taskInfo?.id ||
+      "",
+    ).trim();
+    const trackedTaskTitle = String(
+      ctx.data?.taskTitle ||
+      ctx.data?.task?.title ||
+      ctx.data?.taskDetail?.title ||
+      ctx.data?.taskInfo?.title ||
+      trackedTaskId,
+    ).trim();
+    const tracker = trackedTaskId ? getSessionTracker() : null;
+    if (tracker && trackedTaskId) {
+      const existing = tracker.getSessionById(trackedTaskId);
+      if (!existing) {
+        tracker.createSession({
+          id: trackedTaskId,
+          type: "task",
+          taskId: trackedTaskId,
+          metadata: {
+            title: trackedTaskTitle || trackedTaskId,
+            workspaceId: String(ctx.data?.workspaceId || ctx.data?.activeWorkspace || "").trim() || undefined,
+            workspaceDir: String(ctx.data?.worktreePath || ctx.data?.workspaceDir || "").trim() || undefined,
+            branch:
+              String(
+                ctx.data?.branch ||
+                ctx.data?.task?.branchName ||
+                ctx.data?.taskDetail?.branchName ||
+                ctx.data?.taskInfo?.branchName ||
+                "",
+              ).trim() || undefined,
+          },
+        });
+      } else {
+        tracker.updateSessionStatus(trackedTaskId, "active");
+        if (trackedTaskTitle) tracker.renameSession(trackedTaskId, trackedTaskTitle);
+      }
+      tracker.recordEvent(trackedTaskId, {
+        role: "system",
+        type: "system",
+        content: `Delegating to workflow "${workflowId}"`,
+        timestamp: new Date().toISOString(),
+        _sessionType: "task",
+      });
+    }
 
     if (mode === "dispatch") {
       ctx.log(node.id, `Dispatching universal workflow \"${workflowId}\"`);
@@ -7632,9 +8098,29 @@ const UNIVERSAL_FLOW_NODE = {
       dispatched
         .then((childCtx) => {
           const status = childCtx?.errors?.length ? "failed" : "completed";
+          if (tracker && trackedTaskId) {
+            tracker.updateSessionStatus(trackedTaskId, status);
+            tracker.recordEvent(trackedTaskId, {
+              role: status === "completed" ? "assistant" : "system",
+              type: status === "completed" ? "agent_message" : "error",
+              content: `Workflow "${workflowId}" ${status}`,
+              timestamp: new Date().toISOString(),
+              _sessionType: "task",
+            });
+          }
           ctx.log(node.id, `Dispatched universal workflow \"${workflowId}\" finished with status=${status}`);
         })
         .catch((err) => {
+          if (tracker && trackedTaskId) {
+            tracker.updateSessionStatus(trackedTaskId, "failed");
+            tracker.recordEvent(trackedTaskId, {
+              role: "system",
+              type: "error",
+              content: `Workflow "${workflowId}" failed: ${err.message}`,
+              timestamp: new Date().toISOString(),
+              _sessionType: "task",
+            });
+          }
           ctx.log(node.id, `Dispatched universal workflow \"${workflowId}\" failed: ${err.message}`, "error");
         });
 
@@ -7659,8 +8145,20 @@ const UNIVERSAL_FLOW_NODE = {
       workflowId,
       runId: childCtx?.id || null,
       status: errorCount > 0 ? "failed" : "completed",
+      message: String(childCtx?.data?._workflowTerminalMessage || "").trim(),
+      output: childCtx?.data?._workflowTerminalOutput,
       errorCount,
     };
+    if (tracker && trackedTaskId) {
+      tracker.updateSessionStatus(trackedTaskId, output.status);
+      tracker.recordEvent(trackedTaskId, {
+        role: output.status === "completed" ? "assistant" : "system",
+        type: output.status === "completed" ? "agent_message" : "error",
+        content: `Workflow "${workflowId}" ${output.status}${output.message ? `: ${output.message}` : ""}`,
+        timestamp: new Date().toISOString(),
+        _sessionType: "task",
+      });
+    }
     if (outputVariable) ctx.data[outputVariable] = output;
     return output;
   },
@@ -7975,12 +8473,30 @@ registerBuiltinNodeType("action.continue_session", {
     const prompt = ctx.resolve(node.config?.prompt || "Continue working on the current task.");
     const timeout = node.config?.timeoutMs || 1800000;
     const strategy = node.config?.strategy || "continue";
+    const issueAdvisor =
+      ctx.data?._issueAdvisor && typeof ctx.data._issueAdvisor === "object"
+        ? ctx.data._issueAdvisor
+        : null;
+    const dagStateSummary =
+      ctx.data?._plannerFeedback?.dagStateSummary && typeof ctx.data._plannerFeedback.dagStateSummary === "object"
+        ? ctx.data._plannerFeedback.dagStateSummary
+        : null;
+    const continuationPrefix = issueAdvisor
+      ? [
+        "Issue-advisor continuation context:",
+        `- Recommendation: ${issueAdvisor.recommendedAction || "continue"}`,
+        issueAdvisor.summary ? `- Summary: ${issueAdvisor.summary}` : null,
+        issueAdvisor.nextStepGuidance ? `- Guidance: ${issueAdvisor.nextStepGuidance}` : null,
+        dagStateSummary?.counts ? `- DAG counts: completed=${Number(dagStateSummary.counts.completed ?? 0) || 0}, failed=${Number(dagStateSummary.counts.failed ?? 0) || 0}, pending=${Number(dagStateSummary.counts.pending ?? 0) || 0}` : null,
+      ].filter(Boolean).join("\n") + "\n\n"
+      : "";
+    const enrichedPrompt = continuationPrefix ? `${continuationPrefix}${prompt}` : prompt;
 
     ctx.log(node.id, `Continuing session ${sessionId} (strategy: ${strategy})`);
 
     const agentPool = engine.services?.agentPool;
     if (agentPool?.continueSession) {
-      const result = await agentPool.continueSession(sessionId, prompt, { timeout, strategy });
+      const result = await agentPool.continueSession(sessionId, enrichedPrompt, { timeout, strategy });
 
       // Propagate session ID for downstream chaining
       const threadId = result.threadId || sessionId;
@@ -7993,12 +8509,12 @@ registerBuiltinNodeType("action.continue_session", {
     // Fallback: use ephemeral thread with continuation context
     if (agentPool?.launchEphemeralThread) {
       const continuation = strategy === "retry"
-        ? `Start over on this task. Previous attempt failed.\n\n${prompt}`
+        ? `Start over on this task. Previous attempt failed.\n\n${enrichedPrompt}`
         : strategy === "refine"
-        ? `Refine your previous work. Specifically:\n\n${prompt}`
+        ? `Refine your previous work. Specifically:\n\n${enrichedPrompt}`
         : strategy === "finish_up"
-        ? `Wrap up the current task. Commit, push, and hand off PR lifecycle to Bosun. Ensure tests pass.\n\n${prompt}`
-        : `Continue where you left off.\n\n${prompt}`;
+        ? `Wrap up the current task. Commit, push, and hand off PR lifecycle to Bosun. Ensure tests pass.\n\n${enrichedPrompt}`
+        : `Continue where you left off.\n\n${enrichedPrompt}`;
 
       const result = await agentPool.launchEphemeralThread(continuation, ctx.data?.worktreePath || process.cwd(), timeout);
 
@@ -8089,7 +8605,7 @@ registerBuiltinNodeType("action.bosun_cli", {
     },
     required: ["subcommand"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const sub = node.config?.subcommand || "";
     const args = ctx.resolve(node.config?.args || "");
     const cmd = `bosun ${sub} ${args}`.trim();
@@ -8218,7 +8734,7 @@ registerBuiltinNodeType("action.bosun_tool", {
     },
     required: ["toolId"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const toolId = ctx.resolve(node.config?.toolId || "");
     if (!toolId) throw new Error("action.bosun_tool: 'toolId' is required");
 
@@ -8915,7 +9431,7 @@ registerBuiltinNodeType("action.handle_rate_limit", {
       strategy: { type: "string", enum: ["wait", "rotate", "skip"], default: "wait", description: "Rate limit strategy" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const attempt = ctx.data?._rateLimitAttempt || 0;
     const maxRetries = node.config?.maxRetries || 5;
     const strategy = node.config?.strategy || "wait";
@@ -9068,7 +9584,7 @@ registerBuiltinNodeType("action.refresh_worktree", {
     },
     required: ["operation"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const op = node.config?.operation || "fetch";
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
     const branch = ctx.resolve(node.config?.branch || "main");
@@ -9423,7 +9939,7 @@ registerBuiltinNodeType("action.mcp_tool_call", {
     },
     required: ["server", "tool"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const serverId = ctx.resolve(node.config?.server || "");
     const toolName = ctx.resolve(node.config?.tool || "");
     const timeoutMs = node.config?.timeoutMs || 30000;
@@ -9518,7 +10034,7 @@ registerBuiltinNodeType("action.mcp_list_tools", {
     },
     required: ["server"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const serverId = ctx.resolve(node.config?.server || "");
     const timeoutMs = node.config?.timeoutMs || 30000;
 
@@ -9645,7 +10161,7 @@ registerBuiltinNodeType("action.mcp_pipeline", {
     },
     required: ["steps"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const adapter = await getMcpAdapter();
     const pipelineSpec = adapter.createPipelineSpec(node.config?.steps || []);
 
@@ -9850,7 +10366,7 @@ registerBuiltinNodeType("transform.mcp_extract", {
     },
     required: ["source", "fields"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const sourceNodeId = ctx.resolve(node.config?.source || "");
     const sourceField = node.config?.sourceField || "data";
 
@@ -10942,6 +11458,8 @@ registerBuiltinNodeType("trigger.task_available", {
     return {
       triggered: true,
       tasks: toDispatch,
+      task: primaryTask,
+      taskTitle: primaryTask ? pickTaskString(primaryTask.title, primaryTask.task_title) : "",
       taskCount: toDispatch.length,
       availableSlots: remaining,
       selectedTaskId: primaryTask ? pickTaskString(primaryTask.id, primaryTask.task_id) : "",
@@ -10964,7 +11482,7 @@ registerBuiltinNodeType("condition.slot_available", {
       baseBranch: { type: "string", description: "Base branch to check against" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const maxParallel = node.config?.maxParallel ?? 3;
     const baseBranchLimit = node.config?.baseBranchLimit ?? 0;
     const activeSlotCount = ctx.data?.activeSlotCount ?? 0;
@@ -11002,7 +11520,7 @@ registerBuiltinNodeType("action.allocate_slot", {
     },
     required: ["taskId"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const taskId = cfgOrCtx(node, ctx, "taskId");
     const taskTitle = cfgOrCtx(node, ctx, "taskTitle", "(untitled)");
     const branch = cfgOrCtx(node, ctx, "branch");
@@ -11056,7 +11574,7 @@ registerBuiltinNodeType("action.release_slot", {
       taskId: { type: "string", description: "Task ID whose slot to release" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const taskId = cfgOrCtx(node, ctx, "taskId");
     const slot = ctx.data?._allocatedSlot;
 
@@ -11100,7 +11618,7 @@ registerBuiltinNodeType("action.claim_task", {
     },
     required: ["taskId"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const taskId = cfgOrCtx(node, ctx, "taskId");
     const taskTitle = cfgOrCtx(node, ctx, "taskTitle");
     const ttlMinutes = node.config?.ttlMinutes ?? 180;
@@ -11222,7 +11740,7 @@ registerBuiltinNodeType("action.release_claim", {
       instanceId: { type: "string", description: "Instance ID (auto-read from ctx)" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const taskId = cfgOrCtx(node, ctx, "taskId");
     const claimToken = cfgOrCtx(node, ctx, "claimToken") || ctx.data?._claimToken || "";
     const instanceId = cfgOrCtx(node, ctx, "instanceId") || ctx.data?._claimInstanceId || "";
@@ -11289,7 +11807,7 @@ registerBuiltinNodeType("action.resolve_executor", {
       modelOverride: { type: "string", description: "Force a specific model" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const defaultSdk = cfgOrCtx(node, ctx, "defaultSdk", "auto");
     const sdkOverride = cfgOrCtx(node, ctx, "sdkOverride");
     const modelOverride = cfgOrCtx(node, ctx, "modelOverride");
@@ -11530,7 +12048,7 @@ registerBuiltinNodeType("action.acquire_worktree", {
     },
     required: ["branch", "taskId"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     // Outer guard: ensure we ALWAYS return structured output with recoveryNote
     // so downstream {{acquire-worktree.recoveryNote}} templates never stay literal.
     let taskId, branch, repoRoot, baseBranch;
@@ -12067,7 +12585,7 @@ registerBuiltinNodeType("action.release_worktree", {
       removeTimeout: { type: "number", default: 30000, description: "Timeout for removal (ms)" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const worktreePath = cfgOrCtx(node, ctx, "worktreePath");
     const repoRoot = cfgOrCtx(node, ctx, "repoRoot") || process.cwd();
     const taskId = cfgOrCtx(node, ctx, "taskId");
@@ -12129,7 +12647,7 @@ registerBuiltinNodeType("action.recover_worktree", {
       removeTimeout: { type: "number", default: 30000, description: "Timeout for removal (ms)" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const worktreePath = cfgOrCtx(node, ctx, "worktreePath") || ctx.data?.worktreePath || "";
     const repoRoot = cfgOrCtx(node, ctx, "repoRoot") || process.cwd();
     const taskId = cfgOrCtx(node, ctx, "taskId") || ctx.data?.taskId || "";
@@ -12171,7 +12689,7 @@ registerBuiltinNodeType("action.sweep_task_worktrees", {
       timeout: { type: "number", default: 15000, description: "Timeout for git worktree prune (ms)" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const repoRoot = cfgOrCtx(node, ctx, "repoRoot") || process.cwd();
     const taskId = cfgOrCtx(node, ctx, "taskId") || ctx.data?.taskId || "";
     const timeout = Number(node.config?.timeout ?? 15000);
@@ -12208,7 +12726,7 @@ const readWorkflowContractHandler = {
       },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const projectRoot = cfgOrCtx(node, ctx, "projectRoot")
       || cfgOrCtx(node, ctx, "worktreePath")
       || cfgOrCtx(node, ctx, "repoRoot")
@@ -12277,7 +12795,7 @@ const workflowContractValidationHandler = {
       },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const projectRoot = cfgOrCtx(node, ctx, "projectRoot")
       || cfgOrCtx(node, ctx, "worktreePath")
       || cfgOrCtx(node, ctx, "repoRoot")
@@ -12379,7 +12897,7 @@ registerBuiltinNodeType("action.build_task_prompt", {
     },
     required: ["taskTitle"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const taskId = cfgOrCtx(node, ctx, "taskId");
     const taskTitle = cfgOrCtx(node, ctx, "taskTitle");
     const taskDescription = cfgOrCtx(node, ctx, "taskDescription");
@@ -12396,6 +12914,14 @@ registerBuiltinNodeType("action.build_task_prompt", {
     const includeMemory = node.config?.includeMemory !== false;
     ctx.data._taskIncludeContext = includeComments;
     const customTemplate = cfgOrCtx(node, ctx, "promptTemplate");
+    const workflowIssueAdvisor =
+      ctx.data?._issueAdvisor && typeof ctx.data._issueAdvisor === "object"
+        ? ctx.data._issueAdvisor
+        : null;
+    const workflowDagStateSummary =
+      ctx.data?._plannerFeedback?.dagStateSummary && typeof ctx.data._plannerFeedback.dagStateSummary === "object"
+        ? ctx.data._plannerFeedback.dagStateSummary
+        : null;
     const taskPayload =
       ctx.data?.task && typeof ctx.data.task === "object"
         ? ctx.data.task
@@ -12716,6 +13242,18 @@ registerBuiltinNodeType("action.build_task_prompt", {
       userParts.push("");
     }
 
+    if (workflowIssueAdvisor || workflowDagStateSummary) {
+      userParts.push("## Workflow Continuation Context");
+      if (workflowIssueAdvisor?.recommendedAction) userParts.push(`- **Issue Advisor Action:** ${workflowIssueAdvisor.recommendedAction}`);
+      if (workflowIssueAdvisor?.summary) userParts.push(`- **Issue Advisor Summary:** ${workflowIssueAdvisor.summary}`);
+      if (workflowIssueAdvisor?.nextStepGuidance) userParts.push(`- **Next-Step Guidance:** ${workflowIssueAdvisor.nextStepGuidance}`);
+      if (workflowDagStateSummary?.counts) {
+        userParts.push(`- **DAG Counts:** completed=${Number(workflowDagStateSummary.counts.completed ?? 0) || 0}, failed=${Number(workflowDagStateSummary.counts.failed ?? 0) || 0}, pending=${Number(workflowDagStateSummary.counts.pending ?? 0) || 0}`);
+      }
+      if (workflowDagStateSummary?.revisionCount !== undefined) userParts.push(`- **DAG Revisions:** ${workflowDagStateSummary.revisionCount}`);
+      userParts.push("");
+    }
+
     if (includeComments) {
       const taskContextBlock = buildTaskContextBlock(taskPayload);
       if (taskContextBlock) {
@@ -13002,7 +13540,7 @@ registerBuiltinNodeType("action.persist_memory", {
     },
     required: ["content"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const TASK_TEMPLATE_PLACEHOLDER_RE = /^\{\{\s*[\w.-]+\s*\}\}$/;
     const TASK_TEMPLATE_INLINE_PLACEHOLDER_RE = /\{\{\s*[\w.-]+\s*\}\}/g;
     const normalizeString = (value) => {
@@ -13198,7 +13736,7 @@ registerBuiltinNodeType("action.auto_commit_dirty", {
     },
     required: ["worktreePath"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const worktreePath = cfgOrCtx(node, ctx, "worktreePath");
     const taskId = cfgOrCtx(node, ctx, "taskId") || ctx.data?.taskId || "unknown";
 
@@ -13270,7 +13808,7 @@ registerBuiltinNodeType("action.detect_new_commits", {
       baseBranch: { type: "string", description: "Base branch for diff stats" },
     },
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const worktreePath = cfgOrCtx(node, ctx, "worktreePath");
     const baseBranch = cfgOrCtx(node, ctx, "baseBranch", "origin/main");
 
@@ -13407,7 +13945,7 @@ registerBuiltinNodeType("action.push_branch", {
     },
     required: ["worktreePath"],
   },
-  async execute(node, ctx) {
+  async execute(node, ctx, engine) {
     const worktreePath = cfgOrCtx(node, ctx, "worktreePath");
     const branch = cfgOrCtx(node, ctx, "branch", "");
     const baseBranch = cfgOrCtx(node, ctx, "baseBranch", "origin/main");
@@ -14084,3 +14622,6 @@ export async function ensureWorkflowNodeTypesLoaded(options = {}) {
 }
 
 
+
+
+