bosun 0.41.4 → 0.41.6

package/infra/monitor.mjs

@@ -663,6 +663,7 @@ async function ensureWorkflowAutomationEngine() {
             "template-task-lifecycle",
             "template-task-finalization-guard",
             "template-agent-session-monitor",
+            "template-github-kanban-sync",
           ],
         });
         if (Number(reconcile?.autoUpdated || 0) > 0) {
@@ -673,6 +674,15 @@ async function ensureWorkflowAutomationEngine() {
                 : ""),
           );
         }
+        if (
+          typeof engine.load === "function" &&
+          (Number(reconcile?.autoUpdated || 0) > 0 ||
+            Number(reconcile?.metadataUpdated || 0) > 0 ||
+            (Array.isArray(reconcile?.updatedWorkflowIds) &&
+              reconcile.updatedWorkflowIds.length > 0))
+        ) {
+          engine.load();
+        }
       }
       for (const summary of engine.list?.() || []) {
         const installedFrom = String(summary?.metadata?.installedFrom || "").trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.41.4",
+  "version": "0.41.6",
   "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 Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache-2.0",

package/ui/demo-defaults.js

@@ -18432,7 +18432,7 @@
         "defaultTargetBranch": "origin/main",
         "taskTimeoutMs": 21600000,
         "prePrValidationEnabled": true,
-        "prePrValidationCommand": "npm run prepush:check",
+        "prePrValidationCommand": "auto",
         "autoMergeOnCreate": false,
         "autoMergeMethod": "squash",
         "maxRetries": 2,
@@ -18836,6 +18836,7 @@
           "label": "Pre-PR Validation",
           "config": {
             "command": "{{prePrValidationCommand}}",
+            "commandType": "qualityGate",
             "cwd": "{{worktreePath}}",
             "failOnError": false
           },
@@ -38231,7 +38232,7 @@
         "defaultTargetBranch": "origin/main",
         "taskTimeoutMs": 21600000,
         "prePrValidationEnabled": true,
-        "prePrValidationCommand": "npm run prepush:check",
+        "prePrValidationCommand": "auto",
         "autoMergeOnCreate": false,
         "autoMergeMethod": "squash",
         "maxRetries": 2,
@@ -38604,6 +38605,7 @@
           "label": "Pre-PR Validation",
           "config": {
             "command": "{{prePrValidationCommand}}",
+            "commandType": "qualityGate",
             "cwd": "{{worktreePath}}",
             "failOnError": false
           },

package/workflow/project-detection.mjs

@@ -2,7 +2,8 @@
  * project-detection.mjs — Auto-detect project type, build tools, and commands.
  *
  * Scans a directory for manifest files and infers the project's language,
- * package manager, and standard commands (test, build, lint, syntax-check).
+ * package manager, and standard commands (test, build, lint, syntax-check,
+ * quality gate).
  * Handles mono-repos by detecting multiple stacks in a single root.
  */
 
@@ -360,6 +361,58 @@ function markerExists(rootDir, marker) {
   return existsSync(resolve(rootDir, marker));
 }
 
+function buildPackageScriptCommand(packageManager, scriptName) {
+  const pm = String(packageManager || "npm").trim().toLowerCase();
+  if (pm === "yarn") return `yarn ${scriptName}`;
+  if (pm === "pnpm") return `pnpm ${scriptName}`;
+  if (pm === "bun") return `bun run ${scriptName}`;
+  return `npm run ${scriptName}`;
+}
+
+function readMakefile(rootDir) {
+  for (const name of ["Makefile", "makefile", "GNUmakefile"]) {
+    try {
+      return readFileSync(resolve(rootDir, name), "utf8");
+    } catch {}
+  }
+  return "";
+}
+
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function findMakeTarget(rootDir, targetNames = []) {
+  const makefile = readMakefile(rootDir);
+  if (!makefile) return "";
+  for (const name of targetNames) {
+    const pattern = new RegExp(`^${escapeRegExp(name)}\\s*:`, "m");
+    if (pattern.test(makefile)) return name;
+  }
+  return "";
+}
+
+function detectQualityGateCommand(rootDir, commands = {}, options = {}) {
+  const packageManager = String(options.packageManager || "").trim().toLowerCase();
+  const scripts = readPackageJsonScripts(rootDir);
+  for (const scriptName of ["prepush:check", "prepush-check", "prepush", "pre-push", "verify", "validate", "check"]) {
+    if (typeof scripts[scriptName] === "string" && scripts[scriptName].trim()) {
+      return buildPackageScriptCommand(packageManager, scriptName);
+    }
+  }
+
+  if (existsSync(resolve(rootDir, ".githooks", "pre-push"))) {
+    return "bash .githooks/pre-push";
+  }
+
+  const makeTarget = findMakeTarget(rootDir, ["prepush", "pre-push", "verify", "validate", "check"]);
+  if (makeTarget) {
+    return `make ${makeTarget}`;
+  }
+
+  return commands.test || commands.lint || commands.build || commands.syntaxCheck || "";
+}
+
 // ── Public API ───────────────────────────────────────────────────────────────
 
 /**
@@ -388,6 +441,7 @@ function markerExists(rootDir, marker) {
  * @property {string} lint          - Lint command
  * @property {string} syntaxCheck   - Syntax/compile check command
  * @property {string} [typeCheck]   - Type-check command
+ * @property {string} [qualityGate] - Pre-push / pre-PR validation command
  * @property {string} [testFramework] - Detected test framework name
  */
 export function detectProjectStack(rootDir) {
@@ -402,6 +456,7 @@ export function detectProjectStack(rootDir) {
 
     const pm = def.detectPackageManager(rootDir);
     const commands = def.detectCommands(rootDir);
+    commands.qualityGate = detectQualityGateCommand(rootDir, commands, { packageManager: pm });
     const frameworks = def.detectFrameworks(rootDir);
     stacks.push({
       id: def.id,
@@ -438,6 +493,7 @@ export function getCommandPresets(detected) {
     build: [],
     lint: [],
     syntaxCheck: [],
+    qualityGate: [],
   };
 
   // If we have a detected stack, put its commands first as "Detected" options
@@ -448,6 +504,7 @@ export function getCommandPresets(detected) {
     if (cmds.build) presets.build.push({ label: `${label}: ${cmds.build}`, value: cmds.build, detected: true });
     if (cmds.lint) presets.lint.push({ label: `${label}: ${cmds.lint}`, value: cmds.lint, detected: true });
     if (cmds.syntaxCheck) presets.syntaxCheck.push({ label: `${label}: ${cmds.syntaxCheck}`, value: cmds.syntaxCheck, detected: true });
+    if (cmds.qualityGate) presets.qualityGate.push({ label: `${label}: ${cmds.qualityGate}`, value: cmds.qualityGate, detected: true });
   }
 
   // Add additional detected stacks (monorepo)
@@ -459,6 +516,7 @@ export function getCommandPresets(detected) {
       if (cmds.build) presets.build.push({ label: `${label}: ${cmds.build}`, value: cmds.build, detected: true });
       if (cmds.lint) presets.lint.push({ label: `${label}: ${cmds.lint}`, value: cmds.lint, detected: true });
       if (cmds.syntaxCheck) presets.syntaxCheck.push({ label: `${label}: ${cmds.syntaxCheck}`, value: cmds.syntaxCheck, detected: true });
+      if (cmds.qualityGate) presets.qualityGate.push({ label: `${label}: ${cmds.qualityGate}`, value: cmds.qualityGate, detected: true });
     }
   }
 
@@ -521,6 +579,13 @@ export function getCommandPresets(detected) {
       { label: "Ruby — ruby -c", value: "ruby -c" },
       { label: "PHP — php -l", value: "php -l" },
     ],
+    qualityGate: [
+      { label: "Node.js — npm run prepush:check", value: "npm run prepush:check" },
+      { label: "Node.js — pnpm prepush:check", value: "pnpm prepush:check" },
+      { label: "Repository hook — bash .githooks/pre-push", value: "bash .githooks/pre-push" },
+      { label: "Go — go test ./...", value: "go test ./..." },
+      { label: "Make — make test", value: "make test" },
+    ],
   };
 
   // Merge: skip any universal presets whose value already appears in detected
@@ -541,7 +606,7 @@ export function getCommandPresets(detected) {
  * If the value isn't "auto", returns it unchanged.
  *
  * @param {string} value - The command value (may be "auto" or an actual command)
- * @param {string} commandType - One of "test", "build", "lint", "syntaxCheck"
+ * @param {string} commandType - One of "test", "build", "lint", "syntaxCheck", "qualityGate"
  * @param {string} rootDir - Project root for detection
  * @returns {string} The resolved command
  */
@@ -552,7 +617,7 @@ export function resolveAutoCommand(value, commandType, rootDir) {
 }
 
 function emptyCommands() {
-  return { test: "", build: "", lint: "", syntaxCheck: "", typeCheck: "" };
+  return { test: "", build: "", lint: "", syntaxCheck: "", typeCheck: "", qualityGate: "" };
 }
 
 // Re-export the stack definitions for introspection

package/workflow/workflow-engine.mjs

@@ -41,6 +41,7 @@ import {
   ensureTestRuntimeSandbox,
   resolvePathForTestRuntime,
 } from "../infra/test-runtime.mjs";
+import { getTemplate } from "./workflow-templates.mjs";
 
 // Lazy-loaded workspace manager for workspace-aware scheduling
 let _workspaceManagerMod = null;
@@ -744,6 +745,34 @@ export class WorkflowEngine extends EventEmitter {
     return normalized || "";
   }
 
+  _resolveTemplateDefaultVariable(def, key) {
+    if (!def || typeof def !== "object") return undefined;
+    if (def?.metadata?.templateState?.isCustomized === true) return undefined;
+    const templateId = String(def?.metadata?.installedFrom || "").trim();
+    if (!templateId) return undefined;
+    const template = getTemplate(templateId);
+    if (!template?.variables || typeof template.variables !== "object") return undefined;
+    return Object.prototype.hasOwnProperty.call(template.variables, key)
+      ? template.variables[key]
+      : undefined;
+  }
+
+  _applyResumeInputMigrations(def, data = {}) {
+    if (!data || typeof data !== "object") return data;
+    const next = { ...data };
+    const templateId = String(def?.metadata?.installedFrom || "").trim();
+    if (templateId === "template-task-lifecycle") {
+      const currentValue = next.prePrValidationCommand;
+      const nextDefault =
+        this._resolveTemplateDefaultVariable(def, "prePrValidationCommand")
+        ?? def?.variables?.prePrValidationCommand;
+      if (currentValue === "npm run prepush:check" && nextDefault === "auto") {
+        next.prePrValidationCommand = nextDefault;
+      }
+    }
+    return next;
+  }
+
   _resolveTaskTraceContext(ctx, node = null, result = null) {
     const nodeTaskIdCandidate = (() => {
       if (!node?.config || typeof node.config !== "object") return "";
@@ -1220,10 +1249,13 @@ export class WorkflowEngine extends EventEmitter {
    * @private
    */
   async _executeInner(def, workflowId, inputData, opts) {
-
-    const ctx = new WorkflowContext({
+    const initialData = this._applyResumeInputMigrations(def, {
       ...def.variables,
       ...inputData,
+    });
+
+    const ctx = new WorkflowContext({
+      ...initialData,
       _workflowId: workflowId,
       _workflowName: def.name,
     });
@@ -1347,6 +1379,7 @@ export class WorkflowEngine extends EventEmitter {
     const originalData = { ...(originalRun.detail?.data || {}) };
     delete originalData._workflowId;
     delete originalData._workflowName;
+    const retryData = this._applyResumeInputMigrations(def, originalData);
 
     this.emit("run:retry", {
       originalRunId: runId,
@@ -1356,7 +1389,7 @@ export class WorkflowEngine extends EventEmitter {
     });
 
     if (mode === "from_scratch") {
-      const ctx = await this.execute(workflowId, originalData, {
+      const ctx = await this.execute(workflowId, retryData, {
         ...retryOpts,
         _isRetry: true,
         _originalRunId: runId,
@@ -1373,7 +1406,7 @@ export class WorkflowEngine extends EventEmitter {
     // Build a fresh context but pre-seed completed node outputs.
     const ctx = new WorkflowContext({
       ...def.variables,
-      ...originalData,
+      ...retryData,
       _workflowId: workflowId,
       _workflowName: def.name,
       _retryOf: runId,
@@ -3240,7 +3273,9 @@ export class WorkflowEngine extends EventEmitter {
       const runDetailCache = new Map(); // runId → parsed detail
       const latestByTaskId = new Map(); // taskId → run entry (highest startedAt)
 
-      for (const run of runs) {
+      const allRuns = this._readRunIndex();
+
+      for (const run of allRuns) {
         const dp = resolve(this.runsDir, `${run.runId}.json`);
         if (!existsSync(dp)) continue;
         try {
@@ -3435,7 +3470,34 @@ export function getWorkflowEngine(opts = {}) {
     _defaultEngine = new WorkflowEngine(engineOpts);
     _defaultEngine.load();
   } else if (opts && typeof opts === "object") {
-    if (opts.services && typeof opts.services === "object") {
+    const workflowDir = typeof opts.workflowDir === "string" && opts.workflowDir
+      ? resolve(opts.workflowDir)
+      : null;
+    const runsDir = typeof opts.runsDir === "string" && opts.runsDir
+      ? resolve(opts.runsDir)
+      : null;
+    const configDir = typeof opts.configDir === "string" && opts.configDir
+      ? resolve(opts.configDir)
+      : null;
+    const shouldReinitialize =
+      (workflowDir && workflowDir !== _defaultEngine.workflowDir) ||
+      (runsDir && runsDir !== _defaultEngine.runsDir) ||
+      (configDir && configDir !== resolve(_defaultEngine._configDir || process.cwd()));
+
+    if (shouldReinitialize) {
+      const engineOpts = {
+        ...opts,
+        services: mergeWorkflowServices(_defaultEngine.services, opts.services || {}),
+      };
+      if (
+        engineOpts.detectInterruptedRuns === undefined &&
+        shouldDisableDefaultInterruptedRunDetection(engineOpts)
+      ) {
+        engineOpts.detectInterruptedRuns = false;
+      }
+      _defaultEngine = new WorkflowEngine(engineOpts);
+      _defaultEngine.load();
+    } else if (opts.services && typeof opts.services === "object") {
       _defaultEngine.services = mergeWorkflowServices(
         _defaultEngine.services,
         opts.services,

package/workflow/workflow-nodes.mjs

@@ -44,6 +44,7 @@ import {
   loadWorkflowContract,
   validateWorkflowContract,
 } from "./workflow-contract.mjs";
+import { resolveAutoCommand } from "./project-detection.mjs";
 import { loadConfig } from "../config/config.mjs";
 import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
 import { clearBlockedWorktreeIdentity, normalizeBaseBranch } from "../git/git-safety.mjs";
@@ -2509,10 +2510,15 @@ registerBuiltinNodeType("action.run_agent", {
           ) || "",
         ).trim();
         const sessionId = resolvedSessionId || null;
+        const storedSessionOwnerNodeId = String(ctx.data?._agentSessionNodeId || "").trim() || null;
+        const hasExplicitSessionOverride =
+          options.sessionId != null
+          || node.config?.sessionId != null
+          || (sessionId && !storedSessionOwnerNodeId);
+        const canContinueStoredSession =
+          !!sessionId && (hasExplicitSessionOverride || storedSessionOwnerNodeId === node.id);
         const explicitTaskKey = String(ctx.resolve(node.config?.taskKey || "") || "").trim();
-        const fallbackTaskKey =
-          sessionId ||
-          `${ctx.data?._workflowId || "workflow"}:${ctx.id}:${node.id}`;
+        const fallbackTaskKey = `${ctx.data?._workflowId || "workflow"}:${ctx.id}:${node.id}`;
         const recoveryTaskKey = options.taskKey || explicitTaskKey || fallbackTaskKey;
         const autoRecover = options.autoRecover ?? (node.config?.autoRecover !== false);
         const continueOnSession =
@@ -2612,7 +2618,7 @@ registerBuiltinNodeType("action.run_agent", {
           if (
             autoRecover &&
             continueOnSession &&
-            sessionId &&
+            canContinueStoredSession &&
             typeof agentPool.continueSession === "function"
           ) {
             ctx.log(node.id, `${passLabel} Recovery: continuing existing session ${sessionId}`.trim());
@@ -2706,6 +2712,8 @@ registerBuiltinNodeType("action.run_agent", {
         if (persistSession && threadId) {
           ctx.data.sessionId = threadId;
           ctx.data.threadId = threadId;
+          ctx.data._agentSessionNodeId = node.id;
+          ctx.data._agentSessionTaskKey = recoveryTaskKey;
         }
         const digest = buildAgentExecutionDigest(result, streamLines, maxRetainedEvents);
 
@@ -2988,6 +2996,11 @@ registerBuiltinNodeType("action.run_command", {
       env: { type: "object", description: "Environment variables passed to the command (supports templates)", additionalProperties: true },
       timeoutMs: { type: "number", default: 300000 },
       shell: { type: "string", default: "auto", enum: ["auto", "bash", "pwsh", "cmd"] },
+      commandType: {
+        type: "string",
+        enum: ["test", "build", "lint", "syntaxCheck", "qualityGate"],
+        description: "Optional auto-resolution category when command is set to 'auto'",
+      },
       captureOutput: { type: "boolean", default: true },
       parseJson: { type: "boolean", default: false, description: "Parse JSON output automatically" },
       failOnError: { type: "boolean", default: false, description: "Throw on non-zero exit status (enables workflow retries)" },
@@ -2996,8 +3009,13 @@ registerBuiltinNodeType("action.run_command", {
   },
   async execute(node, ctx) {
     const resolvedCommand = ctx.resolve(node.config?.command || "");
-    const command = normalizeLegacyWorkflowCommand(resolvedCommand);
     const cwd = ctx.resolve(node.config?.cwd || ctx.data?.worktreePath || process.cwd());
+    const commandType = typeof node.config?.commandType === "string" ? node.config.commandType.trim() : "";
+    const autoCommandRoot = ctx.resolve(ctx.data?.repoRoot || cwd);
+    const autoResolvedCommand = commandType
+      ? resolveAutoCommand(String(resolvedCommand || ""), commandType, autoCommandRoot)
+      : resolvedCommand;
+    const command = normalizeLegacyWorkflowCommand(autoResolvedCommand);
     const resolvedEnvConfig = resolveWorkflowNodeValue(node.config?.env ?? {}, ctx);
     const commandEnv = { ...process.env };
     if (resolvedEnvConfig && typeof resolvedEnvConfig === "object" && !Array.isArray(resolvedEnvConfig)) {
@@ -3040,7 +3058,19 @@ registerBuiltinNodeType("action.run_command", {
     };
     const usedArgv = commandArgs.length > 0;
 
-    if (command !== resolvedCommand) {
+    if (!command.trim()) {
+      const reason =
+        String(resolvedCommand || "").trim().toLowerCase() === "auto" && commandType
+          ? `No ${commandType} command detected for ${autoCommandRoot || cwd}`
+          : "No command configured";
+      ctx.log(node.id, reason);
+      return { success: false, output: "", stderr: "", exitCode: null, error: reason };
+    }
+
+    if (autoResolvedCommand !== resolvedCommand) {
+      ctx.log(node.id, `Resolved auto ${commandType} command: ${autoResolvedCommand}`);
+    }
+    if (command !== autoResolvedCommand) {
       ctx.log(node.id, `Normalized legacy command for portability: ${command}`);
     }
     ctx.log(node.id, `Running: ${usedArgv ? `${command} ${commandArgs.join(" ")}`.trim() : command}`);

package/workflow/workflow-templates.mjs

@@ -454,13 +454,32 @@ function createWorkflowTemplateState({ getTemplate, cloneTemplateDefinition }) {
     return def;
   }
 
-  function makeUpdatedWorkflowFromTemplate(existing, template, mode = "replace") {
+  function applyLegacyTemplateVariableMigrations(existing, template, variables, opts = {}) {
+    if (!variables || typeof variables !== "object") return variables;
+    const assumeUncustomized = opts.assumeUncustomized === true;
+    if (!assumeUncustomized && existing?.metadata?.templateState?.isCustomized === true) {
+      return variables;
+    }
+
+    const templateId = String(template?.id || existing?.metadata?.installedFrom || "").trim();
+    if (templateId === "template-task-lifecycle") {
+      const currentValue = existing?.variables?.prePrValidationCommand;
+      const nextDefault = template?.variables?.prePrValidationCommand;
+      if (currentValue === "npm run prepush:check" && nextDefault === "auto") {
+        variables.prePrValidationCommand = nextDefault;
+      }
+    }
+
+    return variables;
+  }
+
+  function makeUpdatedWorkflowFromTemplate(existing, template, mode = "replace", opts = {}) {
     const templateClone = cloneTemplateDefinition(template);
     const nowIso = new Date().toISOString();
-    const mergedVariables = {
+    const mergedVariables = applyLegacyTemplateVariableMigrations(existing, templateClone, {
       ...(templateClone.variables || {}),
       ...(existing.variables || {}),
-    };
+    }, opts);
     const next = {
       ...templateClone,
       id: mode === "copy" ? randomUUID() : existing.id,
@@ -500,7 +519,9 @@ function createWorkflowTemplateState({ getTemplate, cloneTemplateDefinition }) {
       throw new Error("Workflow has custom changes; pass force=true to replace it");
     }
 
-    const next = makeUpdatedWorkflowFromTemplate(hydrated, template, mode);
+    const next = makeUpdatedWorkflowFromTemplate(hydrated, template, mode, {
+      assumeUncustomized: opts.assumeUncustomized === true,
+    });
     return engine.save(next);
   }
 
@@ -563,8 +584,13 @@ function createWorkflowTemplateState({ getTemplate, cloneTemplateDefinition }) {
 
         const templateId = String(state.templateId || "").trim();
         const shouldForceUpdate = templateId && forceUpdateTemplateIds.has(templateId);
+        const assumeUncustomized = previousState?.isCustomized !== true;
         if (shouldForceUpdate) {
-          const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
+          const saved = updateWorkflowFromTemplate(engine, def.id, {
+            mode: "replace",
+            force: true,
+            assumeUncustomized,
+          });
           result.autoUpdated += 1;
           result.updatedWorkflowIds.push(saved.id);
           result.forceUpdated.push(saved.id);
@@ -573,7 +599,11 @@ function createWorkflowTemplateState({ getTemplate, cloneTemplateDefinition }) {
 
         const wasCustomized = previousState?.isCustomized === true;
         if (autoUpdateUnmodified && state.updateAvailable === true && !wasCustomized) {
-          const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
+          const saved = updateWorkflowFromTemplate(engine, def.id, {
+            mode: "replace",
+            force: true,
+            assumeUncustomized: true,
+          });
           result.autoUpdated += 1;
           result.updatedWorkflowIds.push(saved.id);
         }
@@ -967,7 +997,7 @@ export function expandTemplateGroups(templateIds) {
  */
 /**
  * Classify a variable key into a command category if it matches.
- * Returns "test" | "build" | "lint" | "syntaxCheck" | null.
+ * Returns "test" | "build" | "lint" | "syntaxCheck" | "qualityGate" | null.
  */
 function classifyCommandVariable(key) {
   const k = String(key || "").toLowerCase();
@@ -975,6 +1005,7 @@ function classifyCommandVariable(key) {
   if (k.includes("buildcommand") || k.includes("build_command")) return "build";
   if (k.includes("lintcommand") || k.includes("lint_command") || k.includes("lintcmd")) return "lint";
   if (k.includes("syntaxcheck") || k.includes("syntax_check") || k.includes("typecheckcommand") || k.includes("type_check")) return "syntaxCheck";
+  if (k.includes("preprvalidationcommand") || k.includes("pre_pr_validation_command") || k.includes("qualitygatecommand") || k.includes("quality_gate_command")) return "qualityGate";
   return null;
 }
 
@@ -1058,6 +1089,7 @@ function inferVariableDescription(key, defaultValue) {
   if (classifyCommandVariable(normalized) === "build") return "Build command for your project. Auto-detected from project files when available.";
   if (classifyCommandVariable(normalized) === "lint") return "Lint/style check command. Auto-detected from project files when available.";
   if (classifyCommandVariable(normalized) === "syntaxCheck") return "Syntax/compile check command. Auto-detected from project files when available.";
+  if (classifyCommandVariable(normalized) === "qualityGate") return "Pre-PR validation command. Auto-detected from project files and repo hooks when available.";
   if (typeof defaultValue === "boolean") return "Toggle this setting on or off.";
   if (typeof defaultValue === "number") return "Numeric workflow setting.";
   return "";
@@ -1395,5 +1427,3 @@ export function installRecommendedTemplates(engine, overridesById = {}) {
 
 
 
-
-

package/workflow-templates/task-lifecycle.mjs

@@ -66,7 +66,7 @@ export const TASK_LIFECYCLE_TEMPLATE = {
     defaultTargetBranch: "origin/main",
     taskTimeoutMs: 21600000, // 6 hours
     prePrValidationEnabled: true,
-    prePrValidationCommand: "npm run prepush:check",
+    prePrValidationCommand: "auto",
     autoMergeOnCreate: false,
     autoMergeMethod: "squash",
     maxRetries: 2,
@@ -235,6 +235,7 @@ export const TASK_LIFECYCLE_TEMPLATE = {
     // ── SUCCESS PATH: Local quality gate before push/PR ──────────────────
     node("pre-pr-validation", "action.run_command", "Pre-PR Validation", {
       command: "{{prePrValidationCommand}}",
+      commandType: "qualityGate",
       cwd: "{{worktreePath}}",
       failOnError: false,
     }, { x: -120, y: 1940 }),
@@ -826,4 +827,3 @@ export const VE_ORCHESTRATOR_LITE_TEMPLATE = {
     },
   },
 };
-