bosun 0.43.0 → 0.43.1

package/infra/monitor.mjs

@@ -3188,6 +3188,18 @@ function isFlowReviewGateEnabled() {
   return !isFalsyFlag(flowRequireReviewDefault);
 }
 
+function isMonitorMonitorEnabled() {
+  if (isMonitorTestRuntime) return false;
+
+  const explicit =
+    process.env.DEVMODE_MONITOR_MONITOR_ENABLED ??
+    process.env.DEVMODE_AUTO_CODE_FIX_ENABLED;
+  if (explicit !== undefined && String(explicit).trim() !== "") {
+    return !isFalsyFlag(explicit);
+  }
+
+  return false;
+}
 
 function isSelfRestartWatcherEnabled() {
   const devMode = isDevMode();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.43.0",
+  "version": "0.43.1",
   "description": "Bosun Autonomous Engineering — manages AI agent executors with failover, extremely powerful workflow builder, and a massive amount of included default workflow templates for autonomous engineering, creates PRs via GitHub/Jira APIs, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache-2.0",
@@ -550,12 +550,12 @@
     "@toast-ui/editor": "^3.2.2",
     "@whiskeysockets/baileys": "^7.0.0-rc.9",
     "ajv": "^8.18.0",
-    "dompurify": "^3.4.1",
+    "dompurify": "^3.4.2",
     "es-module-shims": "^2.8.0",
     "express": "^5.1.0",
-    "express-rate-limit": "^8.0.0",
+    "express-rate-limit": "^8.5.1",
     "figures": "^6.1.0",
-    "hono": "^4.12.14",
+    "hono": "^4.12.18",
     "htm": "3.1.1",
     "ink": "^5.0.0",
     "ink-text-input": "^6.0.0",

package/server/ui-server.mjs

@@ -2892,6 +2892,29 @@ function sanitizeTaskDiagnosticText(value, maxLength = 240) {
   return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
 }
 
+const LOW_SIGNAL_BLOCKED_REASONS = new Set([
+  "ok",
+  "okay",
+  "success",
+  "succeeded",
+  "passed",
+  "pass",
+  "true",
+  "done",
+  "completed",
+  "complete",
+  "none",
+  "null",
+  "undefined",
+]);
+
+function normalizeBlockedReasonForDisplay(value, maxLength = 280) {
+  const text = sanitizeTaskDiagnosticText(value, maxLength);
+  if (!text) return "";
+  if (LOW_SIGNAL_BLOCKED_REASONS.has(text.toLowerCase())) return "";
+  return text;
+}
+
 const TASK_LOG_DIAGNOSTICS_TAIL_BYTES = 256 * 1024;
 const TASK_LOG_DIAGNOSTICS_CACHE_MS = 5000;
 
@@ -2983,7 +3006,7 @@ function collectTaskWorkflowRunDiagnostics(task, limit = 8) {
       || worktreeFailure?.failureKind
       || "",
     ).trim();
-    const errorText = sanitizeTaskDiagnosticText(
+    const errorText = normalizeBlockedReasonForDisplay(
       worktreeFailure?.error
       || meta?.error
       || meta?.blockedReason
@@ -2991,10 +3014,21 @@ function collectTaskWorkflowRunDiagnostics(task, limit = 8) {
       || "",
       320,
     );
-    const blockedReason = sanitizeTaskDiagnosticText(
-      worktreeFailure?.blockedReason || "",
+    const blockedReason = normalizeBlockedReasonForDisplay(
+      worktreeFailure?.blockedReason
+        || meta?.blockedReason
+        || run?.blockedReason
+        || "",
       280,
     );
+    const status = String(run?.status || "").trim().toLowerCase();
+    const diagnosticText = [
+      failureKind,
+      errorText,
+      blockedReason,
+      run?.summary,
+      run?.message,
+    ].filter(Boolean).join("\n");
     const isWorktreeFailure =
       failureKind === "branch_refresh_conflict"
       || failureKind === "worktree_acquisition_failed"
@@ -3002,17 +3036,29 @@ function collectTaskWorkflowRunDiagnostics(task, limit = 8) {
       || /worktree/i.test(errorText)
       || /refresh conflict/i.test(blockedReason)
       || /managed worktree/i.test(errorText);
-    if (!isWorktreeFailure) continue;
+    const isWorkflowFailure =
+      isWorktreeFailure
+      || ["failed", "blocked", "error", "cancelled", "canceled"].includes(status)
+      || /pre-?pr validation failed/i.test(diagnosticText)
+      || /prepush/i.test(diagnosticText)
+      || /failed to push/i.test(diagnosticText)
+      || /push failed/i.test(diagnosticText)
+      || /create-pr/i.test(diagnosticText)
+      || /retry-pr-ok/i.test(diagnosticText)
+      || /vitest-pool/i.test(diagnosticText)
+      || /Worker exited unexpectedly/i.test(diagnosticText);
+    if (!isWorkflowFailure) continue;
     relevant.push({
       source: "workflow-run",
       runId: String(run?.runId || "").trim() || null,
       workflowId: String(run?.workflowId || "").trim() || null,
       workflowName: String(run?.workflowName || "").trim() || null,
-      message: errorText || blockedReason || "Workflow run recorded a worktree failure.",
+      message: errorText || blockedReason || `Workflow run ${status || "failed"}.`,
       reason: blockedReason || null,
       failureKind: failureKind || null,
       timestamp: run?.endedAt || run?.startedAt || null,
       kind: "workflow-run",
+      diagnosticCategory: isWorktreeFailure ? "worktree_failure" : "workflow_failure",
       retryable: worktreeFailure?.retryable ?? null,
       retryAt: worktreeFailure?.retryAt || null,
       recordedAt: worktreeFailure?.recordedAt || null,
@@ -3037,10 +3083,14 @@ async function collectTaskLogDiagnostics(task, workspaceDir = "", limit = 8) {
     if (!candidate || !existsSync(candidate) || logPaths.includes(candidate)) return;
     logPaths.push(candidate);
   };
+  pushLogPath(resolve(__dirname, "..", ".bosun", "logs", "monitor-error.log"));
+  pushLogPath(resolve(__dirname, "..", ".bosun", "logs", "monitor.log"));
   if (workspaceDir) {
     pushLogPath(resolve(workspaceDir, ".bosun", "logs", "monitor-error.log"));
     pushLogPath(resolve(workspaceDir, ".bosun", "logs", "monitor.log"));
   }
+  pushLogPath(resolve(process.cwd(), ".bosun", "logs", "monitor-error.log"));
+  pushLogPath(resolve(process.cwd(), ".bosun", "logs", "monitor.log"));
   pushLogPath(resolve(repoRoot, ".bosun", "logs", "monitor-error.log"));
   pushLogPath(resolve(repoRoot, ".bosun", "logs", "monitor.log"));
 
@@ -3117,7 +3167,7 @@ async function buildTaskBlockedContext(task, options = {}) {
     ? options.canStart
     : null;
   const normalizedStatus = normalizeTaskStatusKey(currentTask?.status);
-  const explicitReason = sanitizeTaskDiagnosticText(
+  const explicitReason = normalizeBlockedReasonForDisplay(
     currentTask?.blockedReason
       || currentTask?.meta?.worktreeFailure?.blockedReason
       || currentTask?.meta?.autoRecovery?.error
@@ -3133,7 +3183,7 @@ async function buildTaskBlockedContext(task, options = {}) {
       headline: "This task cannot start because one or more dependencies are not done yet.",
       summary: "Bosun will not dispatch this task until every blocking dependency below is resolved.",
       recommendation: "Complete or unblock the listed dependencies, then dispatch this task again.",
-      reason: explicitReason || sanitizeTaskDiagnosticText(canStart?.reason || ""),
+      reason: explicitReason || normalizeBlockedReasonForDisplay(canStart?.reason || ""),
       workflowRunCount: 0,
       prePrValidationFailureCount: 0,
       worktreeFailureCount: 0,
@@ -3163,6 +3213,7 @@ async function buildTaskBlockedContext(task, options = {}) {
     6,
   );
   const hasPlannerCorruption = /planner payload corrupted/i.test(explicitReason);
+  const latestWorkflowEvidence = workflowRunEvidence[workflowRunEvidence.length - 1] || null;
   const repairArtifacts =
     currentTask?.meta?.worktreeFailure?.repairArtifacts
     && typeof currentTask.meta.worktreeFailure.repairArtifacts === "object"
@@ -3170,7 +3221,7 @@ async function buildTaskBlockedContext(task, options = {}) {
       : null;
   const hasWorktreeFailure =
     Boolean(currentTask?.meta?.worktreeFailure) ||
-    workflowRunEvidence.length > 0 ||
+    workflowRunEvidence.some((entry) => entry?.diagnosticCategory === "worktree_failure") ||
     logDiagnostics.counts.worktreeFailed > 0 ||
     timelineEvidence.some((entry) => /worktree failed/i.test(String(entry?.message || "")));
 
@@ -3200,12 +3251,16 @@ async function buildTaskBlockedContext(task, options = {}) {
   } else if (normalizedStatus === "blocked") {
     category = "blocked";
     headline = "This task is blocked.";
-    summary = explicitReason || "Bosun marked this task as blocked, but the original blocked reason was not persisted.";
+    summary = explicitReason
+      || (latestWorkflowEvidence?.message
+        ? `Latest workflow failure: ${latestWorkflowEvidence.message}`
+        : "Bosun marked this task as blocked, but the original blocked reason was not persisted.");
     recommendation = "Review the recent workflow evidence below. After the underlying issue is fixed, move the task back to todo to clear the block and retry it.";
   } else if (canStart?.canStart === false) {
     category = "start_guard_blocked";
     headline = "This task is currently not startable.";
-    summary = sanitizeTaskDiagnosticText(canStart?.reason || "Bosun start guards rejected dispatch for this task.");
+    summary = normalizeBlockedReasonForDisplay(canStart?.reason || "")
+      || "Bosun start guards rejected dispatch for this task.";
     recommendation = "Resolve the blocking condition below before dispatching the task.";
   } else {
     return null;
@@ -3217,10 +3272,13 @@ async function buildTaskBlockedContext(task, options = {}) {
     headline,
     summary,
     recommendation,
-    reason: explicitReason || sanitizeTaskDiagnosticText(canStart?.reason || ""),
+    reason: explicitReason || normalizeBlockedReasonForDisplay(canStart?.reason || ""),
     workflowRunCount: workflowRuns.length,
     prePrValidationFailureCount: logDiagnostics.counts.prePrValidationFailed,
-    worktreeFailureCount: Math.max(logDiagnostics.counts.worktreeFailed, workflowRunEvidence.length),
+    worktreeFailureCount: Math.max(
+      logDiagnostics.counts.worktreeFailed,
+      workflowRunEvidence.filter((entry) => entry?.diagnosticCategory === "worktree_failure").length,
+    ),
     blockedTransitionCount: logDiagnostics.counts.blockedTransitions,
     createPrFailureCount: logDiagnostics.counts.createPrFailed,
     blockedBy: Array.isArray(canStart?.blockedBy) ? canStart.blockedBy : [],
@@ -3232,6 +3290,10 @@ async function buildTaskBlockedContext(task, options = {}) {
   };
 }
 
+export async function _testBuildTaskBlockedContext(task, options = {}) {
+  return buildTaskBlockedContext(task, options);
+}
+
 function buildTaskMetaPatch(previousMeta, metadataPatchMeta, options = {}) {
   const clearBlockedState = options.clearBlockedState === true;
   const nextMeta = previousMeta && typeof previousMeta === "object"
@@ -5254,10 +5316,103 @@ function extractImportedTaskList(body = null) {
   return null;
 }
 
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function mergeImportedTaskCollection(baseEntries = [], incomingEntries = [], keyBuilder) {
+  const merged = [];
+  const indexByKey = new Map();
+  const appendEntry = (entry) => {
+    if (!entry || typeof entry !== "object") return;
+    const key = typeof keyBuilder === "function" ? String(keyBuilder(entry) || "").trim() : "";
+    if (key && indexByKey.has(key)) {
+      merged[indexByKey.get(key)] = { ...merged[indexByKey.get(key)], ...entry };
+      return;
+    }
+    merged.push(entry);
+    if (key) indexByKey.set(key, merged.length - 1);
+  };
+  for (const entry of Array.isArray(baseEntries) ? baseEntries : []) appendEntry(entry);
+  for (const entry of Array.isArray(incomingEntries) ? incomingEntries : []) appendEntry(entry);
+  return merged;
+}
+
+function mergeImportedTaskTimeline(baseEntries = [], incomingEntries = []) {
+  return mergeImportedTaskCollection(baseEntries, incomingEntries, (entry) => (
+    entry?.id
+      || [
+        entry?.type,
+        entry?.source,
+        entry?.at,
+        entry?.status,
+        entry?.fromStatus,
+        entry?.toStatus,
+        entry?.message,
+      ].map((value) => String(value || "").trim()).join("|")
+  ));
+}
+
+function mergeImportedTaskStatusHistory(baseEntries = [], incomingEntries = []) {
+  return mergeImportedTaskCollection(baseEntries, incomingEntries, (entry) => [
+    entry?.status,
+    entry?.timestamp,
+    entry?.source,
+  ].map((value) => String(value || "").trim()).join("|"));
+}
+
+function mergeImportedTaskMeta(currentMeta = {}, incomingMeta = {}) {
+  const base = isPlainObject(currentMeta) ? currentMeta : {};
+  const incoming = isPlainObject(incomingMeta) ? incomingMeta : {};
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(incoming)) {
+    if (isPlainObject(value) && isPlainObject(base[key])) {
+      merged[key] = mergeImportedTaskMeta(base[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+
+function buildImportedTaskPatch(currentTask = {}, importedTask = {}, mode = "merge") {
+  const patch = importedTask && typeof importedTask === "object" ? { ...importedTask } : {};
+  if (mode !== "merge") return patch;
+
+  if (Object.prototype.hasOwnProperty.call(importedTask, "workflowRuns")
+      && Array.isArray(importedTask.workflowRuns)) {
+    patch.workflowRuns = mergeTaskWorkflowRuns(
+      Array.isArray(currentTask?.workflowRuns) ? currentTask.workflowRuns : [],
+      importedTask.workflowRuns,
+      200,
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(importedTask, "timeline")
+      && Array.isArray(importedTask.timeline)) {
+    patch.timeline = mergeImportedTaskTimeline(
+      Array.isArray(currentTask?.timeline) ? currentTask.timeline : [],
+      importedTask.timeline,
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(importedTask, "statusHistory")
+      && Array.isArray(importedTask.statusHistory)) {
+    patch.statusHistory = mergeImportedTaskStatusHistory(
+      Array.isArray(currentTask?.statusHistory) ? currentTask.statusHistory : [],
+      importedTask.statusHistory,
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(importedTask, "meta")
+      && isPlainObject(importedTask.meta)) {
+    patch.meta = mergeImportedTaskMeta(currentTask?.meta, importedTask.meta);
+  }
+  return patch;
+}
+
 async function importInternalTaskStateSnapshot(body = {}) {
   const taskStore = await ensureTaskStoreApi();
   const addTaskFn = typeof taskStore?.addTask === "function" ? taskStore.addTask : null;
   const updateTaskFn = typeof taskStore?.updateTask === "function" ? taskStore.updateTask : null;
+  const getTaskFn = typeof taskStore?.getTask === "function" ? taskStore.getTask : null;
   if (!addTaskFn || !updateTaskFn) {
     throw new Error("Internal task store import is unavailable");
   }
@@ -5301,12 +5456,19 @@ async function importInternalTaskStateSnapshot(body = {}) {
 
     try {
       if (existingById.has(taskId)) {
-        updateTaskFn(taskId, task);
+        const currentTask = existingById.get(taskId) || {};
+        const patch = buildImportedTaskPatch(currentTask, task, mode);
+        updateTaskFn(taskId, patch);
+        if (getTaskFn) {
+          existingById.set(taskId, getTaskFn(taskId) || { ...currentTask, ...patch });
+        } else {
+          existingById.set(taskId, { ...currentTask, ...patch });
+        }
         summary.updated += 1;
         results.push({ id: taskId, status: "updated" });
       } else {
         addTaskFn(task);
-        existingById.set(taskId, task);
+        existingById.set(taskId, getTaskFn ? (getTaskFn(taskId) || task) : task);
         summary.created += 1;
         results.push({ id: taskId, status: "created" });
       }
@@ -19798,6 +19960,156 @@ async function handleApi(req, res, url) {
     return;
   }
 
+  if (path === "/api/executor/dispatch" && req.method === "POST") {
+    try {
+      const body = await readJsonBody(req);
+      const prompt = String(body?.prompt || "").trim();
+      let taskId = String(body?.taskId || body?.id || "").trim();
+      const sdk = typeof body?.sdk === "string" ? body.sdk.trim() : "";
+      const model = typeof body?.model === "string" ? body.model.trim() : "";
+      const executor = uiDeps.getInternalExecutor?.();
+      if (!executor) {
+        jsonResponse(res, 400, {
+          ok: false,
+          error: "Internal executor not enabled. Set EXECUTOR_MODE=internal.",
+        });
+        return;
+      }
+      if (!taskId && !prompt) {
+        jsonResponse(res, 400, { ok: false, error: "taskId or prompt is required" });
+        return;
+      }
+
+      const adapter = getKanbanAdapter();
+      let task = taskId && typeof adapter.getTask === "function"
+        ? await adapter.getTask(taskId)
+        : null;
+      if (taskId && !task) {
+        jsonResponse(res, 404, { ok: false, error: "Task not found." });
+        return;
+      }
+
+      let createdFromPrompt = false;
+      if (!taskId) {
+        const activeWorkspace = getActiveManagedWorkspace(resolveUiConfigDir());
+        const defaultRepository =
+          activeWorkspace?.activeRepo ||
+          activeWorkspace?.repos?.find((repo) => repo.primary)?.name ||
+          activeWorkspace?.repos?.[0]?.name ||
+          "";
+        const titleLine = prompt.split(/\r?\n/).map((line) => line.trim()).find(Boolean) || "Fleet prompt dispatch";
+        const taskData = {
+          title: titleLine.length > 96 ? `${titleLine.slice(0, 93)}...` : titleLine,
+          description: prompt,
+          status: "todo",
+          ...(activeWorkspace?.id ? { workspace: activeWorkspace.id } : {}),
+          ...(defaultRepository ? { repository: defaultRepository } : {}),
+          meta: {
+            ...(activeWorkspace?.id ? { workspace: activeWorkspace.id } : {}),
+            ...(defaultRepository ? { repository: defaultRepository } : {}),
+            source: "fleet-dispatch",
+          },
+        };
+        const createdRaw = await adapter.createTask("", taskData);
+        task = withTaskMetadataTopLevel(createdRaw);
+        taskId = String(task?.id || "").trim();
+        createdFromPrompt = true;
+      }
+
+      const canStart = await evaluateTaskCanStart({
+        taskId,
+        task,
+        adapter,
+        forceStart: body?.force === true || body?.forceStart === true,
+        manualOverride: body?.manualOverride === true || body?.overrideStartGuard === true,
+      });
+      if (!canStart.canStart) {
+        jsonResponse(res, 409, {
+          ok: false,
+          taskId,
+          error: "Task cannot be dispatched",
+          canStart,
+          data: task ? withTaskRuntimeSnapshot(task) : null,
+        });
+        return;
+      }
+
+      const status = executor.getStatus?.() || {};
+      const activeSlots = Array.isArray(status?.slots) ? status.slots : [];
+      const maxParallel = Number(status?.maxParallel || 0);
+      const activeCount = Number(status?.activeSlots || activeSlots.length || 0);
+      const hasFreeSlot = maxParallel <= 0 || activeCount < maxParallel;
+      if (!hasFreeSlot) {
+        const queuedTask = await persistTaskExecutionMeta(adapter, taskId, {
+          queued: true,
+          queueState: "queued",
+          requestedAt: new Date().toISOString(),
+        });
+        jsonResponse(res, 202, {
+          ok: true,
+          taskId,
+          queued: true,
+          started: false,
+          createdFromPrompt,
+          reason: "No free slots",
+          canStart,
+          data: withTaskRuntimeSnapshot(queuedTask || task),
+        });
+        broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
+          reason: "task-queued",
+          taskId,
+        });
+        return;
+      }
+
+      let startedTask = await persistTaskStatusForExecution(adapter, taskId, "inprogress", "api.executor.dispatch") || task;
+      startedTask = await persistTaskExecutionMeta(adapter, taskId, {
+        queued: false,
+        queueState: null,
+      }) || startedTask;
+      applyInternalLifecycleTransition(taskId, "start", {
+        source: "api.executor.dispatch",
+        actor: "ui",
+        force: body?.force === true || body?.forceStart === true || body?.manualOverride === true || body?.overrideStartGuard === true,
+        reason: createdFromPrompt ? "fleet prompt dispatch" : "fleet task dispatch",
+      });
+
+      traceHttpServerAction(req, {
+        route: "/api/executor/dispatch",
+        taskId,
+      }, () => executor.executeTask(startedTask, {
+        ...(sdk ? { sdk } : {}),
+        ...(model ? { model } : {}),
+        force: body?.force === true || body?.forceStart === true || body?.manualOverride === true || body?.overrideStartGuard === true,
+      })).catch((error) => {
+        console.warn(`[telegram-ui] fleet dispatch failed for ${taskId}: ${error.message}`);
+        void persistTaskStatusForExecution(
+          adapter,
+          taskId,
+          resolveFallbackStatusAfterFailedDispatch(task?.status, { started: false }),
+          "api.executor.dispatch.failed",
+        );
+      });
+
+      jsonResponse(res, 200, {
+        ok: true,
+        taskId,
+        queued: false,
+        started: true,
+        createdFromPrompt,
+        canStart,
+        data: withTaskRuntimeSnapshot(startedTask),
+      });
+      broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
+        reason: "task-dispatched",
+        taskId,
+      });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/executor") {
     const executor = uiDeps.getInternalExecutor?.();
     const mode = uiDeps.getExecutorMode?.() || "internal";

package/ui/components/kanban-board.js

@@ -393,6 +393,8 @@ export function buildKanbanColumnItems(tasks = [], hierarchyView = null, hierarc
   const groups = new Map();
   const taskById = hierarchyModel?.taskById || new Map();
   const epicGroupById = new Map((hierarchyView?.epicGroups || []).map((entry) => [String(entry.id || ""), entry]));
+  const nodeStateById = hierarchyView?.nodeStateById || new Map();
+  const hasSearch = nodeStateById.size > 0;
   rows.sort((left, right) => getHierarchySortOrder(hierarchyModel, left?.id) - getHierarchySortOrder(hierarchyModel, right?.id));
 
   const ensureGroup = (key, create) => {
@@ -402,7 +404,8 @@ export function buildKanbanColumnItems(tasks = [], hierarchyView = null, hierarc
 
   for (const task of rows) {
     const taskId = String(task?.id || "");
-    const node = hierarchyView?.nodeStateById?.get?.(taskId) || null;
+    if (hierarchyView?.visibleTaskIds?.size && !hierarchyView.visibleTaskIds.has(taskId)) continue;
+    const node = nodeStateById.get?.(taskId) || null;
     const parentId = String(node?.meta?.parentTaskId || "");
     if (parentId && hierarchyView?.nodeStateById?.get?.(parentId)?.isParentNode) {
       const parentNode = hierarchyView.nodeStateById.get(parentId);
@@ -416,10 +419,14 @@ export function buildKanbanColumnItems(tasks = [], hierarchyView = null, hierarc
         children: [],
       }));
       if (parentTask?.id) coveredHeaderTaskIds.add(String(parentTask.id));
+      const isDirectMatch = node?.searchMatchState === "direct" || node?.searchMatchState === "self";
       if (taskId === parentId) {
         coveredHeaderTaskIds.add(taskId);
         continue;
       }
+      if (hasSearch && parentNode && !isDirectMatch && !parentNode.visibleChildIds?.includes(taskId)) {
+        continue;
+      }
       groupedTaskIds.add(taskId);
       group.children.push(task);
       continue;
@@ -430,20 +437,26 @@ export function buildKanbanColumnItems(tasks = [], hierarchyView = null, hierarc
     const taskType = getTaskHierarchyTaskType(task, "task");
     if (epicGroup && epicGroup.visibleTaskCount > 1 && taskType !== "epic") {
       const anchorTask = epicGroup.anchorTaskId ? taskById.get(epicGroup.anchorTaskId) : null;
+      const anchorTaskId = String(anchorTask?.id || epicGroup.anchorTaskId || "");
+      const anchorNode = anchorTaskId ? nodeStateById.get?.(anchorTaskId) || null : null;
       const group = ensureGroup(`epic:${epicId}`, () => ({
         key: `epic:${epicId}`,
         kind: "epic",
         parentTask: anchorTask,
-        parentNode: anchorTask ? hierarchyView?.nodeStateById?.get?.(String(anchorTask.id)) || null : null,
+        parentNode: anchorNode,
         epicGroup,
         title: epicGroup.label || epicId,
         children: [],
       }));
       if (anchorTask?.id) coveredHeaderTaskIds.add(String(anchorTask.id));
-      if (anchorTask?.id && taskId === String(anchorTask.id)) {
+      if (anchorTaskId && taskId === anchorTaskId) {
         coveredHeaderTaskIds.add(taskId);
         continue;
       }
+      const isDirectMatch = node?.searchMatchState === "direct" || node?.searchMatchState === "self";
+      if (hasSearch && !isDirectMatch && !epicGroup.visibleTaskIds?.includes(taskId)) {
+        continue;
+      }
       groupedTaskIds.add(taskId);
       group.children.push(task);
     }
@@ -465,6 +478,7 @@ export function buildKanbanColumnItems(tasks = [], hierarchyView = null, hierarc
 
   for (const task of rows) {
     const taskId = String(task?.id || "");
+    if (hierarchyView?.visibleTaskIds?.size && !hierarchyView.visibleTaskIds.has(taskId)) continue;
     if (groupedTaskIds.has(taskId) || coveredHeaderTaskIds.has(taskId)) continue;
     items.push({
       kind: "task",
@@ -477,6 +491,46 @@ export function buildKanbanColumnItems(tasks = [], hierarchyView = null, hierarc
   return items;
 }
 
+export function groupTasksByStatus(tasks = [], options = {}) {
+  const rows = Array.isArray(tasks) ? tasks.filter((task) => task && typeof task === "object") : [];
+  const statuses = Array.isArray(options?.statuses) && options.statuses.length > 0
+    ? options.statuses.map((status) => String(status || "").trim()).filter(Boolean)
+    : ["todo", "inprogress", "inreview", "done", "blocked", "draft"];
+  const result = Object.create(null);
+  for (const status of statuses) result[status] = [];
+
+  if (options?.hierarchyMode) {
+    const hierarchyModel = buildTaskHierarchyModel(rows);
+    const hierarchyView = deriveTaskHierarchyView(hierarchyModel);
+    for (const status of statuses) {
+      const statusRows = rows.filter((task) => String(task?.status || "").trim() === status);
+      const grouped = buildKanbanColumnItems(statusRows, hierarchyView, hierarchyModel);
+      result[status] = grouped.map((entry) => {
+        if (entry?.kind === "group") {
+          const parentTask = entry.group?.parentTask || null;
+          const childTasks = Array.isArray(entry.group?.children) ? entry.group.children.filter(Boolean) : [];
+          if (parentTask && childTasks.length > 0) {
+            return {
+              ...parentTask,
+              childTasks,
+            };
+          }
+        }
+        return entry?.task || entry;
+      }).filter(Boolean);
+    }
+    return result;
+  }
+
+  for (const task of rows) {
+    const normalizedStatus = String(task?.status || "").trim();
+    if (!normalizedStatus) continue;
+    if (!Array.isArray(result[normalizedStatus])) result[normalizedStatus] = [];
+    result[normalizedStatus].push(task);
+  }
+  return result;
+}
+
 function getTaskTypeBadgeLabel(taskType) {
   const normalized = String(taskType || "task").toLowerCase();
   if (normalized === "epic") return "EPIC";
@@ -1689,5 +1743,3 @@ export function KanbanBoard({ onOpenTask, hasMoreTasks = false, loadingMoreTasks
     </${Box}>
   `;
 }
-
-

package/ui/demo-defaults.js

@@ -7288,7 +7288,7 @@
           "type": "condition.expression",
           "label": "PR Created?",
           "config": {
-            "expression": "Boolean($ctx.getNodeOutput($edge.source)?.prNumber || $ctx.getNodeOutput($edge.source)?.prUrl)"
+            "expression": "Boolean($ctx.getNodeOutput('create-pr')?.prNumber || $ctx.getNodeOutput('create-pr')?.prUrl)"
           },
           "position": {
             "x": 400,
@@ -7531,7 +7531,7 @@
           "type": "condition.expression",
           "label": "PR Created?",
           "config": {
-            "expression": "Boolean($ctx.getNodeOutput($edge.source)?.prNumber || $ctx.getNodeOutput($edge.source)?.prUrl)"
+            "expression": "Boolean($ctx.getNodeOutput('create-pr-retry')?.prNumber || $ctx.getNodeOutput('create-pr-retry')?.prUrl)"
           },
           "position": {
             "x": 400,
@@ -7759,7 +7759,7 @@
           "type": "condition.expression",
           "label": "PR Created?",
           "config": {
-            "expression": "Boolean($ctx.getNodeOutput($edge.source)?.prNumber || $ctx.getNodeOutput($edge.source)?.prUrl)"
+            "expression": "Boolean($ctx.getNodeOutput('create-pr-retry2')?.prNumber || $ctx.getNodeOutput('create-pr-retry2')?.prUrl)"
           },
           "position": {
             "x": 400,
@@ -9950,7 +9950,7 @@
           "config": {
             "plannerNodeId": "run-planner",
             "maxTasks": "{{taskCount}}",
-            "status": "draft",
+            "status": "todo",
             "dedup": true,
             "failOnZero": true,
             "minCreated": 1
@@ -10575,7 +10575,7 @@
           "type": "action.run_agent",
           "label": "Build Follow-up Tasks JSON",
           "config": {
-            "prompt": "Convert FOLLOW_UP_ACTION lines below into a single JSON object with shape { \"tasks\": [...] }.\n\nSource:\n{{evaluate-fitness.output}}\n\nStructured context:\n{{fitnessSummaryJson}}\n\nRules:\n- Generate at most {{maxFollowupTasks}} tasks\n- Include fields: title, description, implementation_steps, acceptance_criteria, verification, priority, tags, base_branch, impact, confidence, risk, estimated_effort, repo_areas, why_now, kill_criteria\n- Use trend deltas from the summary artifact to justify urgency and avoid parse errors\n- Keep tasks implementation-ready and avoid duplicates\n- Return only JSON",
+            "prompt": "Convert FOLLOW_UP_ACTION lines below into a single JSON object with shape { \"tasks\": [...] }.\n\nSource:\n{{evaluate-fitness.output}}\n\nStructured context:\n{{fitnessSummaryJson}}\n\nRules:\n- Generate at most {{maxFollowupTasks}} tasks\n- Include fields: task_key, title, description, implementation_steps, files, tests, api_contracts, acceptance_criteria, verification, priority, tags, base_branch, impact, confidence, risk, estimated_effort, repo_areas, why_now, kill_criteria\n- Use sprint_id, epic_id, parent_task_key, and depends_on_task_keys when the work belongs in an existing sprint/epic or has DAG ordering\n- Use trend deltas from the summary artifact to justify urgency and avoid parse errors\n- Keep tasks implementation-ready and avoid duplicates\n- Return only JSON",
             "sdk": "auto",
             "timeoutMs": 300000
           },
@@ -22958,7 +22958,7 @@
       "enabled": true,
       "trigger": "trigger.task_available",
       "variables": {
-        "maxConcurrent": 3,
+        "maxConcurrent": 5,
         "pollStatus": "todo",
         "maxBatchSize": 10,
         "subWorkflow": "template-task-lifecycle",
@@ -32953,7 +32953,7 @@
           "type": "condition.expression",
           "label": "PR Created?",
           "config": {
-            "expression": "Boolean($ctx.getNodeOutput($edge.source)?.prNumber || $ctx.getNodeOutput($edge.source)?.prUrl)"
+            "expression": "Boolean($ctx.getNodeOutput('create-pr')?.prNumber || $ctx.getNodeOutput('create-pr')?.prUrl)"
           },
           "position": {
             "x": 400,
@@ -33196,7 +33196,7 @@
           "type": "condition.expression",
           "label": "PR Created?",
           "config": {
-            "expression": "Boolean($ctx.getNodeOutput($edge.source)?.prNumber || $ctx.getNodeOutput($edge.source)?.prUrl)"
+            "expression": "Boolean($ctx.getNodeOutput('create-pr-retry')?.prNumber || $ctx.getNodeOutput('create-pr-retry')?.prUrl)"
           },
           "position": {
             "x": 400,
@@ -33424,7 +33424,7 @@
           "type": "condition.expression",
           "label": "PR Created?",
           "config": {
-            "expression": "Boolean($ctx.getNodeOutput($edge.source)?.prNumber || $ctx.getNodeOutput($edge.source)?.prUrl)"
+            "expression": "Boolean($ctx.getNodeOutput('create-pr-retry2')?.prNumber || $ctx.getNodeOutput('create-pr-retry2')?.prUrl)"
           },
           "position": {
             "x": 400,
@@ -35486,7 +35486,7 @@
           "config": {
             "plannerNodeId": "run-planner",
             "maxTasks": "{{taskCount}}",
-            "status": "draft",
+            "status": "todo",
             "dedup": true,
             "failOnZero": true,
             "minCreated": 1
@@ -36069,7 +36069,7 @@
           "type": "action.run_agent",
           "label": "Build Follow-up Tasks JSON",
           "config": {
-            "prompt": "Convert FOLLOW_UP_ACTION lines below into a single JSON object with shape { \"tasks\": [...] }.\n\nSource:\n{{evaluate-fitness.output}}\n\nStructured context:\n{{fitnessSummaryJson}}\n\nRules:\n- Generate at most {{maxFollowupTasks}} tasks\n- Include fields: title, description, implementation_steps, acceptance_criteria, verification, priority, tags, base_branch, impact, confidence, risk, estimated_effort, repo_areas, why_now, kill_criteria\n- Use trend deltas from the summary artifact to justify urgency and avoid parse errors\n- Keep tasks implementation-ready and avoid duplicates\n- Return only JSON",
+            "prompt": "Convert FOLLOW_UP_ACTION lines below into a single JSON object with shape { \"tasks\": [...] }.\n\nSource:\n{{evaluate-fitness.output}}\n\nStructured context:\n{{fitnessSummaryJson}}\n\nRules:\n- Generate at most {{maxFollowupTasks}} tasks\n- Include fields: task_key, title, description, implementation_steps, files, tests, api_contracts, acceptance_criteria, verification, priority, tags, base_branch, impact, confidence, risk, estimated_effort, repo_areas, why_now, kill_criteria\n- Use sprint_id, epic_id, parent_task_key, and depends_on_task_keys when the work belongs in an existing sprint/epic or has DAG ordering\n- Use trend deltas from the summary artifact to justify urgency and avoid parse errors\n- Keep tasks implementation-ready and avoid duplicates\n- Return only JSON",
             "sdk": "auto",
             "timeoutMs": 300000
           },
@@ -47874,7 +47874,7 @@
       "nodeCount": 9,
       "trigger": "trigger.task_available",
       "variables": {
-        "maxConcurrent": 3,
+        "maxConcurrent": 5,
         "pollStatus": "todo",
         "maxBatchSize": 10,
         "subWorkflow": "template-task-lifecycle",

package/ui/modules/task-hierarchy.js

@@ -144,7 +144,7 @@ export function buildTaskHierarchyModel(tasks = [], options = {}) {
       taskType,
       epicId,
       parentTaskId,
-      collapseKey: getTaskHierarchyCollapseKey("task", id),
+      collapseKey: getTaskHierarchyCollapseKey(taskType, id),
       epicCollapseKey: epicId ? getTaskHierarchyCollapseKey("epic", epicId) : "",
     });
   }
@@ -278,7 +278,7 @@ export function deriveTaskHierarchyView(model, options = {}) {
     }, 0);
     const descendantMatch = visibleChildIds.length > 0;
     const visible = directMatch || descendantMatch;
-    const searchMatchState = directMatch ? "self" : descendantMatch ? "descendant" : "none";
+    const searchMatchState = directMatch ? "direct" : descendantMatch ? "descendant" : "none";
     const state = {
       id,
       task,

package/ui/tabs/agents.js

@@ -3445,10 +3445,10 @@ function FleetSessionsPanel({ slots, sessions = [], taskFallbackEntries = [], on
                     onClick=${() => setDetailTab("turns")}
                   >${iconText(":repeat: Turns")}<//>
                 </div>
-                <div class="fleet-session-body" style=${{ flex: "1 1 auto", minHeight: 0, overflowY: "auto", overflowX: "hidden", paddingRight: "4px" }}>
+                <div class="fleet-session-body" style=${{ flex: "1 1 auto", minHeight: 0, overflow: "hidden", paddingRight: "4px" }}>
                   ${detailTab === "stream"
                     ? streamSessionId
-                      ? html`<${ChatView} sessionId=${streamSessionId} readOnly=${true} />`
+                      ? html`<${ChatView} sessionId=${streamSessionId} readOnly=${true} embedded=${true} />`
                       : html`
                           <div class="chat-view chat-empty-state">
                             <div class="session-empty-icon">${resolveIcon(":chat:")}</div>

package/ui/tabs/tasks.js

@@ -242,7 +242,8 @@ function normalizeTagInput(input) {
   const seen = new Set();
   const tags = [];
   for (const value of values) {
-    const normalized = String(value || "")
+    const raw = typeof value === "string" ? value : value?.name || value?.label || value?.value || "";
+    const normalized = String(raw || "")
       .trim()
       .toLowerCase();
     if (!normalized || seen.has(normalized) || SYSTEM_TAGS.has(normalized)) continue;
@@ -441,6 +442,8 @@ export function normalizeSubtaskRow(entry, fallbackParentTaskId = "") {
     status: toText(entry.status || entry.state),
     assignee: toText(entry.assignee || entry.owner),
     taskType: normalizeTaskTypeValue(entry?.taskType || entry?.type || entry?.kind || entry?.meta?.taskType || entry?.meta?.type, "subtask"),
+    collapseKey: toText(entry.collapseKey || entry?.meta?.collapseKey),
+    epicCollapseKey: toText(entry.epicCollapseKey || entry?.meta?.epicCollapseKey),
     storyPoints: toText(entry.storyPoints || entry.points),
     epicId: toText(entry.epicId || entry.epic || entry.epic_id || entry?.meta?.epicId),
     dueDate: normalizeTaskDueDateInput(entry),
@@ -484,7 +487,9 @@ function mergeSubtaskLists(...lists) {
 }
 
 export function buildTaskHierarchyPath(task, hierarchyModel = null) {
-  const taskById = hierarchyModel?.taskById || new Map();
+  const taskById = hierarchyModel instanceof Map
+    ? hierarchyModel
+    : (hierarchyModel?.taskById || new Map());
   const path = [];
   const seen = new Set();
   let cursor = task;

package/workflow/workflow-engine.mjs

@@ -5157,13 +5157,14 @@ export class WorkflowEngine extends EventEmitter {
     }
     const createTasksGuard = this._resolvePendingCreateTasksGuard(originalRun, def);
     const isInterruptedResume = retryOpts._resumeInterrupted === true;
+    const operatorAction = String(retryOpts.operatorAction || "").trim().toLowerCase();
     const isResumeLikeRetry =
       (mode === "from_failed" && !isInterruptedResume)
       || mode === "replan_from_failed"
       || mode === "replan_subgraph";
     const blocksManualRestart = mode === "from_scratch" && createTasksGuard?.safeResume;
     if (createTasksGuard && (isResumeLikeRetry || blocksManualRestart)) {
-      if (isInterruptedResume) {
+      if (isInterruptedResume || operatorAction === "resume") {
         if (!createTasksGuard.safeResume) {
           throw new Error(`${TAG} ${createTasksGuard.resumeBlockedMessage}`);
         }
@@ -5672,8 +5673,10 @@ export class WorkflowEngine extends EventEmitter {
     if (!this._loaded) this.load();
 
     const triggered = [];
+    const triggeredWorkflowIds = new Set();
     for (const [id, def] of this._workflows) {
       if (def.enabled === false) continue;
+      if (triggeredWorkflowIds.has(id)) continue;
 
       // Find trigger nodes
       const triggerNodes = (def.nodes || []).filter((n) =>
@@ -5733,6 +5736,8 @@ export class WorkflowEngine extends EventEmitter {
           });
           if (shouldFire?.triggered) {
             triggered.push({ workflowId: id, triggeredBy: tNode.id, eventData });
+            triggeredWorkflowIds.add(id);
+            break;
           }
         } catch {
           // Trigger evaluation errors are non-fatal
@@ -7109,7 +7114,6 @@ export class WorkflowEngine extends EventEmitter {
     };
   }
 
-
   /**
    * Get task-linked workflow trace events for a run.
    * Returns [] when run is unknown or has no task trace data.
@@ -9937,6 +9941,14 @@ export class WorkflowEngine extends EventEmitter {
         }
       }
 
+      const indexedRunCountsByTaskId = new Map();
+      for (const run of allRuns) {
+        const ident = identityCache.get(run.runId) ?? getIdentity(run.runId);
+        const taskId = this._resolveRunTaskIdentity(run, ident)?.taskId || "";
+        if (!taskId) continue;
+        indexedRunCountsByTaskId.set(taskId, (indexedRunCountsByTaskId.get(taskId) || 0) + 1);
+      }
+
       // Mark older duplicate runs as not-resumable before entering the loop.
       // This must consider the full paused+resumable set so historical siblings
       // outside the current startup cohort are still retired when a newer run wins.
@@ -10082,7 +10094,7 @@ export class WorkflowEngine extends EventEmitter {
             : (watchdogDecision || this._chooseRetryModeFromDetail(detail, {
                 fallbackMode: "from_scratch",
               }));
-          const detailedRun = this.getRunDetail(run.runId) || run;
+          const detailedRun = this.getRunDetail(run.runId, { decorate: false }) || { ...run, detail };
           const createTasksGuard = this._resolvePendingCreateTasksGuard(detailedRun, def);
           if (createTasksGuard && !createTasksGuard.safeResume) {
             console.warn(`${TAG} Skipping run ${run.runId}: ${createTasksGuard.resumeBlockedMessage}`);

package/workflow/workflow-nodes/actions.mjs

@@ -5169,7 +5169,7 @@ registerNodeType("action.run_agent", {
         for (let idx = 1; idx <= configuredCandidateCount; idx += 1) {
           const candidateBranch =
             `${safeBranchPart(currentBranch)}-cand-${idx}-${batchToken}`.slice(0, 120);
-          execSync(`git checkout -B "${candidateBranch}" "${baselineHead}"`, {
+          execFileSync("git", ["checkout", "-B", candidateBranch, baselineHead], {
             cwd,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf8",
@@ -5252,7 +5252,7 @@ registerNodeType("action.run_agent", {
       }
 
       const selectedHead = selected.hasCommit ? selected.head : baselineHead;
-      execSync(`git checkout -B "${currentBranch}" "${selectedHead}"`, {
+      execFileSync("git", ["checkout", "-B", currentBranch, selectedHead], {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf8",
@@ -5261,7 +5261,7 @@ registerNodeType("action.run_agent", {
       for (const candidate of candidateRuns) {
         if (!candidate?.branch) continue;
         try {
-          execSync(`git branch -D "${candidate.branch}"`, {
+          execFileSync("git", ["branch", "-D", candidate.branch], {
             cwd,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf8",
@@ -7438,6 +7438,16 @@ registerNodeType("action.materialize_planner_tasks", {
       }
       if (Array.isArray(task.tags) && task.tags.length > 0) payload.tags = task.tags;
       if (task.baseBranch) payload.baseBranch = task.baseBranch;
+      if (task.sprintId) {
+        payload.sprintId = task.sprintId;
+      }
+      if (task.epicId) {
+        payload.epicId = task.epicId;
+      }
+      if (Array.isArray(task.dependencyTaskIds) && task.dependencyTaskIds.length > 0) {
+        payload.dependencyTaskIds = task.dependencyTaskIds;
+        payload.dependsOn = task.dependencyTaskIds;
+      }
       if (task.draft || String(status || "").trim().toLowerCase() === "draft") {
         payload.draft = true;
       }
@@ -7472,16 +7482,38 @@ registerNodeType("action.materialize_planner_tasks", {
         run_id: String(ctx?.runId || ctx?.data?._runId || "").trim() || null,
         acceptance_criteria: task.acceptanceCriteria,
         verification: task.verification,
+        implementation_steps: Array.isArray(task.implementationSteps) ? task.implementationSteps : [],
+        files: Array.isArray(task.files) ? task.files : [],
+        tests: Array.isArray(task.tests) ? task.tests : [],
+        api_contracts: Array.isArray(task.apiContracts) ? task.apiContracts : [],
         task_key: task.taskKey || null,
         parent_task_key: task.parentTaskKey || null,
         parent_task_id: task.parentTaskId || null,
         depends_on_task_keys: Array.isArray(task.dependencyTaskKeys) ? task.dependencyTaskKeys : [],
         depends_on_task_ids: Array.isArray(task.dependencyTaskIds) ? task.dependencyTaskIds : [],
+        sprint_id: task.sprintId || null,
+        epic_id: task.epicId || null,
         decomposition_kind: task.decompositionKind || null,
         spawn_when: task.spawnWhen || null,
         merge_back_policy: task.mergeBackPolicy || null,
         dedupe_key: plannerDedupeKey,
       };
+      const plannerWorkflowRunId = String(ctx?.runId || ctx?.data?.runId || ctx?.data?._runId || "").trim() || null;
+      existingMeta.plannerProvenance = {
+        plannerRunId: plannerWorkflowRunId,
+        workflowRunId: plannerWorkflowRunId,
+        plannerNodeId,
+        sourceNodeId: node.id,
+        sourceNodeType: "action.materialize_planner_tasks",
+        sourceLabels: ["workflow", "planner", "materialize_planner_tasks"],
+        generatedAt:
+          typeof existingMeta.plannerProvenance?.generatedAt === "string"
+            ? existingMeta.plannerProvenance.generatedAt
+            : new Date().toISOString(),
+        dedupeKey: plannerDedupeKey,
+        materializationFingerprint,
+        taskIndex: task.index,
+      };
       payload.meta = existingMeta;
       const existingTaskByProvenance = Array.isArray(existingRows)
         ? existingRows.find((candidate) => {

package/workflow/workflow-nodes/agent.mjs

@@ -369,14 +369,22 @@ export const CALIBRATED_MAX_RISK_WITHOUT_HUMAN = "medium";
 export const STRICT_TASK_PLANNER_TASK_COUNT = 8;
 const TASK_PLANNER_REQUIRED_TOP_LEVEL_KEYS = ["tasks"];
 const TASK_PLANNER_REQUIRED_TASK_FIELDS = [
+  "task_key",
   "title",
   "description",
+  "implementation_steps",
+  "files",
+  "tests",
+  "api_contracts",
   "acceptance_criteria",
   "verification",
   "repo_areas",
   "impact",
   "confidence",
   "risk",
+  "estimated_effort",
+  "why_now",
+  "kill_criteria",
 ];
 const TASK_PLANNER_ALLOWED_ESTIMATED_EFFORT = ["small", "medium", "large"];
 const PLANNER_SCORE_MODE_RATIO = "ratio";
@@ -557,10 +565,18 @@ export function normalizePlannerTaskForCreation(task, index, options = {}) {
   const strict = options?.strict === true;
 
   const normalizeStringList = (value) => {
-    if (!Array.isArray(value)) return [];
-    return value
-      .map((entry) => String(entry || "").trim())
-      .filter(Boolean);
+    if (Array.isArray(value)) {
+      return value
+        .map((entry) => String(entry || "").trim())
+        .filter(Boolean);
+    }
+    if (typeof value === "string") {
+      return value
+        .split(/\r?\n|,/)
+        .map((entry) => entry.replace(/^[-*]\s+/, "").trim())
+        .filter(Boolean);
+    }
+    return [];
   };
   const normalizeRepoAreas = (value) => {
     const list = normalizeStringList(value);
@@ -590,12 +606,24 @@ export function normalizePlannerTaskForCreation(task, index, options = {}) {
   const lines = [];
   const description = String(task.description || "").trim();
   if (description) lines.push(description);
+  const implementationSteps = strict
+    ? validateStrictPlannerRequiredField("implementation_steps", task.implementation_steps || task.implementationSteps, { type: "array" })
+    : normalizeStringList(task.implementation_steps || task.implementationSteps);
   const acceptanceCriteria = strict
-    ? validateStrictPlannerRequiredField("acceptance_criteria", task.acceptance_criteria, { type: "array" })
-    : normalizeStringList(task.acceptance_criteria);
+    ? validateStrictPlannerRequiredField("acceptance_criteria", task.acceptance_criteria || task.acceptanceCriteria, { type: "array" })
+    : normalizeStringList(task.acceptance_criteria || task.acceptanceCriteria);
   const verification = strict
     ? validateStrictPlannerRequiredField("verification", task.verification, { type: "array" })
     : normalizeStringList(task.verification);
+  const files = strict
+    ? validateStrictPlannerRequiredField("files", task.files || task.file_paths || task.filePaths || task.paths, { type: "array" })
+    : normalizeStringList(task.files || task.file_paths || task.filePaths || task.paths);
+  const tests = strict
+    ? validateStrictPlannerRequiredField("tests", task.tests || task.test_commands || task.testCommands, { type: "array" })
+    : normalizeStringList(task.tests || task.test_commands || task.testCommands);
+  const apiContracts = strict
+    ? validateStrictPlannerRequiredField("api_contracts", task.api_contracts || task.apiContracts, { type: "array" })
+    : normalizeStringList(task.api_contracts || task.apiContracts);
   const repoAreas = normalizeRepoAreas(
     strict
       ? validateStrictPlannerRequiredField("repo_areas", task.repo_areas || task.repoAreas, { type: "array" })
@@ -671,13 +699,18 @@ export function normalizePlannerTaskForCreation(task, index, options = {}) {
     for (const item of items) lines.push(`- ${item}`);
   };
 
-  appendList("Implementation Steps", task.implementation_steps);
+  appendList("Implementation Steps", implementationSteps);
+  appendList("Files", files);
+  appendList("Tests", tests);
+  appendList("API Contracts", apiContracts);
   appendList("Acceptance Criteria", acceptanceCriteria);
   appendList("Verification", verification);
 
   const baseBranch = String(task.base_branch || "").trim();
   const workspace = String(task.workspace || "").trim();
   const repository = String(task.repository || task.repo || "").trim();
+  const sprintId = String(task.sprint_id || task.sprintId || task.sprint || "").trim();
+  const epicId = String(task.epic_id || task.epicId || task.epic || "").trim();
   const repositories = Array.isArray(task.repositories)
     ? task.repositories.map((entry) => String(entry || "").trim()).filter(Boolean)
     : [];
@@ -707,6 +740,10 @@ export function normalizePlannerTaskForCreation(task, index, options = {}) {
     requestedStatus: requestedStatus || null,
     acceptanceCriteria,
     verification,
+    implementationSteps,
+    files,
+    tests,
+    apiContracts,
     repoAreas,
     impact,
     confidence,
@@ -719,6 +756,8 @@ export function normalizePlannerTaskForCreation(task, index, options = {}) {
     parentTaskId,
     dependencyTaskKeys,
     dependencyTaskIds,
+    sprintId: sprintId || null,
+    epicId: epicId || null,
     decompositionKind,
     spawnWhen,
     mergeBackPolicy,
@@ -797,7 +836,7 @@ export function validateStrictTaskPlannerPayload(payload, options = {}) {
       return { ok: false, error: `${taskLabel}.description must be a non-empty string`, code: "invalid_field", taskIndex: i, field: "description" };
     }
 
-    const listFields = ["acceptance_criteria", "verification", "repo_areas"];
+    const listFields = ["implementation_steps", "files", "tests", "api_contracts", "acceptance_criteria", "verification", "repo_areas", "kill_criteria"];
     for (const field of listFields) {
       const value = task[field];
       if (!Array.isArray(value) || value.length === 0 || value.some((entry) => String(entry || "").trim() === "")) {
@@ -1731,6 +1770,9 @@ registerNodeType("agent.run_planner", {
         ].filter(Boolean).join("\n\n")}\n\n`
         : "\n") +
       `Your response MUST be a single fenced JSON block with shape { "tasks": [...] }.\n` +
+      `Each task object MUST include: task_key, title, description, implementation_steps, files, tests, api_contracts, acceptance_criteria, verification, repo_areas, impact, confidence, risk, estimated_effort, why_now, and kill_criteria.\n` +
+      `Use sprint_id and epic_id when the planned work belongs to a sprint or epic. Use parent_task_key and depends_on_task_keys to encode DAG/dependency order between generated tasks.\n` +
+      `Descriptions must be ticket-ready: describe the current problem, exact scope, implementation approach, and user-visible outcome in enough detail for an executor to work without rediscovering intent.\n` +
       `Do NOT include status updates, analysis notes, tool commentary, questions, or prose outside the JSON block.\n` +
       `The downstream system will parse your output as JSON — any extra text will cause task creation to fail.`;
     const promptText = basePrompt

package/workflow-templates/agents.mjs

@@ -503,9 +503,27 @@ export const BACKEND_AGENT_TEMPLATE = (() => {
   const mainValidation = embedSubWorkflow(VALIDATION_GATE_SUB, "main-");
   const retryValidation = embedSubWorkflow(VALIDATION_GATE_SUB, "retry-");
   const retry2Validation = embedSubWorkflow(VALIDATION_GATE_SUB, "retry2-");
-  const mainPrHandoff = embedSubWorkflow(PR_CHECK_HANDOFF_SUB, "main-");
-  const retryPrHandoff = embedSubWorkflow(PR_CHECK_HANDOFF_SUB, "retry-");
-  const retry2PrHandoff = embedSubWorkflow(PR_CHECK_HANDOFF_SUB, "retry2-");
+  const mainPrHandoff = embedSubWorkflow(PR_CHECK_HANDOFF_SUB, "main-", {
+    nodeOverrides: {
+      "pr-ok": {
+        expression: "Boolean($ctx.getNodeOutput('create-pr')?.prNumber || $ctx.getNodeOutput('create-pr')?.prUrl)",
+      },
+    },
+  });
+  const retryPrHandoff = embedSubWorkflow(PR_CHECK_HANDOFF_SUB, "retry-", {
+    nodeOverrides: {
+      "pr-ok": {
+        expression: "Boolean($ctx.getNodeOutput('create-pr-retry')?.prNumber || $ctx.getNodeOutput('create-pr-retry')?.prUrl)",
+      },
+    },
+  });
+  const retry2PrHandoff = embedSubWorkflow(PR_CHECK_HANDOFF_SUB, "retry2-", {
+    nodeOverrides: {
+      "pr-ok": {
+        expression: "Boolean($ctx.getNodeOutput('create-pr-retry2')?.prNumber || $ctx.getNodeOutput('create-pr-retry2')?.prUrl)",
+      },
+    },
+  });
 
   return {
     id: "template-backend-agent",

package/workflow-templates/planning.mjs

@@ -76,7 +76,7 @@ export const TASK_PLANNER_TEMPLATE = {
     node("materialize-tasks", "action.materialize_planner_tasks", "Create Tasks", {
       plannerNodeId: "run-planner",
       maxTasks: "{{taskCount}}",
-      status: "draft",
+      status: "todo",
       dedup: true,
       failOnZero: true,
       minCreated: 1,
@@ -929,7 +929,8 @@ Structured context:
 
 Rules:
 - Generate at most {{maxFollowupTasks}} tasks
-- Include fields: title, description, implementation_steps, acceptance_criteria, verification, priority, tags, base_branch, impact, confidence, risk, estimated_effort, repo_areas, why_now, kill_criteria
+- Include fields: task_key, title, description, implementation_steps, files, tests, api_contracts, acceptance_criteria, verification, priority, tags, base_branch, impact, confidence, risk, estimated_effort, repo_areas, why_now, kill_criteria
+- Use sprint_id, epic_id, parent_task_key, and depends_on_task_keys when the work belongs in an existing sprint/epic or has DAG ordering
 - Use trend deltas from the summary artifact to justify urgency and avoid parse errors
 - Keep tasks implementation-ready and avoid duplicates
 - Return only JSON`,
@@ -993,5 +994,3 @@ Rules:
   },
 };
 
-
-

package/workflow-templates/task-batch.mjs

@@ -125,7 +125,7 @@ export const TASK_BATCH_PROCESSOR_TEMPLATE = {
   recommended: true,
   trigger: "trigger.task_available",
   variables: {
-    maxConcurrent: 3,
+    maxConcurrent: 5,
     pollStatus: "todo",
     maxBatchSize: 10,
     subWorkflow: "template-task-lifecycle",