lee-spec-kit 0.9.6 → 0.9.8

package/dist/index.js

@@ -167,6 +167,7 @@ var koCli = {
   "config.fullstackRepoRequired": "Multi \uD504\uB85C\uC81D\uD2B8\uB294 --component\uB85C \uB300\uC0C1 \uCEF4\uD3EC\uB10C\uD2B8\uB97C \uC9C0\uC815\uD574\uC57C \uD569\uB2C8\uB2E4.",
   "config.projectRootSet": "\u2705 {repo} projectRoot \uC124\uC815 \uC644\uB8CC: {path}",
   "config.projectRootSetSingle": "\u2705 projectRoot \uC124\uC815 \uC644\uB8CC: {path}",
+  "config.workflowUpdated": "\u2705 \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815\uC744 \uC5C5\uB370\uC774\uD2B8\uD588\uC2B5\uB2C8\uB2E4.",
   "update.start": "\u{1F4E6} \uD15C\uD50C\uB9BF \uC5C5\uB370\uC774\uD2B8\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4...",
   "update.langLabel": "\uC5B8\uC5B4",
   "update.typeLabel": "\uD0C0\uC785",
@@ -179,6 +180,7 @@ var koCli = {
   "update.fileUpdated": "{file} \uC5C5\uB370\uC774\uD2B8",
   "update.gitStatusUnavailable": "git \uC0C1\uD0DC\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. (git repo\uAC00 \uC544\uB2C8\uAC70\uB098 git \uC2E4\uD589 \uBD88\uAC00) --force\uB85C \uAC15\uC81C \uB36E\uC5B4\uC4F0\uAE30\uB97C \uC0AC\uC6A9\uD558\uC138\uC694.",
   "update.docsWorktreeDirty": "docs \uC791\uC5C5\uD2B8\uB9AC\uC5D0 \uBCC0\uACBD\uC0AC\uD56D\uC774 \uC788\uC5B4 update\uB97C \uC9C4\uD589\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uBCC0\uACBD\uC0AC\uD56D\uC744 \uCEE4\uBC0B/\uC2A4\uD0DC\uC2DC \uD6C4 \uB2E4\uC2DC \uC2E4\uD589\uD558\uAC70\uB098 --force\uB85C \uB36E\uC5B4\uC4F0\uC138\uC694.",
+  "update.legacyAutomationSafe": "\uAE30\uC874 \uD504\uB85C\uC81D\uD2B8\uB294 \uBA85\uC2DC\uC801\uC73C\uB85C \uC0AC\uC6A9\uD55C \uACBD\uC6B0\uAC00 \uC544\uB2C8\uBA74 \uC0C8 Task \uC704\uC784\uACFC Plan/Task \uAC80\uC218\uB97C \uAEBC\uC9C4 \uC0C1\uD0DC\uB85C \uC720\uC9C0\uD569\uB2C8\uB2E4. `npx lee-spec-kit config --interactive` \uB610\uB294 config \uD50C\uB798\uADF8\uB85C \uC124\uC815\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
   "init.selectLangPrompt": "\uBB38\uC11C \uC5B8\uC5B4\uB97C \uC120\uD0DD\uD558\uC138\uC694:",
   "init.currentDirectoryLabel": "\u{1F4CD} \uD604\uC7AC \uC704\uCE58",
   "init.gitDetected": "\u2705 Git \uB808\uD3EC\uC9C0\uD1A0\uB9AC \uAC10\uC9C0\uB428",
@@ -213,7 +215,7 @@ var koCli = {
   "init.choice.taskAgent.on": "\uC0AC\uC6A9 - \uAC01 Task \uAD6C\uD604\uC744 \uC704\uC784",
   "init.choice.taskAgent.off": "\uC0AC\uC6A9 \uC548 \uD568 - \uBA54\uC778 \uC5D0\uC774\uC804\uD2B8\uAC00 \uC9C1\uC811 \uAD6C\uD604",
   "init.prompt.reviews": "\uB3C5\uB9BD \uAC80\uC218 \uB2E8\uACC4\uB97C \uC120\uD0DD\uD558\uC138\uC694:",
-  "init.prompt.maxReviewRounds": "\uC794\uC5EC \uC704\uD5D8\uC744 \uAE30\uB85D\uD558\uACE0 \uACC4\uC18D\uD558\uAE30 \uC804 \uB9AC\uBDF0 \uC9C0\uC801 \uC790\uB3D9 \uBC18\uC601 \uCD5C\uB300 \uD69F\uC218:",
+  "init.prompt.maxReviewRounds": "\uC794\uC5EC \uC704\uD5D8\uC744 \uAE30\uB85D\uD558\uACE0 \uACC4\uC18D\uD558\uAE30 \uC804 fresh \uB9AC\uBDF0 \uCD5C\uB300 \uC2E4\uD589 \uD69F\uC218:",
   "init.choice.review.plan": "Plan",
   "init.choice.review.task": "Task",
   "init.choice.review.feature": "Feature",
@@ -239,7 +241,7 @@ var koCli = {
   "init.log.workflowLabel": "\uC6CC\uD06C\uD50C\uB85C\uC6B0",
   "init.log.taskAgentLabel": "Task \uAD6C\uD604",
   "init.log.reviewsLabel": "\uAC80\uC218",
-  "init.log.maxReviewRoundsLabel": "\uB9AC\uBDF0 \uC9C0\uC801 \uC790\uB3D9 \uBC18\uC601 \uD69F\uC218",
+  "init.log.maxReviewRoundsLabel": "fresh \uB9AC\uBDF0 \uCD5C\uB300 \uC2E4\uD589 \uD69F\uC218",
   "init.log.completionStrategyLabel": "\uB85C\uCEEC \uD1B5\uD569",
   "init.summary.taskAgent.on": "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8",
   "init.summary.taskAgent.off": "\uBA54\uC778 \uC5D0\uC774\uC804\uD2B8",
@@ -481,6 +483,7 @@ var enCli = {
   "config.fullstackRepoRequired": "For multi projects, specify a target component via `--component`.",
   "config.projectRootSet": "\u2705 {repo} projectRoot set: {path}",
   "config.projectRootSetSingle": "\u2705 projectRoot set: {path}",
+  "config.workflowUpdated": "\u2705 Workflow configuration updated.",
   "update.start": "\u{1F4E6} Starting template update...",
   "update.langLabel": "Lang",
   "update.typeLabel": "Type",
@@ -493,6 +496,7 @@ var enCli = {
   "update.fileUpdated": "{file} updated",
   "update.gitStatusUnavailable": "Cannot determine git status (not a git repo or git unavailable). Use --force to overwrite.",
   "update.docsWorktreeDirty": "Docs working tree has changes. Commit/stash your changes, or run with --force to overwrite.",
+  "update.legacyAutomationSafe": "Existing projects keep newly introduced task delegation and Plan/Task review disabled unless they had explicitly opted in. Configure them with `npx lee-spec-kit config --interactive` or the config flags.",
   "init.selectLangPrompt": "Select docs language:",
   "init.currentDirectoryLabel": "\u{1F4CD} Current directory",
   "init.gitDetected": "\u2705 Git repository detected",
@@ -527,7 +531,7 @@ var enCli = {
   "init.choice.taskAgent.on": "On - delegate each task implementation",
   "init.choice.taskAgent.off": "Off - implement tasks in the main agent",
   "init.prompt.reviews": "Select independent review gates:",
-  "init.prompt.maxReviewRounds": "Maximum automatic finding remediation rounds before continuing with residual risks:",
+  "init.prompt.maxReviewRounds": "Maximum fresh review rounds before continuing with residual risks:",
   "init.choice.review.plan": "Plan",
   "init.choice.review.task": "Task",
   "init.choice.review.feature": "Feature",
@@ -553,7 +557,7 @@ var enCli = {
   "init.log.workflowLabel": "Workflow",
   "init.log.taskAgentLabel": "Task implementation",
   "init.log.reviewsLabel": "Reviews",
-  "init.log.maxReviewRoundsLabel": "Review remediation rounds",
+  "init.log.maxReviewRoundsLabel": "Maximum fresh review rounds",
   "init.log.completionStrategyLabel": "Local integration",
   "init.summary.taskAgent.on": "subagent",
   "init.summary.taskAgent.off": "main agent",
@@ -1371,12 +1375,15 @@ Before taking the next workflow step:
 13. When \`workflow-stage --json\` returns \`nextAction.category === "plan_review"\` with \`executor === "subagent"\`, delegate a fresh read-only review of \`spec.md\` and \`plan.md\` using the returned model settings and exact \`specHash\` / \`planHash\`; the main agent records the returned reviewRound, evidence, decision, reviewer metadata, and both hashes, and any later spec/plan content change requires a fresh review
 14. When \`workflow-stage --json\` returns \`nextAction.category === "task_execute"\` with \`executor === "subagent"\`, mark exactly the returned \`taskId\` as active and delegate its implementation plus task-scoped verification to a fresh subagent in the returned \`workingDirectory\`, using the returned \`model\`, \`reasoningEffort\`, \`onUnavailable\`, and exact \`workerContract\`; no named execution skill is required
 15. The task implementation worker executes directly: it must follow the approved Verification Contract, must not add unplanned durable tests, and must not run \`workflow-stage\`, spawn another subagent, edit lee-spec-kit docs, change task state, commit, request approvals, or perform remote/destructive actions. It may modify project code and run task-scoped checks only. The main agent inspects the result, synchronizes docs and task state, and owns every commit and workflow transition; official hooks block commits while \`task_execute\` is still active
-16. When \`workflow-stage --json\` returns \`nextAction.category === "task_review"\` with \`executor === "subagent"\`, delegate a fresh read-only review for the returned \`taskId\`, \`baseSha\`, \`targetSha\`, and \`targetTree\`; the main agent records the returned reviewRound and evidence and moves the task from \`REVIEW\` to \`DONE\` only after an approve decision
+16. When \`workflow-stage --json\` returns \`nextAction.category === "task_review"\` with \`executor === "subagent"\`, delegate a fresh read-only review for the returned \`taskId\`, \`baseSha\`, \`targetSha\`, and \`targetTree\`; the main agent records the returned reviewRound and evidence and moves the task from \`REVIEW\` to \`DONE\` after an approve decision or the automatic exhausted-\`changes_requested\` path described below
 17. When \`workflow-stage --json\` returns \`nextAction.category === "pre_pr_review"\` and \`nextAction.executor === "subagent"\`, delegate a fresh read-only Feature review using the returned \`model\`, \`reasoningEffort\`, \`onUnavailable\`, reviewRound, and review target metadata; do not select or require a named review skill
 18. Review subagents return findings without modifying code; the main agent remediates findings and records the actual reviewer metadata, reviewed scope, evidence, decision, and exact hash/SHA/tree target metadata
-19. workflow.agentReview.maxRounds counts automatic finding-remediation passes, not the initial review. After those passes are exhausted, keep the latest changes_requested findings as residual risks and automatically complete that Plan/task/Feature review gate without asking the user for a review-approval token; blocked decisions never auto-complete
-20. For a local workflow, do not report completion directly after implementation approval; follow the exact returned \`local verify\` / \`local merge\` / \`local cleanup\` commands until \`workflow-stage\` proves verification, integration, and cleanup and returns \`done\`; review-fix and \`feature_remediation\` stages explicitly permit scoped fixes
-21. In a \`local-ff\` or \`local-squash\` workflow, keep implementation approval and local merge approval distinct when \`local_merge\` is required: the first accepts the implementation, and the second authorizes the configured integration strategy, post-merge checks, and local cleanup
+19. After delegating to a subagent, wait until it returns a terminal outcome: completed, explicit failure, cancellation, or an approval/user-input request that requires action
+20. While the subagent remains running, use repeated bounded waits, preferably longer waits. A bounded wait that returns no update, a lack of status messages, or a lack of file changes means only that the subagent is still pending; none is evidence of failure or stalled work. Read-only review subagents are expected not to modify files
+21. Do not interrupt, replace, or abandon a running subagent solely because it has been quiet or has not changed files. Stop it only after an explicit user request, a terminal failure/cancellation, or an unrecoverable runtime status
+22. workflow.agentReview.maxRounds is the maximum number of fresh reviews for each Plan/task/Feature gate. A changes_requested decision on the final allowed review is remediated once, but the changed target is not reviewed again; keep remaining findings and the post-review target change as residual risks and automatically complete the gate without asking the user for a review-approval token. For example, maxRounds=1 means review round 1, remediate once, then continue with no round 2; blocked decisions never auto-complete
+23. For a local workflow, do not report completion directly after implementation approval; follow the exact returned \`local verify\` / \`local merge\` / \`local cleanup\` commands until \`workflow-stage\` proves verification, integration, and cleanup and returns \`done\`; review-fix and \`feature_remediation\` stages explicitly permit scoped fixes
+24. In a \`local-ff\` or \`local-squash\` workflow, keep implementation approval and local merge approval distinct when \`local_merge\` is required: the first accepts the implementation, and the second authorizes the configured integration strategy, post-merge checks, and local cleanup
 
 Approval and remote actions:
 
@@ -1696,6 +1703,7 @@ function toProjectConfig(docsDir, configFile, projectType, components) {
   return {
     schemaId: "lee-spec",
     docsDir,
+    createdAt: configFile.createdAt,
     projectName: configFile.projectName,
     projectType,
     components: projectType === "multi" ? components : void 0,
@@ -2131,7 +2139,7 @@ function initCommand(program2) {
     "Review gates: comma-separated plan,task,feature | none"
   ).option(
     "--max-review-rounds <count>",
-    "Automatic review finding remediation rounds before continuing with residual risks (default: 1)"
+    "Maximum fresh review rounds before continuing with residual risks (default: 1)"
   ).option(
     "--completion-strategy <strategy>",
     "Local completion: local-ff | local-squash | none"
@@ -2865,6 +2873,7 @@ async function runInit(options) {
             featureChecks: [],
             postMergeChecks: []
           } : {},
+          agentAutomationConfigured: true,
           agentExecution: {
             task: {
               ...createDefaultAgentExecutionTaskConfig(),
@@ -3816,6 +3825,50 @@ function migrateLegacyApprovalSettings(approval) {
   return { approval, changedPaths };
 }
 
+// src/config/agent-automation.ts
+var AGENT_AUTOMATION_OPT_IN_INIT_DATE = "2026-08-27";
+function isPlainRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function matchesGeneratedAgentRuntime(value, options = {}) {
+  if (!isPlainRecord2(value)) return false;
+  const expectedKeys = [
+    ...typeof options.enabled === "boolean" ? ["enabled"] : [],
+    "model",
+    "onUnavailable",
+    "reasoningEffort",
+    "type"
+  ].sort();
+  if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify(expectedKeys)) {
+    return false;
+  }
+  return (typeof options.enabled !== "boolean" || value.enabled === options.enabled) && value.type === "subagent" && value.model === "inherit" && value.reasoningEffort === "high" && value.onUnavailable === "inherit";
+}
+function matchesGeneratedReviewPhase(value, enabled) {
+  if (!isPlainRecord2(value)) return false;
+  if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify(["enabled", "evidenceMode", "reviewer"])) {
+    return false;
+  }
+  return value.enabled === enabled && value.evidenceMode === "path_required" && matchesGeneratedAgentRuntime(value.reviewer);
+}
+function resolveLegacyBackfilledAgentAutomation(config) {
+  const none = { taskExecution: false, planReview: false };
+  if (!isPlainRecord2(config.workflow)) return none;
+  const workflow = config.workflow;
+  if (workflow.agentAutomationConfigured === true) return none;
+  const createdAt = typeof config.createdAt === "string" ? config.createdAt.trim() : "";
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(createdAt)) return none;
+  if (createdAt >= AGENT_AUTOMATION_OPT_IN_INIT_DATE) return none;
+  const taskExecution = isPlainRecord2(workflow.agentExecution) ? workflow.agentExecution.task : null;
+  const planReview = isPlainRecord2(workflow.agentReview) ? workflow.agentReview.plan : null;
+  return {
+    taskExecution: matchesGeneratedAgentRuntime(taskExecution, {
+      enabled: true
+    }),
+    planReview: matchesGeneratedReviewPhase(planReview, true)
+  };
+}
+
 // src/commands/update.ts
 function hasOwnKey2(value, key) {
   return Object.prototype.hasOwnProperty.call(value, key);
@@ -3903,7 +3956,9 @@ async function runUpdate(options) {
       const updateAgents = options.agents || !hasExplicitSelection;
       const updateAgentsMd = options.agentsMd || !hasExplicitSelection;
       console.log(chalk.blue(tr(lang, "cli", "update.start")));
-      console.log(chalk.gray(`  - ${tr(lang, "cli", "update.langLabel")}: ${lang}`));
+      console.log(
+        chalk.gray(`  - ${tr(lang, "cli", "update.langLabel")}: ${lang}`)
+      );
       console.log(
         chalk.gray(`  - ${tr(lang, "cli", "update.typeLabel")}: ${projectType}`)
       );
@@ -3911,7 +3966,12 @@ async function runUpdate(options) {
       let updatedCount = 0;
       if (updateAgents) {
         console.log(chalk.blue(tr(lang, "cli", "update.updatingAgents")));
-        const commonAgentsBase = path8.join(templatesDir, lang, "common", "agents");
+        const commonAgentsBase = path8.join(
+          templatesDir,
+          lang,
+          "common",
+          "agents"
+        );
         const targetAgentsBase = path8.join(docsDir, "agents");
         const commonAgents = commonAgentsBase;
         const targetAgents = targetAgentsBase;
@@ -3940,13 +4000,14 @@ async function runUpdate(options) {
           updatedCount += count;
         }
         console.log(
-          chalk.green(
-            `  \u2705 ${tr(lang, "cli", "update.agentsUpdated")}`
-          )
+          chalk.green(`  \u2705 ${tr(lang, "cli", "update.agentsUpdated")}`)
         );
       }
       if (updateAgentsMd) {
-        const agentsMdTargets = await collectAgentsMdTargets(cwd, currentConfig);
+        const agentsMdTargets = await collectAgentsMdTargets(
+          cwd,
+          currentConfig
+        );
         for (const target of agentsMdTargets) {
           const result = await upsertLeeSpecKitAgentsMd(target, {
             lang,
@@ -3975,13 +4036,24 @@ async function runUpdate(options) {
           )
         );
         console.log(
-          chalk.gray(
-            `    (${configBackfill.changedPaths.join(", ")})`
-          )
+          chalk.gray(`    (${configBackfill.changedPaths.join(", ")})`)
         );
+        if (configBackfill.changedPaths.includes(
+          "workflow.agentExecution.task.enabled"
+        ) || configBackfill.changedPaths.includes(
+          "workflow.agentReview.plan.enabled"
+        )) {
+          console.log(
+            chalk.yellow(
+              `  - ${tr(lang, "cli", "update.legacyAutomationSafe")}`
+            )
+          );
+        }
       }
       console.log(
-        chalk.green(`\u2705 ${tr(lang, "cli", "update.updatedTotal", { count: updatedCount })}`)
+        chalk.green(
+          `\u2705 ${tr(lang, "cli", "update.updatedTotal", { count: updatedCount })}`
+        )
       );
     },
     { owner: "update" }
@@ -4050,6 +4122,7 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
   }
   const workflow = raw.workflow;
   changedPaths.push(...migrateLegacyWorkflowSettings(workflow));
+  const restoreLegacyAgentAutomationDefaults = resolveLegacyBackfilledAgentAutomation(raw);
   setIfMissing(
     workflow,
     "requireWorktree",
@@ -4154,11 +4227,15 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
   setIfMissing(
     taskExecution,
     "enabled",
-    defaultTaskExecution.enabled,
+    false,
     "workflow.agentExecution.task.enabled"
   );
   if (typeof taskExecution.enabled !== "boolean") {
-    taskExecution.enabled = defaultTaskExecution.enabled;
+    taskExecution.enabled = false;
+    changedPaths.push("workflow.agentExecution.task.enabled");
+  }
+  if (restoreLegacyAgentAutomationDefaults.taskExecution && taskExecution.enabled !== false) {
+    taskExecution.enabled = false;
     changedPaths.push("workflow.agentExecution.task.enabled");
   }
   if (taskExecution.type !== "subagent") {
@@ -4248,14 +4325,17 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
       changedPaths.push(`${phasePath}.reviewer.onUnavailable`);
     }
   };
-  normalizeAgentReviewPhase("plan", true);
+  normalizeAgentReviewPhase("plan", false);
+  if (restoreLegacyAgentAutomationDefaults.planReview) {
+    const planReview = agentReview.plan;
+    if (planReview.enabled !== false) {
+      planReview.enabled = false;
+      changedPaths.push("workflow.agentReview.plan.enabled");
+    }
+  }
   normalizeAgentReviewPhase("task", false);
   const legacyFeatureEnabled = typeof legacyPrePrReview?.enabled === "boolean" ? legacyPrePrReview.enabled : workflow.mode !== "local";
-  normalizeAgentReviewPhase(
-    "feature",
-    legacyFeatureEnabled,
-    legacyPrePrReview
-  );
+  normalizeAgentReviewPhase("feature", legacyFeatureEnabled, legacyPrePrReview);
   if (hasOwnKey2(workflow, "prePrReview")) {
     delete workflow.prePrReview;
     changedPaths.push("workflow.prePrReview");
@@ -4383,11 +4463,15 @@ function getDocsPorcelainStatus(docsDir, ignoredAbsPaths = []) {
   if (!top) return null;
   const rel = path8.relative(top, docsDir) || ".";
   try {
-    const output = execFileSync("git", ["status", "--porcelain=v1", "--", rel], {
-      cwd: top,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
+    const output = execFileSync(
+      "git",
+      ["status", "--porcelain=v1", "--", rel],
+      {
+        cwd: top,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
     if (ignoredAbsPaths.length === 0) {
       return output;
     }
@@ -4423,8 +4507,62 @@ async function isDocsWorktreeCleanOrThrow(docsDir, lang, ignoredAbsPaths = []) {
   }
   return true;
 }
+var CONFIG_REVIEW_PHASES = ["plan", "task", "feature"];
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseReviews(value) {
+  if (typeof value === "undefined") return void 0;
+  const normalized = value.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+  if (normalized.length === 1 && normalized[0] === "none") return [];
+  if (normalized.length === 0 || normalized.includes("none") || normalized.some(
+    (entry) => !CONFIG_REVIEW_PHASES.includes(entry)
+  )) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--reviews` must be a comma-separated subset of `plan,task,feature`, or `none`."
+    );
+  }
+  return CONFIG_REVIEW_PHASES.filter((phase) => normalized.includes(phase));
+}
+function parseMaxReviewRounds(value) {
+  if (typeof value === "undefined") return void 0;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--max-review-rounds` must be a positive integer."
+    );
+  }
+  return parsed;
+}
+function validateWorkflowOptions(options) {
+  if (options.taskAgent && !["on", "off"].includes(options.taskAgent)) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--task-agent` must be `on` or `off`."
+    );
+  }
+  if (options.completionStrategy && !["local-ff", "local-squash", "none"].includes(options.completionStrategy)) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--completion-strategy` must be `local-ff`, `local-squash`, or `none`."
+    );
+  }
+  parseReviews(options.reviews);
+  parseMaxReviewRounds(options.maxReviewRounds);
+}
 function configCommand(program2) {
-  program2.command("config").description("View or modify project configuration").option("--dir <dir>", "Docs directory or project path to target").option("--project-root <path>", "Set project root path").option("--component <component>", "Component name for multi projects").option("--non-interactive", "Fail instead of prompting for input").action(async (options) => {
+  program2.command("config").description("View or modify project configuration").option("--dir <dir>", "Docs directory or project path to target").option("--project-root <path>", "Set project root path").option("--component <component>", "Component name for multi projects").option("--task-agent <mode>", "Task implementation agent: on | off").option(
+    "--reviews <list>",
+    "Review gates: comma-separated plan,task,feature | none"
+  ).option(
+    "--max-review-rounds <count>",
+    "Maximum fresh review rounds before continuing with residual risks"
+  ).option(
+    "--completion-strategy <strategy>",
+    "Local completion: local-ff | local-squash | none"
+  ).option("--interactive", "Configure workflow options interactively").option("--non-interactive", "Fail instead of prompting for input").action(async (options) => {
     try {
       await runConfig(options);
     } catch (error) {
@@ -4450,6 +4588,7 @@ ${tr(lang2, "cli", "common.canceled")}`));
   });
 }
 async function runConfig(options) {
+  validateWorkflowOptions(options);
   const cwd = process.cwd();
   const targetCwd = options.dir ? path8.resolve(cwd, options.dir) : cwd;
   const config = await getConfig(targetCwd);
@@ -4460,7 +4599,8 @@ async function runConfig(options) {
     );
   }
   const configPath = path8.join(config.docsDir, ".lee-spec-kit.json");
-  if (!options.projectRoot) {
+  const hasWorkflowOptions = typeof options.taskAgent !== "undefined" || typeof options.reviews !== "undefined" || typeof options.maxReviewRounds !== "undefined" || typeof options.completionStrategy !== "undefined" || !!options.interactive;
+  if (!options.projectRoot && !hasWorkflowOptions) {
     console.log();
     console.log(chalk.blue(tr(config.lang, "cli", "config.currentTitle")));
     console.log();
@@ -4475,85 +4615,21 @@ async function runConfig(options) {
     console.log();
     return;
   }
-  const projectRoot = options.projectRoot;
   await withFileLock(
     getDocsLockPath(config.docsDir),
     async () => {
       const configFile = await fs.readJson(configPath);
-      if (configFile.docsRepo !== "standalone") {
-        console.log(
-          chalk.yellow(tr(config.lang, "cli", "config.projectRootStandaloneOnly"))
+      if (!isPlainObject2(configFile)) {
+        throw createCliError(
+          "PRECONDITION_FAILED",
+          "Invalid project configuration."
         );
-        return;
       }
-      const projectType = normalizeProjectType(String(configFile.projectType || "single"));
-      const targetFromOptions = options.component?.trim().toLowerCase();
-      if (projectType === "multi") {
-        const components = resolveProjectComponents(projectType, configFile.components);
-        let targetComponent = targetFromOptions;
-        if (!targetComponent) {
-          if (components.length === 1) {
-            targetComponent = components[0];
-          } else if (options.nonInteractive) {
-            throw createCliError(
-              "PROMPT_BLOCKED",
-              "`--component` is required for multi projectRoot update when using `--non-interactive`."
-            );
-          } else {
-            const response = await prompts(
-              [
-                {
-                  type: "select",
-                  name: "component",
-                  message: tr(config.lang, "cli", "config.selectRepoToUpdate"),
-                  choices: components.map((value) => ({
-                    title: value.toUpperCase(),
-                    value
-                  }))
-                }
-              ],
-              {
-                onCancel: () => {
-                  throw new Error("canceled");
-                }
-              }
-            );
-            targetComponent = response.component;
-          }
-        }
-        if (!targetComponent) {
-          throw createCliError(
-            "INVALID_ARGUMENT",
-            "Component selection is required."
-          );
-        }
-        assertAllowedComponent(targetComponent, components);
-        const currentRoot = typeof configFile.projectRoot === "object" && configFile.projectRoot ? configFile.projectRoot : {};
-        currentRoot[targetComponent] = projectRoot;
-        configFile.projectRoot = currentRoot;
-        console.log(
-          chalk.green(
-            tr(config.lang, "cli", "config.projectRootSet", {
-              repo: targetComponent.toUpperCase(),
-              path: projectRoot
-            })
-          )
-        );
-      } else {
-        if (targetFromOptions) {
-          throw createCliError(
-            "INVALID_ARGUMENT",
-            "`--component` is only valid for multi projectRoot updates."
-          );
-        }
-        configFile.projectRoot = projectRoot;
-        console.log(
-          chalk.green(
-            tr(config.lang, "cli", "config.projectRootSetSingle", {
-              path: projectRoot
-            })
-          )
-        );
+      if (options.projectRoot) {
+        await updateProjectRoot(configFile, options, config.lang);
+      }
+      if (hasWorkflowOptions) {
+        await updateWorkflowConfig(configFile, options, config.lang);
       }
       await fs.writeJson(configPath, configFile, { spaces: 2 });
       console.log();
@@ -4561,6 +4637,255 @@ async function runConfig(options) {
     { owner: "config" }
   );
 }
+async function updateProjectRoot(configFile, options, lang) {
+  if (configFile.docsRepo !== "standalone") {
+    console.log(
+      chalk.yellow(tr(lang, "cli", "config.projectRootStandaloneOnly"))
+    );
+    return;
+  }
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) return;
+  const projectType = normalizeProjectType(
+    String(configFile.projectType || "single")
+  );
+  const targetFromOptions = options.component?.trim().toLowerCase();
+  if (projectType === "multi") {
+    const components = resolveProjectComponents(
+      projectType,
+      configFile.components
+    );
+    let targetComponent = targetFromOptions;
+    if (!targetComponent) {
+      if (components.length === 1) {
+        targetComponent = components[0];
+      } else if (options.nonInteractive) {
+        throw createCliError(
+          "PROMPT_BLOCKED",
+          "`--component` is required for multi projectRoot update when using `--non-interactive`."
+        );
+      } else {
+        const response = await prompts(
+          [
+            {
+              type: "select",
+              name: "component",
+              message: tr(lang, "cli", "config.selectRepoToUpdate"),
+              choices: components.map((value) => ({
+                title: value.toUpperCase(),
+                value
+              }))
+            }
+          ],
+          {
+            onCancel: () => {
+              throw new Error("canceled");
+            }
+          }
+        );
+        targetComponent = response.component;
+      }
+    }
+    if (!targetComponent) {
+      throw createCliError(
+        "INVALID_ARGUMENT",
+        "Component selection is required."
+      );
+    }
+    assertAllowedComponent(targetComponent, components);
+    const currentRoot = isPlainObject2(
+      configFile.projectRoot
+    ) ? Object.fromEntries(
+      Object.entries(configFile.projectRoot).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : {};
+    currentRoot[targetComponent] = projectRoot;
+    configFile.projectRoot = currentRoot;
+    console.log(
+      chalk.green(
+        tr(lang, "cli", "config.projectRootSet", {
+          repo: targetComponent.toUpperCase(),
+          path: projectRoot
+        })
+      )
+    );
+  } else {
+    if (targetFromOptions) {
+      throw createCliError(
+        "INVALID_ARGUMENT",
+        "`--component` is only valid for multi projectRoot updates."
+      );
+    }
+    configFile.projectRoot = projectRoot;
+    console.log(
+      chalk.green(
+        tr(lang, "cli", "config.projectRootSetSingle", {
+          path: projectRoot
+        })
+      )
+    );
+  }
+}
+function ensureWorkflow(configFile) {
+  if (!isPlainObject2(configFile.workflow)) configFile.workflow = {};
+  return configFile.workflow;
+}
+function ensureTaskExecution(workflow) {
+  if (!isPlainObject2(workflow.agentExecution)) workflow.agentExecution = {};
+  const agentExecution = workflow.agentExecution;
+  if (!isPlainObject2(agentExecution.task)) {
+    agentExecution.task = createDefaultAgentExecutionTaskConfig();
+  }
+  return agentExecution.task;
+}
+function ensureAgentReview(workflow) {
+  if (!isPlainObject2(workflow.agentReview)) workflow.agentReview = {};
+  return workflow.agentReview;
+}
+function ensureReviewPhase(agentReview, phaseName) {
+  if (!isPlainObject2(agentReview[phaseName])) {
+    agentReview[phaseName] = {
+      enabled: false,
+      evidenceMode: "path_required",
+      reviewer: createDefaultAgentReviewerConfig()
+    };
+  }
+  const phase = agentReview[phaseName];
+  if (!isPlainObject2(phase.reviewer)) {
+    phase.reviewer = createDefaultAgentReviewerConfig();
+  }
+  if (phase.evidenceMode !== "any" && phase.evidenceMode !== "path_required") {
+    phase.evidenceMode = "path_required";
+  }
+  return phase;
+}
+function currentReviewSelection(workflow) {
+  const agentReview = isPlainObject2(workflow.agentReview) ? workflow.agentReview : {};
+  const legacyFeature = isPlainObject2(workflow.prePrReview) ? workflow.prePrReview.enabled : void 0;
+  const isLocal = workflow.mode === "local" || workflow.preset === "local";
+  return CONFIG_REVIEW_PHASES.filter((phase) => {
+    const phaseConfig = isPlainObject2(agentReview[phase]) ? agentReview[phase] : {};
+    if (typeof phaseConfig.enabled === "boolean") return phaseConfig.enabled;
+    if (phase === "feature") {
+      return typeof legacyFeature === "boolean" ? legacyFeature : !isLocal;
+    }
+    return false;
+  });
+}
+async function updateWorkflowConfig(configFile, options, lang) {
+  const workflow = ensureWorkflow(configFile);
+  const legacyBackfilledAgentAutomation = resolveLegacyBackfilledAgentAutomation(configFile);
+  if (legacyBackfilledAgentAutomation.taskExecution) {
+    ensureTaskExecution(workflow).enabled = false;
+  }
+  if (legacyBackfilledAgentAutomation.planReview) {
+    ensureReviewPhase(ensureAgentReview(workflow), "plan").enabled = false;
+  }
+  const isLocal = workflow.mode === "local" || workflow.preset === "local";
+  if (options.interactive && options.nonInteractive) {
+    throw createCliError(
+      "PROMPT_BLOCKED",
+      "`--interactive` cannot be used with `--non-interactive`."
+    );
+  }
+  let taskAgentEnabled = options.taskAgent === "on" ? true : options.taskAgent === "off" ? false : void 0;
+  let reviews = parseReviews(options.reviews);
+  let maxReviewRounds = parseMaxReviewRounds(options.maxReviewRounds);
+  let completionStrategy = options.completionStrategy;
+  if (options.interactive) {
+    const selectedReviews = currentReviewSelection(workflow);
+    const currentTaskExecution = isPlainObject2(workflow.agentExecution) && isPlainObject2(workflow.agentExecution.task) ? workflow.agentExecution.task.enabled === true : false;
+    const currentAgentReview = isPlainObject2(workflow.agentReview) ? workflow.agentReview : {};
+    const currentMaxRounds = typeof currentAgentReview.maxRounds === "number" && Number.isInteger(currentAgentReview.maxRounds) && currentAgentReview.maxRounds > 0 ? currentAgentReview.maxRounds : 1;
+    const response = await prompts(
+      [
+        {
+          type: typeof options.taskAgent === "undefined" ? "select" : null,
+          name: "taskAgent",
+          message: tr(lang, "cli", "init.prompt.taskAgent"),
+          choices: [
+            { title: tr(lang, "cli", "init.choice.taskAgent.on"), value: true },
+            {
+              title: tr(lang, "cli", "init.choice.taskAgent.off"),
+              value: false
+            }
+          ],
+          initial: currentTaskExecution ? 0 : 1
+        },
+        {
+          type: typeof options.reviews === "undefined" ? "multiselect" : null,
+          name: "reviews",
+          message: tr(lang, "cli", "init.prompt.reviews"),
+          choices: CONFIG_REVIEW_PHASES.map((phase) => ({
+            title: tr(lang, "cli", `init.choice.review.${phase}`),
+            value: phase,
+            selected: selectedReviews.includes(phase)
+          }))
+        },
+        {
+          type: typeof options.maxReviewRounds === "undefined" ? "number" : null,
+          name: "maxReviewRounds",
+          message: tr(lang, "cli", "init.prompt.maxReviewRounds"),
+          initial: currentMaxRounds,
+          min: 1
+        },
+        {
+          type: isLocal && typeof options.completionStrategy === "undefined" ? "select" : null,
+          name: "completionStrategy",
+          message: tr(lang, "cli", "init.prompt.completionStrategy"),
+          choices: [
+            { title: "local-ff", value: "local-ff" },
+            { title: "local-squash", value: "local-squash" },
+            { title: "none", value: "none" }
+          ],
+          initial: ["local-ff", "local-squash", "none"].indexOf(
+            String(workflow.completionStrategy || "none")
+          )
+        }
+      ],
+      {
+        onCancel: () => {
+          throw new Error("canceled");
+        }
+      }
+    );
+    if (typeof response.taskAgent === "boolean")
+      taskAgentEnabled = response.taskAgent;
+    if (Array.isArray(response.reviews)) {
+      reviews = CONFIG_REVIEW_PHASES.filter(
+        (phase) => response.reviews.includes(phase)
+      );
+    }
+    if (Number.isInteger(response.maxReviewRounds) && response.maxReviewRounds > 0) {
+      maxReviewRounds = response.maxReviewRounds;
+    }
+    completionStrategy = response.completionStrategy || completionStrategy;
+  }
+  if (completionStrategy && !isLocal) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--completion-strategy` can only be used with a local workflow."
+    );
+  }
+  if (typeof taskAgentEnabled === "boolean") {
+    ensureTaskExecution(workflow).enabled = taskAgentEnabled;
+  }
+  if (reviews) {
+    const agentReview = ensureAgentReview(workflow);
+    for (const phase of CONFIG_REVIEW_PHASES) {
+      ensureReviewPhase(agentReview, phase).enabled = reviews.includes(phase);
+    }
+  }
+  if (typeof maxReviewRounds === "number") {
+    ensureAgentReview(workflow).maxRounds = maxReviewRounds;
+  }
+  if (completionStrategy) workflow.completionStrategy = completionStrategy;
+  if (typeof taskAgentEnabled === "boolean" || reviews) {
+    workflow.agentAutomationConfigured = true;
+  }
+  console.log(chalk.green(tr(lang, "cli", "config.workflowUpdated")));
+}
 function runProcess(bin, args, cwd) {
   const result = spawnSync(bin, args, {
     cwd,
@@ -8441,6 +8766,7 @@ var COMPLETION_MARKERS = {
 };
 function resolveWorkflowRequirements(config) {
   const workflow = config.workflow || {};
+  const legacyBackfilledAgentAutomation = resolveLegacyBackfilledAgentAutomation(config);
   const hasCanonicalMode = workflow.mode === "github" || workflow.mode === "local";
   const workflowMode = hasCanonicalMode ? workflow.mode : workflow.preset === "local" ? "local" : "github";
   const isLocalWorkflow = workflowMode === "local";
@@ -8452,10 +8778,13 @@ function resolveWorkflowRequirements(config) {
     requirePr: workflow.requirePr ?? !isLocalWorkflow,
     requireReview: workflow.requireReview ?? !isLocalWorkflow,
     requireMerge: workflow.requireMerge ?? !isLocalWorkflow,
-    planReviewEnabled: workflow.agentReview?.plan?.enabled ?? true,
+    // Missing agent automation keys identify projects created before these
+    // policies existed. Keep their historical main-agent/no-Plan-review
+    // behavior; new projects opt in explicitly through init.
+    planReviewEnabled: legacyBackfilledAgentAutomation.planReview ? false : workflow.agentReview?.plan?.enabled ?? false,
     taskReviewEnabled: workflow.agentReview?.task?.enabled ?? false,
     featureReviewEnabled: workflow.agentReview?.feature?.enabled ?? workflow.prePrReview?.enabled ?? !isLocalWorkflow,
-    taskExecutionEnabled: workflow.agentExecution?.task?.enabled ?? true
+    taskExecutionEnabled: legacyBackfilledAgentAutomation.taskExecution ? false : workflow.agentExecution?.task?.enabled ?? false
   };
 }
 function parseApprovalStatus(raw) {
@@ -8518,8 +8847,8 @@ function resolveMaxReviewRounds(config) {
   const configured = config.workflow?.agentReview?.maxRounds;
   return typeof configured === "number" && Number.isInteger(configured) && configured > 0 ? configured : 1;
 }
-function reviewRemediationLimitReached(config, reviewRound, decisionOutcome) {
-  return decisionOutcome === "changes_requested" && (reviewRound || 1) > resolveMaxReviewRounds(config);
+function reviewRoundLimitReached(config, reviewRound, decisionOutcome) {
+  return decisionOutcome === "changes_requested" && (reviewRound || 1) >= resolveMaxReviewRounds(config);
 }
 function parseWorkflowTaskLine(line, index = -1) {
   const canonical = parseTaskLine(line, index);
@@ -9244,28 +9573,34 @@ function reviewEvidenceSatisfied(config, feature, scope, evidence) {
   });
 }
 function planReviewSatisfied(config, feature, review, target) {
-  return review.status === "done" && reviewEvidenceSatisfied(config, feature, "plan", review.evidence) && (review.decisionOutcome === "approve" || reviewRemediationLimitReached(
+  const reviewLimitReached = reviewRoundLimitReached(
     config,
     review.reviewRound,
     review.decisionOutcome
-  )) && review.reviewedSpecHash === target.specHash && review.reviewedPlanHash === target.planHash;
+  );
+  const targetMatches = review.reviewedSpecHash === target.specHash && review.reviewedPlanHash === target.planHash;
+  return review.status === "done" && reviewEvidenceSatisfied(config, feature, "plan", review.evidence) && (review.decisionOutcome === "approve" && targetMatches || reviewLimitReached && !targetMatches);
 }
 function featureReviewSatisfied(config, feature, tasks, target) {
-  return !!target && tasks.prePrReviewStatus === "done" && reviewEvidenceSatisfied(config, feature, "feature", tasks.prePrEvidence) && !!tasks.prePrDecision && (tasks.prePrDecisionOutcome === "approve" || reviewRemediationLimitReached(
+  const reviewLimitReached = reviewRoundLimitReached(
     config,
     tasks.prePrReviewRound,
     tasks.prePrDecisionOutcome
-  )) && tasks.prePrReviewedHead === target.targetSha && tasks.prePrReviewedTree === target.targetTree;
+  );
+  const targetMatches = !!target && tasks.prePrReviewedHead === target.targetSha && tasks.prePrReviewedTree === target.targetTree;
+  return !!target && tasks.prePrReviewStatus === "done" && reviewEvidenceSatisfied(config, feature, "feature", tasks.prePrEvidence) && !!tasks.prePrDecision && (tasks.prePrDecisionOutcome === "approve" && targetMatches || reviewLimitReached && !targetMatches);
 }
 function taskReviewEvidenceSatisfied(config, feature, task, target) {
-  return !!target && reviewEvidenceSatisfied(config, feature, "task", task.reviewEvidence) && (task.reviewDecisionOutcome === "approve" || reviewRemediationLimitReached(
+  const reviewLimitReached = reviewRoundLimitReached(
     config,
     task.reviewRound,
     task.reviewDecisionOutcome
-  )) && task.reviewedHead === target.targetSha && task.reviewedTree === target.targetTree;
+  );
+  const targetMatches = !!target && task.reviewedHead === target.targetSha && task.reviewedTree === target.targetTree;
+  return !!target && reviewEvidenceSatisfied(config, feature, "task", task.reviewEvidence) && (task.reviewDecisionOutcome === "approve" && targetMatches || reviewLimitReached && !targetMatches);
 }
 function recordedTaskReviewSatisfied(config, feature, projectGitCwd, task, currentTargetSha) {
-  if (!currentTargetSha || !task.reviewedHead || !task.reviewedTree || task.reviewDecisionOutcome !== "approve" && !reviewRemediationLimitReached(
+  if (!currentTargetSha || !task.reviewedHead || !task.reviewedTree || task.reviewDecisionOutcome !== "approve" && !reviewRoundLimitReached(
     config,
     task.reviewRound,
     task.reviewDecisionOutcome
@@ -9276,7 +9611,7 @@ function recordedTaskReviewSatisfied(config, feature, projectGitCwd, task, curre
     ["rev-parse", `${task.reviewedHead}^{tree}`],
     projectGitCwd
   ) || "";
-  return actualTree === task.reviewedTree && isAncestor(projectGitCwd, task.reviewedHead, currentTargetSha);
+  return actualTree === task.reviewedTree && isAncestor(projectGitCwd, task.reviewedHead, currentTargetSha) && (task.reviewDecisionOutcome === "approve" || task.reviewedHead !== currentTargetSha);
 }
 function resolvePreviousTaskReviewBase(config, feature, tasks, task) {
   const taskIndex = tasks.tasks.indexOf(task);
@@ -9680,7 +10015,8 @@ function resolvePlanReviewPayload(config, feature, review, target) {
   const targetMatches = review.reviewedSpecHash === target.specHash && review.reviewedPlanHash === target.planHash;
   const maxReviewRounds = resolveMaxReviewRounds(config);
   const reviewRound = review.reviewRound || 1;
-  const nextReviewRound = !targetMatches && review.decisionOutcome ? reviewRound + 1 : reviewRound;
+  const requestedReviewRound = !targetMatches && review.decisionOutcome ? reviewRound + 1 : reviewRound;
+  const nextReviewRound = Math.min(requestedReviewRound, maxReviewRounds);
   const actionContext = {
     reviewScope: "plan",
     reviewRound: nextReviewRound,
@@ -9690,7 +10026,8 @@ function resolvePlanReviewPayload(config, feature, review, target) {
     docsDirectory: config.docsDir
   };
   if (review.decisionOutcome === "changes_requested") {
-    if (targetMatches) {
+    if (targetMatches && reviewRound <= maxReviewRounds) {
+      const finalReviewRound = reviewRound >= maxReviewRounds;
       return {
         status: "ok",
         reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -9699,7 +10036,7 @@ function resolvePlanReviewPayload(config, feature, review, target) {
         stage: "plan_review_fix",
         nextAction: buildAction(
           "plan_review_fix",
-          `Address the independent Plan review findings in spec.md or plan.md, record review round ${reviewRound + 1}, keep implementation blocked, and request a fresh review for the resulting document hashes.`,
+          finalReviewRound ? `Address the independent Plan review findings in spec.md or plan.md, keep review round ${reviewRound}, and do not request another review. The resulting document hash changes will be preserved with the remaining findings as residual risks before automatic Plan promotion.` : `Address the independent Plan review findings in spec.md or plan.md, record review round ${reviewRound + 1}, keep implementation blocked, and request a fresh review for the resulting document hashes.`,
           false,
           null,
           void 0,
@@ -9711,6 +10048,26 @@ function resolvePlanReviewPayload(config, feature, review, target) {
       };
     }
   }
+  if (review.decisionOutcome === "changes_requested" && reviewRound >= maxReviewRounds) {
+    return {
+      status: "ok",
+      reasonCode: "WORKFLOW_STAGE_RESOLVED",
+      docsDir: config.docsDir,
+      featureRef: buildFeatureRef(feature),
+      stage: "plan_review",
+      nextAction: buildAction(
+        "plan_review",
+        `The Plan review round limit was reached at round ${reviewRound}. Do not delegate another review. Repair or record the final-round evidence if needed, preserve the remaining findings and any post-review hash changes as residual risks, and continue through automatic Plan promotion.`,
+        false,
+        null,
+        void 0,
+        { ...actionContext, reviewRound: maxReviewRounds }
+      ),
+      approvalRequired: false,
+      implementationAllowed: false,
+      blockedReasonCode: "PLAN_REVIEW_NOT_APPROVED"
+    };
+  }
   if (targetMatches && review.decisionOutcome === "blocked") {
     return {
       status: "ok",
@@ -9790,11 +10147,11 @@ async function collectWorkflowStage(cwd, selector, component) {
     specContent || "",
     planContent || ""
   );
-  const planReviewAutoCompleted = planReview.status === "done" && reviewEvidenceSatisfied(config, feature, "plan", planReview.evidence) && reviewRemediationLimitReached(
+  const planReviewAutoCompleted = planReview.status === "done" && reviewEvidenceSatisfied(config, feature, "plan", planReview.evidence) && reviewRoundLimitReached(
     config,
     planReview.reviewRound,
     planReview.decisionOutcome
-  ) && planReview.reviewedSpecHash === planReviewTarget.specHash && planReview.reviewedPlanHash === planReviewTarget.planHash;
+  ) && (planReview.reviewedSpecHash !== planReviewTarget.specHash || planReview.reviewedPlanHash !== planReviewTarget.planHash);
   const enforcePlanReview = requirements.planReviewEnabled && (tasks.docStatus !== "approved" || planReview.hasMetadata);
   const issueDraft = parseWorkflowDraftMetadataExtended(issueContent || "");
   const prDraft = parseWorkflowDraftMetadataExtended(prContent || "");
@@ -9852,7 +10209,7 @@ async function collectWorkflowStage(cwd, selector, component) {
       stage: "plan",
       nextAction: buildAction(
         isReviewStage ? "plan_approve" : "plan_write",
-        isReviewStage ? planReviewAutoCompleted ? "The Plan review remediation limit was reached. Preserve the remaining findings as residual risks, promote plan.md from Review to Approved, and continue automatically without asking the user for review approval." : approvalRequired ? "Get user approval and update plan.md status to Approved." : "Promote plan.md from Review to Approved and continue automatically." : "Write or refine plan.md until it is ready for approval.",
+        isReviewStage ? planReviewAutoCompleted ? "The Plan review round limit was reached. Preserve the remaining findings and post-review hash changes as residual risks, promote plan.md from Review to Approved, and continue automatically without asking the user for review approval." : approvalRequired ? "Get user approval and update plan.md status to Approved." : "Promote plan.md from Review to Approved and continue automatically." : "Write or refine plan.md until it is ready for approval.",
         approvalRequired
       ),
       approvalRequired,
@@ -10040,6 +10397,7 @@ async function collectWorkflowStage(cwd, selector, component) {
     const evidenceMatchesTarget = reviewTask.reviewedHead === reviewTarget.targetSha && reviewTask.reviewedTree === reviewTarget.targetTree;
     if (reviewTask.reviewDecisionOutcome === "changes_requested") {
       if (evidenceMatchesTarget && reviewContext.reviewRound <= reviewContext.maxReviewRounds) {
+        const finalReviewRound = reviewContext.reviewRound >= reviewContext.maxReviewRounds;
         return {
           status: "ok",
           reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -10048,7 +10406,7 @@ async function collectWorkflowStage(cwd, selector, component) {
           stage: "task_review_fix",
           nextAction: buildAction(
             "task_review_fix",
-            `Address the independent review findings for ${reviewTask.taskId || reviewTask.title}, return the task to REVIEW, commit the new code tip, and request fresh review round ${reviewContext.reviewRound + 1}.`,
+            finalReviewRound ? `Address the independent review findings for ${reviewTask.taskId || reviewTask.title}, return the task to REVIEW, and commit the new code tip without requesting another review. Preserve any remaining findings and the post-review target change as residual risks before automatic task completion.` : `Address the independent review findings for ${reviewTask.taskId || reviewTask.title}, return the task to REVIEW, commit the new code tip, and request fresh review round ${reviewContext.reviewRound + 1}.`,
             false,
             null,
             void 0,
@@ -10081,7 +10439,7 @@ async function collectWorkflowStage(cwd, selector, component) {
       };
     }
     if (taskReviewEvidenceSatisfied(config, feature, reviewTask, reviewTarget)) {
-      const completionSummary = reviewTask.reviewDecisionOutcome === "approve" ? reviewTask.status === "DONE" ? `The independent review approved ${reviewTask.taskId || reviewTask.title} at the current code tree. Commit the review evidence before continuing.` : `The independent review approved ${reviewTask.taskId || reviewTask.title} at the current code tree. Mark the task DONE and commit the review evidence before starting another task.` : reviewTask.status === "DONE" ? `The review remediation limit was reached for ${reviewTask.taskId || reviewTask.title}. Keep the remaining findings as residual risks and commit the review evidence before continuing automatically.` : `The review remediation limit was reached for ${reviewTask.taskId || reviewTask.title}. Keep the remaining findings as residual risks, mark the task DONE, and commit the review evidence before continuing automatically.`;
+      const completionSummary = reviewTask.reviewDecisionOutcome === "approve" ? reviewTask.status === "DONE" ? `The independent review approved ${reviewTask.taskId || reviewTask.title} at the current code tree. Commit the review evidence before continuing.` : `The independent review approved ${reviewTask.taskId || reviewTask.title} at the current code tree. Mark the task DONE and commit the review evidence before starting another task.` : reviewTask.status === "DONE" ? `The review round limit was reached for ${reviewTask.taskId || reviewTask.title}. Keep the remaining findings${evidenceMatchesTarget ? "" : " and any post-review unreviewed target changes"} as residual risks and commit the review evidence before continuing automatically.` : `The review round limit was reached for ${reviewTask.taskId || reviewTask.title}. Keep the remaining findings${evidenceMatchesTarget ? "" : " and any post-review unreviewed target changes"} as residual risks, mark the task DONE, and commit the review evidence before continuing automatically.`;
       return {
         status: "ok",
         reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -10101,6 +10459,26 @@ async function collectWorkflowStage(cwd, selector, component) {
         blockedReasonCode: "TASK_REVIEW_NOT_APPROVED"
       };
     }
+    if (reviewTask.reviewDecisionOutcome === "changes_requested" && reviewContext.reviewRound >= reviewContext.maxReviewRounds) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "task_review",
+        nextAction: buildAction(
+          "task_review",
+          `The review round limit was reached for ${reviewTask.taskId || reviewTask.title} at round ${reviewContext.reviewRound}. Do not delegate another review. Repair or record the final-round evidence if needed and preserve the remaining findings and any post-review target changes as residual risks before completing the task automatically.`,
+          false,
+          null,
+          void 0,
+          reviewContext
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "TASK_REVIEW_NOT_APPROVED"
+      };
+    }
     return {
       status: "ok",
       reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -10109,13 +10487,16 @@ async function collectWorkflowStage(cwd, selector, component) {
       stage: "task_review",
       nextAction: buildAction(
         "task_review",
-        `Delegate fresh read-only review round ${evidenceMatchesTarget ? reviewContext.reviewRound : reviewTask.reviewDecisionOutcome ? reviewContext.reviewRound + 1 : reviewContext.reviewRound} of ${reviewTask.taskId || reviewTask.title} for ${reviewTarget.baseSha}..${reviewTarget.targetSha}. Record Review Round, evidence, decision, reviewer metadata, Reviewed Head, and Reviewed Tree without modifying code.`,
+        `Delegate fresh read-only review round ${evidenceMatchesTarget ? reviewContext.reviewRound : reviewTask.reviewDecisionOutcome ? Math.min(reviewContext.reviewRound + 1, reviewContext.maxReviewRounds) : reviewContext.reviewRound} of ${reviewTask.taskId || reviewTask.title} for ${reviewTarget.baseSha}..${reviewTarget.targetSha}. Record Review Round, evidence, decision, reviewer metadata, Reviewed Head, and Reviewed Tree without modifying code.`,
         false,
         null,
         resolveAgentReviewer(config, "task"),
         {
           ...reviewContext,
-          reviewRound: !evidenceMatchesTarget && reviewTask.reviewDecisionOutcome ? reviewContext.reviewRound + 1 : reviewContext.reviewRound
+          reviewRound: !evidenceMatchesTarget && reviewTask.reviewDecisionOutcome ? Math.min(
+            reviewContext.reviewRound + 1,
+            reviewContext.maxReviewRounds
+          ) : reviewContext.reviewRound
         }
       ),
       approvalRequired: false,
@@ -10225,6 +10606,7 @@ async function collectWorkflowStage(cwd, selector, component) {
     const evidenceMatchesTarget = !!reviewTarget && tasks.prePrReviewedHead === reviewTarget.targetSha && tasks.prePrReviewedTree === reviewTarget.targetTree;
     if (reviewContext && tasks.prePrDecisionOutcome === "changes_requested") {
       if (evidenceMatchesTarget && reviewContext.reviewRound <= reviewContext.maxReviewRounds) {
+        const finalReviewRound = reviewContext.reviewRound >= reviewContext.maxReviewRounds;
         return {
           status: "ok",
           reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -10233,7 +10615,7 @@ async function collectWorkflowStage(cwd, selector, component) {
           stage: "feature_review_fix",
           nextAction: buildAction(
             "feature_review_fix",
-            `Address the Feature review findings, commit the remediation, record review round ${reviewContext.reviewRound + 1}, and request a fresh review of the new code tree before implementation approval.`,
+            finalReviewRound ? `Address the Feature review findings and commit the remediation without requesting another review. Preserve any remaining findings and the post-review target change as residual risks before continuing automatically.` : `Address the Feature review findings, commit the remediation, record review round ${reviewContext.reviewRound + 1}, and request a fresh review of the new code tree before implementation approval.`,
             false,
             null,
             void 0,
@@ -10266,7 +10648,12 @@ async function collectWorkflowStage(cwd, selector, component) {
       };
     }
     if (!featureReviewSatisfied(config, feature, tasks, reviewTarget)) {
-      const requestedRound = reviewContext && !evidenceMatchesTarget && tasks.prePrDecisionOutcome ? reviewContext.reviewRound + 1 : reviewContext?.reviewRound;
+      const rawRequestedRound = reviewContext && !evidenceMatchesTarget && tasks.prePrDecisionOutcome ? reviewContext.reviewRound + 1 : reviewContext?.reviewRound;
+      const requestedRound = reviewContext && typeof rawRequestedRound === "number" ? Math.min(
+        rawRequestedRound,
+        reviewContext.maxReviewRounds
+      ) : rawRequestedRound;
+      const reviewLimitExhausted = !!reviewContext && tasks.prePrDecisionOutcome === "changes_requested" && reviewContext.reviewRound >= reviewContext.maxReviewRounds;
       return {
         status: "ok",
         reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -10275,10 +10662,10 @@ async function collectWorkflowStage(cwd, selector, component) {
         stage: "pre_pr_review",
         nextAction: buildAction(
           "pre_pr_review",
-          reviewTarget ? `Delegate independent read-only Feature review round ${requestedRound} to a fresh subagent for ${reviewTarget.baseSha}..${reviewTarget.targetSha}. Record Review Round, findings, decision, reviewer metadata, Pre-PR Reviewed Head, and Pre-PR Reviewed Tree as evidence.` : "Create a project commit before requesting the independent Feature review.",
+          reviewLimitExhausted ? `The Feature review round limit was reached at round ${reviewContext.reviewRound}. Do not delegate another review. Repair or record the final-round evidence if needed and preserve the remaining findings and any post-review target changes as residual risks before continuing automatically.` : reviewTarget ? `Delegate independent read-only Feature review round ${requestedRound} to a fresh subagent for ${reviewTarget.baseSha}..${reviewTarget.targetSha}. Record Review Round, findings, decision, reviewer metadata, Pre-PR Reviewed Head, and Pre-PR Reviewed Tree as evidence.` : "Create a project commit before requesting the independent Feature review.",
           false,
           null,
-          reviewTarget ? resolveAgentReviewer(config, "feature") : void 0,
+          reviewTarget && !reviewLimitExhausted ? resolveAgentReviewer(config, "feature") : void 0,
           reviewContext ? { ...reviewContext, reviewRound: requestedRound } : void 0
         ),
         approvalRequired: false,