lee-spec-kit 0.9.2 → 0.9.4

package/dist/index.js

@@ -199,6 +199,27 @@ var koCli = {
   "init.choice.docsRepo.embedded.desc": "\uD504\uB85C\uC81D\uD2B8\uC640 \uD568\uAED8 push\uB429\uB2C8\uB2E4",
   "init.choice.docsRepo.standalone.title": "standalone - \uBCC4\uB3C4 \uB3C5\uB9BD \uB808\uD3EC",
   "init.choice.docsRepo.standalone.desc": "push \uC5EC\uBD80\uB97C \uBCC4\uB3C4\uB85C \uC124\uC815\uD569\uB2C8\uB2E4",
+  "init.prompt.workflowMode": "\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBC29\uC2DD\uC744 \uC120\uD0DD\uD558\uC138\uC694:",
+  "init.choice.workflow.github.title": "GitHub - Issue\uC640 PR \uAE30\uBC18 \uC6CC\uD06C\uD50C\uB85C\uC6B0",
+  "init.choice.workflow.github.desc": "\uC6D0\uACA9 Issue, \uBE0C\uB79C\uCE58, PR, \uB9AC\uBDF0, \uBCD1\uD569 \uB2E8\uACC4\uB97C \uC0AC\uC6A9\uD569\uB2C8\uB2E4",
+  "init.choice.workflow.local.title": "Local - \uB85C\uCEEC \uD1B5\uD569 \uC6CC\uD06C\uD50C\uB85C\uC6B0",
+  "init.choice.workflow.local.desc": "GitHub \uC5C6\uC774 \uAD00\uB9AC\uD615 worktree\uC640 \uB85C\uCEEC \uAC80\uC99D\uC744 \uC0AC\uC6A9\uD569\uB2C8\uB2E4",
+  "init.prompt.workflowSetup": "\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC790\uB3D9\uD654 \uBC29\uC2DD\uC744 \uC124\uC815\uD558\uC138\uC694:",
+  "init.choice.workflowSetup.recommended.title": "\uAD8C\uC7A5 \uC124\uC815 - \uADE0\uD615 \uC7A1\uD78C \uAE30\uBCF8\uAC12 \uC0AC\uC6A9",
+  "init.choice.workflowSetup.recommended.desc": "Task \uAD6C\uD604\uC744 \uC704\uC784\uD558\uACE0 Plan\uACFC Feature\uB97C \uAC80\uC218\uD569\uB2C8\uB2E4",
+  "init.choice.workflowSetup.custom.title": "\uC9C1\uC811 \uC124\uC815 - \uC635\uC158 \uC120\uD0DD",
+  "init.choice.workflowSetup.custom.desc": "Task \uC704\uC784, \uAC80\uC218 \uB2E8\uACC4, \uB85C\uCEEC \uD1B5\uD569 \uBC29\uC2DD\uC744 \uC120\uD0DD\uD569\uB2C8\uB2E4",
+  "init.prompt.taskAgent": "Task \uAD6C\uD604\uC744 \uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8\uC5D0\uAC8C \uC704\uC784\uD560\uAE4C\uC694?",
+  "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.choice.review.plan": "Plan",
+  "init.choice.review.task": "Task",
+  "init.choice.review.feature": "Feature",
+  "init.prompt.completionStrategy": "\uB85C\uCEEC \uD1B5\uD569 \uBC29\uC2DD\uC744 \uC120\uD0DD\uD558\uC138\uC694:",
+  "init.choice.completionStrategy.localFf": "local-ff - \uAC80\uC99D\uB41C Feature \uBE0C\uB79C\uCE58\uB97C fast-forward \uD1B5\uD569",
+  "init.choice.completionStrategy.localSquash": "local-squash - \uAC80\uC99D\uB41C \uD558\uB098\uC758 \uCEE4\uBC0B\uC73C\uB85C \uD1B5\uD569",
+  "init.choice.completionStrategy.none": "none - Feature \uBE0C\uB79C\uCE58\uB97C \uD1B5\uD569\uD558\uC9C0 \uC54A\uACE0 \uC885\uB8CC",
   "init.prompt.componentRepoPath": "{component} \uCEF4\uD3EC\uB10C\uD2B8 \uB808\uD3EC\uC9C0\uD1A0\uB9AC \uACBD\uB85C\uB97C \uC785\uB825\uD558\uC138\uC694:",
   "init.prompt.projectRepoPath": "\uD504\uB85C\uC81D\uD2B8 \uB808\uD3EC\uC9C0\uD1A0\uB9AC \uACBD\uB85C\uB97C \uC785\uB825\uD558\uC138\uC694:",
   "init.validation.enterPath": "\uACBD\uB85C\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694",
@@ -208,11 +229,19 @@ var koCli = {
   "init.prompt.remoteUrl": "\uC6D0\uACA9 \uB808\uD3EC URL\uC744 \uC785\uB825\uD558\uC138\uC694:",
   "init.validation.enterUrl": "URL\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694",
   "init.prompt.overwrite": "{dir} \uD3F4\uB354\uAC00 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4. \uB36E\uC5B4\uC4F0\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+  "init.log.configSummaryTitle": "\u2699\uFE0F  \uC124\uC815 \uC694\uC57D",
   "init.log.creatingDocs": "\u{1F4C1} docs \uAD6C\uC870 \uC0DD\uC131 \uC911...",
   "init.log.projectLabel": "\uD504\uB85C\uC81D\uD2B8",
   "init.log.typeLabel": "\uD0C0\uC785",
   "init.log.langLabel": "\uC5B8\uC5B4",
   "init.log.pathLabel": "\uACBD\uB85C",
+  "init.log.workflowLabel": "\uC6CC\uD06C\uD50C\uB85C\uC6B0",
+  "init.log.taskAgentLabel": "Task \uAD6C\uD604",
+  "init.log.reviewsLabel": "\uAC80\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",
+  "init.summary.reviews.none": "\uC5C6\uC74C",
   "init.log.docsCreated": "\u2705 docs \uAD6C\uC870 \uC0DD\uC131 \uC644\uB8CC!",
   "init.log.nextStepsTitle": "\uB2E4\uC74C \uB2E8\uACC4:",
   "init.log.nextSteps1": "  1. {docsDir}/prd/README.md \uC791\uC131",
@@ -482,6 +511,27 @@ var enCli = {
   "init.choice.docsRepo.embedded.desc": "Pushed together with the project",
   "init.choice.docsRepo.standalone.title": "standalone - separate docs repo",
   "init.choice.docsRepo.standalone.desc": "Configure push settings separately",
+  "init.prompt.workflowMode": "Select workflow mode:",
+  "init.choice.workflow.github.title": "GitHub - Issue and pull request workflow",
+  "init.choice.workflow.github.desc": "Use remote Issue, branch, pull request, review, and merge gates",
+  "init.choice.workflow.local.title": "Local - local integration workflow",
+  "init.choice.workflow.local.desc": "Use managed worktrees and local verification without requiring GitHub",
+  "init.prompt.workflowSetup": "Configure workflow automation:",
+  "init.choice.workflowSetup.recommended.title": "Recommended - use balanced defaults",
+  "init.choice.workflowSetup.recommended.desc": "Delegate task implementation and review Plan plus Feature",
+  "init.choice.workflowSetup.custom.title": "Custom - choose workflow options",
+  "init.choice.workflowSetup.custom.desc": "Select task delegation, review gates, and local integration",
+  "init.prompt.taskAgent": "Delegate task implementation to a subagent?",
+  "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.choice.review.plan": "Plan",
+  "init.choice.review.task": "Task",
+  "init.choice.review.feature": "Feature",
+  "init.prompt.completionStrategy": "Select local integration strategy:",
+  "init.choice.completionStrategy.localFf": "local-ff - fast-forward the verified Feature branch",
+  "init.choice.completionStrategy.localSquash": "local-squash - integrate as one verified commit",
+  "init.choice.completionStrategy.none": "none - finish without integrating the Feature branch",
   "init.prompt.componentRepoPath": 'Enter repository path for component "{component}":',
   "init.prompt.projectRepoPath": "Enter project repository path:",
   "init.validation.enterPath": "Please enter a path",
@@ -491,11 +541,19 @@ var enCli = {
   "init.prompt.remoteUrl": "Enter remote repository URL:",
   "init.validation.enterUrl": "Please enter a URL",
   "init.prompt.overwrite": "{dir} already exists. Overwrite?",
+  "init.log.configSummaryTitle": "\u2699\uFE0F  Configuration summary",
   "init.log.creatingDocs": "\u{1F4C1} Creating docs structure...",
   "init.log.projectLabel": "Project",
   "init.log.typeLabel": "Type",
   "init.log.langLabel": "Lang",
   "init.log.pathLabel": "Path",
+  "init.log.workflowLabel": "Workflow",
+  "init.log.taskAgentLabel": "Task implementation",
+  "init.log.reviewsLabel": "Reviews",
+  "init.log.completionStrategyLabel": "Local integration",
+  "init.summary.taskAgent.on": "subagent",
+  "init.summary.taskAgent.off": "main agent",
+  "init.summary.reviews.none": "none",
   "init.log.docsCreated": "\u2705 Docs structure created!",
   "init.log.nextStepsTitle": "Next steps:",
   "init.log.nextSteps1": "  1. Write {docsDir}/prd/README.md",
@@ -1295,7 +1353,7 @@ Before taking the next workflow step:
 3. When relevant, also read \`issue.md\` and \`pr.md\`
 4. Run \`npx lee-spec-kit workflow-stage <feature-ref> --json\` and follow only the returned \`nextAction\`
 5. If \`workflow-stage --json\` returns \`primaryActionLabel\` and \`actionOptions\`, treat \`primaryActionLabel\` as the default option label and present the exact \`actionOptions[*].reply\` tokens to the user before continuing
-6. Do not start implementation unless \`stage === "implementation"\` and \`implementationAllowed === true\`
+6. Do not modify implementation code unless \`implementationAllowed === true\`; normal task work uses \`stage === "implementation"\`, while \`task_review_fix\`, \`feature_review_fix\`, and \`feature_remediation\` are the only review/remediation exceptions
 7. Treat stages before implementation as hard gates:
    - spec approval plus plan / tasks readiness
    - issue preparation / issue creation
@@ -1306,10 +1364,14 @@ Before taking the next workflow step:
 10. In standalone mode, do not hand-write \`git worktree add\`; run the exact \`nextAction.command\` from \`workflow-stage\` so the managed workspace path, stale directory cleanup, and \`.env\` / \`.env.*\` copy step stay consistent
 11. Keep docs and code synchronized; if code changes materially, update the active feature docs in the same turn before stopping
 12. When docs are synced to code, keep exactly one explicit marker like \`<!-- lee-spec-kit:workflow-sync 2026-04-16T12:34:56.789Z -->\` in a single active feature doc (prefer \`tasks.md\` or \`decisions.md\`): replace an existing marker timestamp or remove duplicates instead of appending another marker, so \`workflow-audit\` can prove the sync happened after the latest code change
-13. When \`workflow-stage --json\` returns \`nextAction.category === "pre_pr_review"\` and \`nextAction.executor === "subagent"\`, delegate a fresh read-only review using the returned \`model\`, \`reasoningEffort\`, and \`onUnavailable\` policy; do not select or require a named review skill
-14. The Pre-PR review subagent returns findings without modifying code; the main agent remediates findings and records the actual reviewer metadata, reviewed diff scope, evidence, and final decision
-15. 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\`; \`feature_remediation\` explicitly permits Feature worktree fixes
-16. 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
+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 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 evidence and moves the task from \`REVIEW\` to \`DONE\` only after an approve decision
+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\`, 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. 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
+20. 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:
 
@@ -1898,7 +1960,7 @@ var DEFAULT_APPROVAL_REQUIRE_CHECK_CATEGORIES = [
   "implementation_approve",
   "local_merge"
 ];
-var PRE_PR_REVIEW_REASONING_EFFORTS = [
+var AGENT_REVIEW_REASONING_EFFORTS = [
   "low",
   "medium",
   "high",
@@ -1913,7 +1975,7 @@ function createDefaultApprovalConfig() {
     requireCheckCategories: [...DEFAULT_APPROVAL_REQUIRE_CHECK_CATEGORIES]
   };
 }
-function createDefaultPrePrReviewerConfig() {
+function createDefaultAgentReviewerConfig() {
   return {
     type: "subagent",
     model: "inherit",
@@ -1921,6 +1983,15 @@ function createDefaultPrePrReviewerConfig() {
     onUnavailable: "inherit"
   };
 }
+function createDefaultAgentExecutionTaskConfig() {
+  return {
+    enabled: true,
+    type: "subagent",
+    model: "inherit",
+    reasoningEffort: "high",
+    onUnavailable: "inherit"
+  };
+}
 
 // src/commands/init.ts
 function checkGitRepo(cwd) {
@@ -2005,6 +2076,35 @@ function hasStandaloneProjectRepoOutsideWorkspaceGitRoot(workspaceGitRoot, proje
     return !!projectGitRoot && path8.resolve(projectGitRoot) !== path8.resolve(workspaceGitRoot);
   });
 }
+var INIT_REVIEW_PHASES = ["plan", "task", "feature"];
+function parseInitReviews(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) => !INIT_REVIEW_PHASES.includes(entry)
+  )) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--reviews` must be a comma-separated subset of `plan,task,feature`, or `none`."
+    );
+  }
+  return INIT_REVIEW_PHASES.filter((phase) => normalized.includes(phase));
+}
+function assertValidInitWorkflowOptions(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`."
+    );
+  }
+}
 function initCommand(program2) {
   program2.command("init").description("Initialize project documentation structure").option("-n, --name <name>", "Project name (default: current folder name)").option(
     "-t, --type <type>",
@@ -2012,7 +2112,13 @@ function initCommand(program2) {
   ).option(
     "--components <list>",
     "Component list for multi (comma-separated, e.g. app,api,worker)"
-  ).option("-l, --lang <lang>", "Language: ko | en (default: en)").option("--workflow <mode>", "Workflow mode: github | local").option("-d, --dir <dir>", "Target directory (default: ./docs)", "./docs").option("--docs-repo <mode>", "Docs repository mode: embedded | standalone").option(
+  ).option("-l, --lang <lang>", "Language: ko | en (default: en)").option("--workflow <mode>", "Workflow mode: github | local").option("--task-agent <mode>", "Task implementation agent: on | off").option(
+    "--reviews <list>",
+    "Review gates: comma-separated plan,task,feature | none"
+  ).option(
+    "--completion-strategy <strategy>",
+    "Local completion: local-ff | local-squash | none"
+  ).option("-d, --dir <dir>", "Target directory (default: ./docs)", "./docs").option("--docs-repo <mode>", "Docs repository mode: embedded | standalone").option(
     "--project-root <path>",
     "Project root path (standalone single) or JSON map for standalone multi"
   ).option(
@@ -2042,6 +2148,7 @@ ${tr(lang2, "cli", "common.canceled")}`));
   });
 }
 async function runInit(options) {
+  assertValidInitWorkflowOptions(options);
   const cwd = process.cwd();
   const defaultName = path8.basename(cwd);
   let projectName = options.name || defaultName;
@@ -2049,6 +2156,9 @@ async function runInit(options) {
   let components = parseComponentsOption(options.components);
   let lang = options.lang || "en";
   let workflowMode = options.workflow || "github";
+  let taskAgentEnabled = options.taskAgent !== "off";
+  let enabledReviews = parseInitReviews(options.reviews) ?? ["plan", "feature"];
+  let completionStrategy = options.completionStrategy || "local-ff";
   let docsRepo = options.docsRepo || "embedded";
   let pushDocs = typeof options.pushDocs === "boolean" ? options.pushDocs : void 0;
   let docsRemote = options.docsRemote;
@@ -2168,6 +2278,24 @@ async function runInit(options) {
             }
           ],
           initial: 0
+        },
+        {
+          type: options.workflow ? null : "select",
+          name: "workflowMode",
+          message: tr(lang, "cli", "init.prompt.workflowMode"),
+          choices: [
+            {
+              title: tr(lang, "cli", "init.choice.workflow.github.title"),
+              value: "github",
+              description: tr(lang, "cli", "init.choice.workflow.github.desc")
+            },
+            {
+              title: tr(lang, "cli", "init.choice.workflow.local.title"),
+              value: "local",
+              description: tr(lang, "cli", "init.choice.workflow.local.desc")
+            }
+          ],
+          initial: 0
         }
       ],
       {
@@ -2179,6 +2307,7 @@ async function runInit(options) {
     projectName = response.projectName || projectName;
     projectType = response.projectType || projectType;
     docsRepo = response.docsRepo || "embedded";
+    workflowMode = response.workflowMode || workflowMode;
     if (docsRepo === "standalone") {
       const resolvedType = normalizeProjectType(
         String(projectType || response.projectType || "multi")
@@ -2290,6 +2419,128 @@ async function runInit(options) {
         docsRemote = remoteResponse.docsRemote || docsRemote;
       }
     }
+    const hasExplicitWorkflowSetup = typeof options.taskAgent !== "undefined" || typeof options.reviews !== "undefined" || typeof options.completionStrategy !== "undefined";
+    let customizeWorkflow = hasExplicitWorkflowSetup;
+    if (!hasExplicitWorkflowSetup) {
+      const setupResponse = await prompts(
+        [
+          {
+            type: "select",
+            name: "workflowSetup",
+            message: tr(lang, "cli", "init.prompt.workflowSetup"),
+            choices: [
+              {
+                title: tr(
+                  lang,
+                  "cli",
+                  "init.choice.workflowSetup.recommended.title"
+                ),
+                value: "recommended",
+                description: tr(
+                  lang,
+                  "cli",
+                  "init.choice.workflowSetup.recommended.desc"
+                )
+              },
+              {
+                title: tr(
+                  lang,
+                  "cli",
+                  "init.choice.workflowSetup.custom.title"
+                ),
+                value: "custom",
+                description: tr(
+                  lang,
+                  "cli",
+                  "init.choice.workflowSetup.custom.desc"
+                )
+              }
+            ],
+            initial: 0
+          }
+        ],
+        {
+          onCancel: () => {
+            throw new Error("canceled");
+          }
+        }
+      );
+      customizeWorkflow = setupResponse.workflowSetup === "custom";
+    }
+    if (customizeWorkflow) {
+      const workflowResponse = 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: 0
+          },
+          {
+            type: typeof options.reviews === "undefined" ? "multiselect" : null,
+            name: "reviews",
+            message: tr(lang, "cli", "init.prompt.reviews"),
+            choices: INIT_REVIEW_PHASES.map((phase) => ({
+              title: tr(lang, "cli", `init.choice.review.${phase}`),
+              value: phase,
+              selected: phase !== "task"
+            }))
+          },
+          {
+            type: workflowMode === "local" && typeof options.completionStrategy === "undefined" ? "select" : null,
+            name: "completionStrategy",
+            message: tr(lang, "cli", "init.prompt.completionStrategy"),
+            choices: [
+              {
+                title: tr(
+                  lang,
+                  "cli",
+                  "init.choice.completionStrategy.localFf"
+                ),
+                value: "local-ff"
+              },
+              {
+                title: tr(
+                  lang,
+                  "cli",
+                  "init.choice.completionStrategy.localSquash"
+                ),
+                value: "local-squash"
+              },
+              {
+                title: tr(lang, "cli", "init.choice.completionStrategy.none"),
+                value: "none"
+              }
+            ],
+            initial: 0
+          }
+        ],
+        {
+          onCancel: () => {
+            throw new Error("canceled");
+          }
+        }
+      );
+      if (typeof workflowResponse.taskAgent === "boolean") {
+        taskAgentEnabled = workflowResponse.taskAgent;
+      }
+      if (Array.isArray(workflowResponse.reviews)) {
+        enabledReviews = INIT_REVIEW_PHASES.filter(
+          (phase) => workflowResponse.reviews.includes(phase)
+        );
+      }
+      completionStrategy = workflowResponse.completionStrategy || completionStrategy;
+    }
   }
   if (!projectType) {
     projectType = "multi";
@@ -2315,6 +2566,12 @@ async function runInit(options) {
     tr(lang, "cli", "validation.context.workflowMode"),
     lang
   );
+  if (workflowMode !== "local" && options.completionStrategy) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "`--completion-strategy` can only be used with `--workflow local`."
+    );
+  }
   if (projectType === "single") {
     if (components.length > 0) {
       throw createCliError(
@@ -2478,7 +2735,7 @@ async function runInit(options) {
         }
       }
       console.log();
-      console.log(chalk.blue(tr(lang, "cli", "init.log.creatingDocs")));
+      console.log(chalk.blue(tr(lang, "cli", "init.log.configSummaryTitle")));
       console.log(
         chalk.gray(
           `  ${tr(lang, "cli", "init.log.projectLabel")}: ${projectName}`
@@ -2493,6 +2750,35 @@ async function runInit(options) {
       console.log(
         chalk.gray(`  ${tr(lang, "cli", "init.log.pathLabel")}: ${targetDir}`)
       );
+      console.log(
+        chalk.gray(
+          `  ${tr(lang, "cli", "init.log.workflowLabel")}: ${workflowMode}`
+        )
+      );
+      console.log(
+        chalk.gray(
+          `  ${tr(lang, "cli", "init.log.taskAgentLabel")}: ${tr(
+            lang,
+            "cli",
+            taskAgentEnabled ? "init.summary.taskAgent.on" : "init.summary.taskAgent.off"
+          )}`
+        )
+      );
+      const reviewSummary = enabledReviews.length > 0 ? enabledReviews.map((phase) => tr(lang, "cli", `init.choice.review.${phase}`)).join(", ") : tr(lang, "cli", "init.summary.reviews.none");
+      console.log(
+        chalk.gray(
+          `  ${tr(lang, "cli", "init.log.reviewsLabel")}: ${reviewSummary}`
+        )
+      );
+      if (workflowMode === "local") {
+        console.log(
+          chalk.gray(
+            `  ${tr(lang, "cli", "init.log.completionStrategyLabel")}: ${completionStrategy}`
+          )
+        );
+      }
+      console.log();
+      console.log(chalk.blue(tr(lang, "cli", "init.log.creatingDocs")));
       console.log();
       const templatesDir = getTemplatesDir();
       const commonPath = path8.join(templatesDir, lang, "common");
@@ -2541,14 +2827,33 @@ async function runInit(options) {
           taskCommitGate: "warn",
           ...workflowMode === "local" ? {
             baseBranch: resolveInitialBaseBranch(cwd, docsRepo, projectRoot),
-            completionStrategy: "local-ff",
+            completionStrategy,
             deleteFeatureBranchAfterMerge: true,
             featureChecks: [],
             postMergeChecks: []
           } : {},
-          prePrReview: {
-            evidenceMode: "path_required",
-            reviewer: createDefaultPrePrReviewerConfig()
+          agentExecution: {
+            task: {
+              ...createDefaultAgentExecutionTaskConfig(),
+              enabled: taskAgentEnabled
+            }
+          },
+          agentReview: {
+            plan: {
+              enabled: enabledReviews.includes("plan"),
+              evidenceMode: "path_required",
+              reviewer: createDefaultAgentReviewerConfig()
+            },
+            task: {
+              enabled: enabledReviews.includes("task"),
+              evidenceMode: "path_required",
+              reviewer: createDefaultAgentReviewerConfig()
+            },
+            feature: {
+              enabled: enabledReviews.includes("feature"),
+              evidenceMode: "path_required",
+              reviewer: createDefaultAgentReviewerConfig()
+            }
           }
         },
         pr: {
@@ -2765,17 +3070,12 @@ function sanitizeTasksForLocal(content, lang) {
   const lines = next.split("\n");
   const filtered = [];
   for (const line of lines) {
-    if (/^\s*-\s*\*\*(Issue|PR|PR Status|PR 상태|Pre-PR Review|PR 전 리뷰)\*\*\s*:/.test(
+    if (/^\s*-\s*\*\*(Issue|PR|PR Status|PR 상태|PR Review|PR 리뷰|PR Review Evidence|PR 리뷰 Evidence)\*\*\s*:/.test(
       line
     )) {
       continue;
     }
-    if (/^\s*-\s*\*\*(Pre-PR Evidence|PR 전 리뷰 Evidence)\*\*\s*:/.test(
-      line
-    )) {
-      continue;
-    }
-    if (/^\s*-\s*\*\*(Pre-PR Decision|PR Review Decision|PR 전 리뷰 Decision|PR 리뷰 Decision)\*\*\s*:/.test(
+    if (/^\s*-\s*\*\*(PR Review Decision|PR 리뷰 Decision)\*\*\s*:/.test(
       line
     )) {
       continue;
@@ -2789,9 +3089,17 @@ function sanitizeTasksForLocal(content, lang) {
     if (/^\s*-\s*Example:\s*review note link/i.test(line)) continue;
     if (/^\s*-\s*사전 리뷰 최종 결과/.test(line)) continue;
     if (/^\s*-\s*예:\s*리뷰 노트 링크/.test(line)) continue;
+    if (/^\s*-\s*PR creation requires/i.test(line)) continue;
+    if (/^\s*-\s*PR 생성 전/.test(line)) continue;
+    if (/agents\/skills\/create-pr\.md/.test(line)) continue;
+    if (/^\s*-\s*Mark .*PR review handoff/i.test(line)) continue;
+    if (/^\s*-\s*PR 리뷰 handoff/.test(line)) continue;
+    if (/^\s*-\s*Record why\/how review comments/i.test(line)) continue;
+    if (/^\s*-\s*리뷰 지적사항을/.test(line)) continue;
     filtered.push(line);
   }
   next = filtered.join("\n");
+  next = lang === "ko" ? next.replaceAll("**PR \uC804 \uB9AC\uBDF0**", "**Feature \uB9AC\uBDF0**").replaceAll("**PR \uC804 \uB9AC\uBDF0 Evidence**", "**Feature \uB9AC\uBDF0 Evidence**").replaceAll("**PR \uC804 \uB9AC\uBDF0 Decision**", "**Feature \uB9AC\uBDF0 Decision**").replaceAll("**PR \uC804 \uB9AC\uBDF0 Head**", "**Feature \uB9AC\uBDF0 Head**").replaceAll("**PR \uC804 \uB9AC\uBDF0 Tree**", "**Feature \uB9AC\uBDF0 Tree**").replaceAll("pre-PR \uB9AC\uBDF0 handoff", "Feature \uB9AC\uBDF0 handoff") : next.replaceAll("**Pre-PR Review**", "**Feature Review**").replaceAll("**Pre-PR Evidence**", "**Feature Review Evidence**").replaceAll("**Pre-PR Decision**", "**Feature Review Decision**").replaceAll("**Pre-PR Reviewed Head**", "**Feature Reviewed Head**").replaceAll("**Pre-PR Reviewed Tree**", "**Feature Reviewed Tree**").replaceAll("pre-PR review handoff", "Feature review handoff");
   next = next.replace(/feat\/\{issue-number\}-/g, "feat/").replace(/feat\/\{이슈번호\}-/g, "feat/").replace(/feat\/-/g, "feat/");
   return normalizeTrailingBlankLines(next);
 }
@@ -3798,52 +4106,120 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
       }
     }
   }
-  if (!isPlainObject(workflow.prePrReview)) {
-    workflow.prePrReview = {};
-    changedPaths.push("workflow.prePrReview");
+  if (!isPlainObject(workflow.agentExecution)) {
+    workflow.agentExecution = {};
+    changedPaths.push("workflow.agentExecution");
   }
-  const prePrReview = workflow.prePrReview;
+  const agentExecution = workflow.agentExecution;
+  if (!isPlainObject(agentExecution.task)) {
+    agentExecution.task = {};
+    changedPaths.push("workflow.agentExecution.task");
+  }
+  const taskExecution = agentExecution.task;
+  const defaultTaskExecution = createDefaultAgentExecutionTaskConfig();
   setIfMissing(
-    prePrReview,
-    "evidenceMode",
-    "path_required",
-    "workflow.prePrReview.evidenceMode"
-  );
-  if (prePrReview.evidenceMode !== void 0 && prePrReview.evidenceMode !== "path_required" && prePrReview.evidenceMode !== "any") {
-    prePrReview.evidenceMode = "path_required";
-    changedPaths.push("workflow.prePrReview.evidenceMode");
-  }
-  if ("findings" in prePrReview) {
-    delete prePrReview.findings;
-    changedPaths.push("workflow.prePrReview.findings");
-  }
-  const defaultReviewer = createDefaultPrePrReviewerConfig();
-  if (!isPlainObject(prePrReview.reviewer)) {
-    prePrReview.reviewer = defaultReviewer;
-    changedPaths.push("workflow.prePrReview.reviewer");
-  } else {
-    const reviewer = prePrReview.reviewer;
+    taskExecution,
+    "enabled",
+    defaultTaskExecution.enabled,
+    "workflow.agentExecution.task.enabled"
+  );
+  if (typeof taskExecution.enabled !== "boolean") {
+    taskExecution.enabled = defaultTaskExecution.enabled;
+    changedPaths.push("workflow.agentExecution.task.enabled");
+  }
+  if (taskExecution.type !== "subagent") {
+    taskExecution.type = defaultTaskExecution.type;
+    changedPaths.push("workflow.agentExecution.task.type");
+  }
+  if (typeof taskExecution.model !== "string" || !taskExecution.model.trim()) {
+    taskExecution.model = defaultTaskExecution.model;
+    changedPaths.push("workflow.agentExecution.task.model");
+  } else if (taskExecution.model !== taskExecution.model.trim()) {
+    taskExecution.model = taskExecution.model.trim();
+    changedPaths.push("workflow.agentExecution.task.model");
+  }
+  if (typeof taskExecution.reasoningEffort !== "string" || !AGENT_REVIEW_REASONING_EFFORTS.includes(
+    taskExecution.reasoningEffort
+  )) {
+    taskExecution.reasoningEffort = defaultTaskExecution.reasoningEffort;
+    changedPaths.push("workflow.agentExecution.task.reasoningEffort");
+  }
+  if (taskExecution.onUnavailable !== "inherit" && taskExecution.onUnavailable !== "error") {
+    taskExecution.onUnavailable = defaultTaskExecution.onUnavailable;
+    changedPaths.push("workflow.agentExecution.task.onUnavailable");
+  }
+  const legacyPrePrReview = isPlainObject(workflow.prePrReview) ? { ...workflow.prePrReview } : null;
+  if (!isPlainObject(workflow.agentReview)) {
+    workflow.agentReview = {};
+    changedPaths.push("workflow.agentReview");
+  }
+  const agentReview = workflow.agentReview;
+  const normalizeAgentReviewPhase = (key, enabledDefault, legacySeed = null) => {
+    const phasePath = `workflow.agentReview.${key}`;
+    if (!isPlainObject(agentReview[key])) {
+      agentReview[key] = legacySeed ? { ...legacySeed } : {};
+      changedPaths.push(phasePath);
+    }
+    const phase = agentReview[key];
+    setIfMissing(phase, "enabled", enabledDefault, `${phasePath}.enabled`);
+    if (typeof phase.enabled !== "boolean") {
+      phase.enabled = enabledDefault;
+      changedPaths.push(`${phasePath}.enabled`);
+    }
+    setIfMissing(
+      phase,
+      "evidenceMode",
+      "path_required",
+      `${phasePath}.evidenceMode`
+    );
+    if (phase.evidenceMode !== "path_required" && phase.evidenceMode !== "any") {
+      phase.evidenceMode = "path_required";
+      changedPaths.push(`${phasePath}.evidenceMode`);
+    }
+    if ("findings" in phase) {
+      delete phase.findings;
+      changedPaths.push(`${phasePath}.findings`);
+    }
+    const defaultReviewer = createDefaultAgentReviewerConfig();
+    if (!isPlainObject(phase.reviewer)) {
+      phase.reviewer = defaultReviewer;
+      changedPaths.push(`${phasePath}.reviewer`);
+      return;
+    }
+    const reviewer = phase.reviewer;
     if (reviewer.type !== "subagent") {
       reviewer.type = defaultReviewer.type;
-      changedPaths.push("workflow.prePrReview.reviewer.type");
+      changedPaths.push(`${phasePath}.reviewer.type`);
     }
     if (typeof reviewer.model !== "string" || !reviewer.model.trim()) {
       reviewer.model = defaultReviewer.model;
-      changedPaths.push("workflow.prePrReview.reviewer.model");
+      changedPaths.push(`${phasePath}.reviewer.model`);
     } else if (reviewer.model !== reviewer.model.trim()) {
       reviewer.model = reviewer.model.trim();
-      changedPaths.push("workflow.prePrReview.reviewer.model");
+      changedPaths.push(`${phasePath}.reviewer.model`);
     }
-    if (typeof reviewer.reasoningEffort !== "string" || !PRE_PR_REVIEW_REASONING_EFFORTS.includes(
+    if (typeof reviewer.reasoningEffort !== "string" || !AGENT_REVIEW_REASONING_EFFORTS.includes(
       reviewer.reasoningEffort
     )) {
       reviewer.reasoningEffort = defaultReviewer.reasoningEffort;
-      changedPaths.push("workflow.prePrReview.reviewer.reasoningEffort");
+      changedPaths.push(`${phasePath}.reviewer.reasoningEffort`);
     }
     if (reviewer.onUnavailable !== "inherit" && reviewer.onUnavailable !== "error") {
       reviewer.onUnavailable = defaultReviewer.onUnavailable;
-      changedPaths.push("workflow.prePrReview.reviewer.onUnavailable");
+      changedPaths.push(`${phasePath}.reviewer.onUnavailable`);
     }
+  };
+  normalizeAgentReviewPhase("plan", true);
+  normalizeAgentReviewPhase("task", false);
+  const legacyFeatureEnabled = typeof legacyPrePrReview?.enabled === "boolean" ? legacyPrePrReview.enabled : workflow.mode !== "local";
+  normalizeAgentReviewPhase(
+    "feature",
+    legacyFeatureEnabled,
+    legacyPrePrReview
+  );
+  if (hasOwnKey2(workflow, "prePrReview")) {
+    delete workflow.prePrReview;
+    changedPaths.push("workflow.prePrReview");
   }
   if (!isPlainObject(raw.pr)) {
     raw.pr = {};
@@ -4980,7 +5356,7 @@ function extractTaskTitles(tasksContent) {
   return uniqItems(
     tasksContent.split("\n").map((line) => {
       const match = line.match(
-        /^\s*-\s*\[(?:TODO|DOING|DONE)\][^\n]*?\s+(?:T-[A-Z0-9-]+\s+)?(.+?)\s*$/
+        /^\s*-\s*\[(?:TODO|DOING|REVIEW|DONE)\][^\n]*?\s+(?:T-[A-Z0-9-]+\s+)?(.+?)\s*$/
       );
       if (!match) return void 0;
       return sanitizeDraftItem(match[1]);
@@ -7120,7 +7496,11 @@ function formatTaskBlock(input) {
     "  - Acceptance:",
     ...input.acceptanceItems.map((item) => `    - ${item}`),
     "  - Checklist:",
-    ...input.checklistItems.map((item) => `    - [ ] ${item}`)
+    ...input.checklistItems.map((item) => `    - [ ] ${item}`),
+    "  - Review Evidence: -",
+    "  - Review Decision: -",
+    "  - Reviewed Head: -",
+    "  - Reviewed Tree: -"
   ];
 }
 async function runTaskAdd(featureName, options) {
@@ -7548,7 +7928,7 @@ function registerCodexHooksIntegration(parent) {
         removeLeeSpecKitCodexHooks,
         resolveCodexHooksRepoRoot,
         upsertLeeSpecKitCodexHooks
-      } = await import('./hooks-373Z6JG2.js');
+      } = await import('./hooks-67CU3GZC.js');
       const workflowRoot = config.docsRepo === "standalone" ? resolveConfiguredStandaloneWorkspaceRoot(config) : resolveCodexHooksRepoRoot(process.cwd());
       if (!workflowRoot) {
         throw createCliError(
@@ -7724,6 +8104,14 @@ async function resolveLocalIntegrationContext(config, feature) {
   const squashCommitMatchesSource = completionStrategy === "local-squash" && state?.strategy === "local-squash" && !!featureTip && state.featureTip === featureTip && !!integratedCommit && !!baseTip && integratedCommit === baseTip && !!featureTree && integratedTree === featureTree && state.integratedTree === featureTree;
   const squashEvidencePresent = !!featureTip && evidenceTip === featureTip;
   const squashIntegrationComplete = squashCommitMatchesSource && squashEvidencePresent;
+  const recordedStrategy = state?.strategy || "local-ff";
+  const recordedIntegratedCommit = state?.integratedCommit || state?.mergedBaseTip || null;
+  const baseContainsRecordedIntegration = !!recordedIntegratedCommit && isAncestor(
+    projectRoot,
+    recordedIntegratedCommit,
+    `refs/heads/${baseBranch}`
+  );
+  const cleanedIntegrationStillValid = state?.status === "cleaned" && recordedStrategy === completionStrategy && state.featureTip === featureTip && baseContainsRecordedIntegration && (completionStrategy === "local-squash" ? state.integratedCommit === recordedIntegratedCommit && state.integratedTree === featureTree && squashEvidencePresent : state.mergedBaseTip === featureTip && baseContainsFeature);
   return {
     projectRoot,
     featureWorktree: effectiveFeatureWorktree,
@@ -7738,6 +8126,7 @@ async function resolveLocalIntegrationContext(config, feature) {
     completionStrategy,
     baseContainsFeature,
     integrationComplete: completionStrategy === "local-squash" ? squashIntegrationComplete : !!featureTip && baseTip === featureTip,
+    cleanedIntegrationStillValid,
     evidenceRef,
     squashCommitMatchesSource,
     squashEvidencePresent,
@@ -7944,9 +8333,57 @@ var ISSUE_LABELS = ["Issue", "Issue Number", "\uC774\uC288", "\uC774\uC288 \uBC8
 var BRANCH_LABELS3 = ["Branch", "\uBE0C\uB79C\uCE58"];
 var PR_LABELS = ["PR", "Pull Request"];
 var PR_STATUS_LABELS = ["PR Status", "PR \uC0C1\uD0DC"];
-var PRE_PR_REVIEW_LABELS = ["Pre-PR Review", "PR \uC804 \uB9AC\uBDF0"];
-var PRE_PR_EVIDENCE_LABELS = ["Pre-PR Evidence", "PR \uC804 \uB9AC\uBDF0 Evidence"];
-var PRE_PR_DECISION_LABELS = ["Pre-PR Decision", "PR \uC804 \uB9AC\uBDF0 Decision"];
+var PRE_PR_REVIEW_LABELS = [
+  "Pre-PR Review",
+  "PR \uC804 \uB9AC\uBDF0",
+  "Feature Review",
+  "Feature \uB9AC\uBDF0"
+];
+var PRE_PR_EVIDENCE_LABELS = [
+  "Pre-PR Evidence",
+  "PR \uC804 \uB9AC\uBDF0 Evidence",
+  "Feature Review Evidence",
+  "Feature \uB9AC\uBDF0 Evidence"
+];
+var PRE_PR_DECISION_LABELS = [
+  "Pre-PR Decision",
+  "PR \uC804 \uB9AC\uBDF0 Decision",
+  "Feature Review Decision",
+  "Feature \uB9AC\uBDF0 Decision"
+];
+var PRE_PR_REVIEWED_HEAD_LABELS = [
+  "Pre-PR Reviewed Head",
+  "PR \uC804 \uB9AC\uBDF0 Head",
+  "Feature Reviewed Head",
+  "Feature \uB9AC\uBDF0 Head"
+];
+var PRE_PR_REVIEWED_TREE_LABELS = [
+  "Pre-PR Reviewed Tree",
+  "PR \uC804 \uB9AC\uBDF0 Tree",
+  "Feature Reviewed Tree",
+  "Feature \uB9AC\uBDF0 Tree"
+];
+var PLAN_REVIEW_STATUS_LABELS = ["Plan Review", "Plan \uAC80\uC218", "Plan \uB9AC\uBDF0"];
+var PLAN_REVIEW_EVIDENCE_LABELS = [
+  "Plan Review Evidence",
+  "Plan \uAC80\uC218 Evidence",
+  "Plan \uB9AC\uBDF0 Evidence"
+];
+var PLAN_REVIEW_DECISION_LABELS = [
+  "Plan Review Decision",
+  "Plan \uAC80\uC218 Decision",
+  "Plan \uB9AC\uBDF0 Decision"
+];
+var PLAN_REVIEWED_SPEC_HASH_LABELS = [
+  "Plan Reviewed Spec Hash",
+  "Plan \uAC80\uC218 Spec Hash",
+  "Plan \uB9AC\uBDF0 Spec Hash"
+];
+var PLAN_REVIEWED_PLAN_HASH_LABELS = [
+  "Plan Reviewed Plan Hash",
+  "Plan \uAC80\uC218 Plan Hash",
+  "Plan \uB9AC\uBDF0 Plan Hash"
+];
 var COMPLETION_MARKERS = {
   allTasks: "lee-spec-kit:completion:all-tasks",
   tests: "lee-spec-kit:completion:tests",
@@ -7965,7 +8402,10 @@ function resolveWorkflowRequirements(config) {
     requirePr: workflow.requirePr ?? !isLocalWorkflow,
     requireReview: workflow.requireReview ?? !isLocalWorkflow,
     requireMerge: workflow.requireMerge ?? !isLocalWorkflow,
-    prePrReviewEnabled: workflow.prePrReview?.enabled ?? !isLocalWorkflow
+    planReviewEnabled: workflow.agentReview?.plan?.enabled ?? true,
+    taskReviewEnabled: workflow.agentReview?.task?.enabled ?? false,
+    featureReviewEnabled: workflow.agentReview?.feature?.enabled ?? workflow.prePrReview?.enabled ?? !isLocalWorkflow,
+    taskExecutionEnabled: workflow.agentExecution?.task?.enabled ?? true
   };
 }
 function parseApprovalStatus(raw) {
@@ -8016,7 +8456,62 @@ function parseCompletionCheckbox(lines, marker, legacyPattern) {
     (line) => legacyPattern.test(line) && parseMarkdownCheckbox(line) === true
   );
 }
-function parseTasksDoc(content) {
+function parseReviewDecisionOutcome(value) {
+  const match = (value || "").trim().toLowerCase().match(/\b(approve|changes_requested|blocked)\b/);
+  return match?.[1] || null;
+}
+function parseWorkflowTaskLine(line, index = -1) {
+  const canonical = parseTaskLine(line, index);
+  if (canonical) {
+    return {
+      index,
+      raw: line,
+      status: canonical.status,
+      taskId: canonical.taskId,
+      title: canonical.title
+    };
+  }
+  const legacy = line.match(
+    /^\s*-\s*\[(TODO|DOING|DONE|REVIEW)\](?:\[[^\]]+\])*\s+(?:(T-[A-Za-z0-9-]+)\s+)?(.+?)\s*$/i
+  );
+  if (!legacy) return null;
+  return {
+    index,
+    raw: line,
+    status: legacy[1].toUpperCase(),
+    taskId: legacy[2] || null,
+    title: legacy[3].trim()
+  };
+}
+function extractTaskReviewValue(lines, startIndex, labels) {
+  let endIndex = lines.length;
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (parseWorkflowTaskLine(lines[index]) || /^\s*##\s+/.test(lines[index])) {
+      endIndex = index;
+      break;
+    }
+  }
+  for (let index = startIndex + 1; index < endIndex; index += 1) {
+    for (const label of labels) {
+      const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const match = lines[index].match(
+        new RegExp(
+          `^\\s*-\\s*(?:\\*\\*)?${escaped}(?:\\*\\*)?:\\s*(.*?)\\s*$`,
+          "i"
+        )
+      );
+      if (match) return sanitizeMetadataValue2(match[1]);
+    }
+  }
+  return null;
+}
+function buildSyntheticTaskId(feature, title, sameTitleOccurrence) {
+  const fingerprint = createHash("sha256").update(
+    `${feature.folderName}\0${normalizeCommitTopicText(title).toLowerCase()}\0${sameTitleOccurrence}`
+  ).digest("hex").slice(0, 10);
+  return `T-${feature.id}-legacy-${fingerprint}`;
+}
+function parseTasksDoc(content, feature) {
   const issueRaw = extractFieldValue2(content, ISSUE_LABELS);
   const issueNumberMatch = issueRaw?.match(/^#(\d+)$/);
   const issueNumber = issueNumberMatch ? Number(issueNumberMatch[1]) : null;
@@ -8025,15 +8520,43 @@ function parseTasksDoc(content) {
   const prePrDecision = extractFieldValue2(content, PRE_PR_DECISION_LABELS);
   const tasks = [];
   const nonCodeLines = withoutFencedCodeBlocks(content);
-  for (const line of nonCodeLines) {
-    const match = line.match(
-      /^\s*-\s*\[(TODO|DOING|DONE|REVIEW)\](?:\[[^\]]+\])*\s+(.+?)\s*$/i
+  const legacyTitleOccurrences = /* @__PURE__ */ new Map();
+  for (let index = 0; index < nonCodeLines.length; index += 1) {
+    const line = nonCodeLines[index];
+    const parsed = parseWorkflowTaskLine(line, index);
+    if (!parsed) continue;
+    const reviewDecision = extractTaskReviewValue(
+      nonCodeLines,
+      index,
+      ["Review Decision", "Task Review Decision", "\uD0DC\uC2A4\uD06C \uB9AC\uBDF0 Decision"]
     );
-    if (!match) continue;
+    const legacyTitleKey = normalizeCommitTopicText(parsed.title).toLowerCase();
+    const sameTitleOccurrence = (legacyTitleOccurrences.get(legacyTitleKey) || 0) + 1;
+    legacyTitleOccurrences.set(legacyTitleKey, sameTitleOccurrence);
+    const taskId = parsed.taskId || buildSyntheticTaskId(feature, parsed.title, sameTitleOccurrence);
     tasks.push({
       raw: line,
-      status: match[1].toUpperCase(),
-      title: match[2].trim()
+      status: parsed.status,
+      taskId,
+      taskIdSource: parsed.taskId ? "document" : "synthetic",
+      title: parsed.title,
+      reviewEvidence: extractTaskReviewValue(
+        nonCodeLines,
+        index,
+        ["Review Evidence", "Task Review Evidence", "\uD0DC\uC2A4\uD06C \uB9AC\uBDF0 Evidence"]
+      ),
+      reviewDecision,
+      reviewDecisionOutcome: parseReviewDecisionOutcome(reviewDecision),
+      reviewedHead: extractTaskReviewValue(
+        nonCodeLines,
+        index,
+        ["Reviewed Head", "Task Reviewed Head", "\uD0DC\uC2A4\uD06C \uB9AC\uBDF0 Head"]
+      ),
+      reviewedTree: extractTaskReviewValue(
+        nonCodeLines,
+        index,
+        ["Reviewed Tree", "Task Reviewed Tree", "\uD0DC\uC2A4\uD06C \uB9AC\uBDF0 Tree"]
+      )
     });
   }
   const allTasksChecked = parseCompletionCheckbox(
@@ -8064,11 +8587,7 @@ function parseTasksDoc(content) {
     if (value === "done") return "done";
     return null;
   })();
-  const prePrDecisionOutcome = (() => {
-    const value = (prePrDecision || "").trim().toLowerCase();
-    const match = value.match(/\b(approve|changes_requested|blocked)\b/);
-    return match?.[1] || null;
-  })();
+  const prePrDecisionOutcome = parseReviewDecisionOutcome(prePrDecision);
   return {
     docStatus: parseApprovalStatus(
       extractFieldValue2(content, DOC_STATUS_LABELS) || void 0
@@ -8083,6 +8602,12 @@ function parseTasksDoc(content) {
     ),
     prePrDecision: sanitizeMetadataValue2(prePrDecision),
     prePrDecisionOutcome,
+    prePrReviewedHead: sanitizeMetadataValue2(
+      extractFieldValue2(content, PRE_PR_REVIEWED_HEAD_LABELS)
+    ),
+    prePrReviewedTree: sanitizeMetadataValue2(
+      extractFieldValue2(content, PRE_PR_REVIEWED_TREE_LABELS)
+    ),
     tasks,
     completion: {
       allTasksChecked,
@@ -8097,6 +8622,58 @@ function sanitizeMetadataValue2(value) {
   if (!trimmed || trimmed === "-") return null;
   return trimmed;
 }
+function parsePlanReview(content) {
+  const statusValue = sanitizeMetadataValue2(
+    extractFieldValue2(content, PLAN_REVIEW_STATUS_LABELS)
+  )?.toLowerCase();
+  const status = statusValue === "pending" || statusValue === "running" || statusValue === "done" ? statusValue : null;
+  const evidence = sanitizeMetadataValue2(
+    extractFieldValue2(content, PLAN_REVIEW_EVIDENCE_LABELS)
+  );
+  const decision = sanitizeMetadataValue2(
+    extractFieldValue2(content, PLAN_REVIEW_DECISION_LABELS)
+  );
+  const reviewedSpecHash = sanitizeMetadataValue2(
+    extractFieldValue2(content, PLAN_REVIEWED_SPEC_HASH_LABELS)
+  );
+  const reviewedPlanHash = sanitizeMetadataValue2(
+    extractFieldValue2(content, PLAN_REVIEWED_PLAN_HASH_LABELS)
+  );
+  return {
+    status,
+    evidence,
+    decision,
+    decisionOutcome: parseReviewDecisionOutcome(decision),
+    reviewedSpecHash,
+    reviewedPlanHash,
+    hasMetadata: PLAN_REVIEW_STATUS_LABELS.some((label) => {
+      const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(`^\\s*-\\s*\\*\\*${escaped}\\*\\*:`, "mi").test(content);
+    })
+  };
+}
+function buildReviewDocumentHash(content, excludedLabels) {
+  const excluded = new Set(
+    [...excludedLabels, "Status", "\uC0C1\uD0DC"].map((label) => label.toLowerCase())
+  );
+  const normalized = content.replace(/\r\n/g, "\n").split("\n").filter((line) => {
+    const match = line.match(/^\s*-\s*\*\*(.+?)\*\*\s*:/);
+    return !match || !excluded.has(match[1].trim().toLowerCase());
+  }).join("\n").trim();
+  return createHash("sha256").update(normalized).digest("hex");
+}
+function buildPlanReviewTarget(specContent, planContent) {
+  return {
+    specHash: buildReviewDocumentHash(specContent, []),
+    planHash: buildReviewDocumentHash(planContent, [
+      ...PLAN_REVIEW_STATUS_LABELS,
+      ...PLAN_REVIEW_EVIDENCE_LABELS,
+      ...PLAN_REVIEW_DECISION_LABELS,
+      ...PLAN_REVIEWED_SPEC_HASH_LABELS,
+      ...PLAN_REVIEWED_PLAN_HASH_LABELS
+    ])
+  };
+}
 function normalizeCommitTopicText(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -8232,7 +8809,7 @@ function hasOpenTask(tasks) {
 function hasUncommittedChanges(gitCwd) {
   if (!gitCwd) return false;
   const status = runGitCapture(
-    ["status", "--porcelain", "--untracked-files=no"],
+    ["status", "--porcelain", "--untracked-files=normal"],
     gitCwd
   ) || "";
   return status.trim().length > 0;
@@ -8296,7 +8873,7 @@ function resolveProjectCommitTopic(feature, tasks) {
   const activeTask = tasks.tasks.find(
     (task) => task.status === "DOING" || task.status === "REVIEW"
   );
-  const raw = activeTask?.title || getLastDoneTask(tasks)?.title || nextTodoTask(tasks)?.title || feature.folderName;
+  const raw = activeTask?.title || getLastDoneTask(tasks)?.title || tasks.tasks.find((task) => task.status === "TODO")?.title || feature.folderName;
   const withoutTaskId = normalizeCommitTopicText(raw || "").replace(
     /^T-[A-Za-z0-9-]+\s+/,
     ""
@@ -8353,6 +8930,19 @@ function resolveExpectedBranch(feature, tasks) {
   if (!tasks.issueNumber) return null;
   return `feat/${tasks.issueNumber}-${feature.slug}`;
 }
+function buildExpectedBranchCommand(config, feature, expectedBranch, requireWorktree) {
+  if (requireWorktree) {
+    return buildManagedWorktreeCreateCommand(
+      config,
+      feature.git.projectGitCwd,
+      expectedBranch
+    );
+  }
+  return localBranchExists(
+    resolveProjectRootGitCwd(config, feature),
+    expectedBranch
+  ) ? `git checkout ${expectedBranch}` : `git checkout -b ${expectedBranch}`;
+}
 function resolveProjectRootFromGitCwd2(projectGitCwd) {
   return runGitCapture(["rev-parse", "--show-toplevel"], projectGitCwd) || path8.resolve(projectGitCwd);
 }
@@ -8517,19 +9107,96 @@ function buildPostMergeCleanupSummary(state) {
   }
   return `Finish the post-merge cleanup before closing the feature: ${remaining.join(", ")}.`;
 }
-function nextTodoTask(tasks) {
-  return tasks.tasks.find((task) => task.status === "DOING") || tasks.tasks.find((task) => task.status === "TODO") || null;
+function nextExecutableTask(tasks) {
+  return tasks.tasks.find((task) => task.status === "DOING") || tasks.tasks.find((task) => task.status === "REVIEW") || tasks.tasks.find((task) => task.status === "TODO") || tasks.tasks.find((task) => task.status !== "DONE");
 }
 function allTasksDone(tasks) {
   return tasks.tasks.length > 0 && tasks.tasks.every((task) => task.status === "DONE");
 }
-function prePrSatisfied(config, feature, tasks) {
-  return tasks.prePrReviewStatus === "done" && isPrePrEvidenceSatisfied({
+function resolveAgentReviewPhase(config, scope) {
+  if (scope === "plan") {
+    return config.workflow?.agentReview?.plan || {};
+  }
+  if (scope === "task") {
+    return config.workflow?.agentReview?.task || {};
+  }
+  return config.workflow?.agentReview?.feature || config.workflow?.prePrReview || {};
+}
+function resolveProjectReviewTarget(config, projectGitCwd, scope, taskBase = null) {
+  const pathArgs = ["--", "."];
+  const relativeDocsDir = path8.relative(projectGitCwd, config.docsDir);
+  const normalizedDocsDir = normalizeGitRelativePath(relativeDocsDir);
+  if (normalizedDocsDir && normalizedDocsDir !== "." && normalizedDocsDir !== ".." && !normalizedDocsDir.startsWith("../")) {
+    pathArgs.push(`:(exclude)${normalizedDocsDir}/**`);
+  }
+  const targetSha = runGitCapture(["log", "-n", "1", "--pretty=%H", ...pathArgs], projectGitCwd) || runGitCapture(["rev-parse", "HEAD"], projectGitCwd) || "";
+  if (!targetSha) return null;
+  const targetTree = runGitCapture(["rev-parse", `${targetSha}^{tree}`], projectGitCwd) || "";
+  if (!targetTree) return null;
+  let baseSha = "";
+  if (scope === "task" && taskBase) {
+    const actualBaseTree = runGitCapture(
+      ["rev-parse", `${taskBase.reviewedHead}^{tree}`],
+      projectGitCwd
+    ) || "";
+    if (actualBaseTree === taskBase.reviewedTree && taskBase.reviewedHead !== targetSha && isAncestor(projectGitCwd, taskBase.reviewedHead, targetSha)) {
+      baseSha = taskBase.reviewedHead;
+    }
+  }
+  if (!baseSha) {
+    const baseBranch = config.workflow?.baseBranch?.trim() || "main";
+    for (const candidate of [`origin/${baseBranch}`, baseBranch]) {
+      const candidateBase = runGitCapture(["merge-base", candidate, targetSha], projectGitCwd) || "";
+      if (candidateBase && candidateBase !== targetSha) {
+        baseSha = candidateBase;
+        break;
+      }
+    }
+  }
+  if (!baseSha) {
+    baseSha = runGitCapture(["rev-parse", `${targetSha}^`], projectGitCwd) || targetSha;
+  }
+  return { baseSha, targetSha, targetTree };
+}
+function reviewEvidenceSatisfied(config, feature, scope, evidence) {
+  return isPrePrEvidenceSatisfied({
     docsDir: config.docsDir,
     featureDir: feature.path,
-    evidence: tasks.prePrEvidence,
-    evidenceMode: config.workflow?.prePrReview?.evidenceMode
-  }) && !!tasks.prePrDecision && tasks.prePrDecisionOutcome === "approve";
+    evidence,
+    evidenceMode: resolveAgentReviewPhase(config, scope).evidenceMode
+  });
+}
+function planReviewSatisfied(config, feature, review, target) {
+  return review.status === "done" && reviewEvidenceSatisfied(config, feature, "plan", review.evidence) && review.decisionOutcome === "approve" && review.reviewedSpecHash === target.specHash && review.reviewedPlanHash === target.planHash;
+}
+function featureReviewSatisfied(config, feature, tasks, target) {
+  return !!target && tasks.prePrReviewStatus === "done" && reviewEvidenceSatisfied(config, feature, "feature", tasks.prePrEvidence) && !!tasks.prePrDecision && tasks.prePrDecisionOutcome === "approve" && tasks.prePrReviewedHead === target.targetSha && tasks.prePrReviewedTree === target.targetTree;
+}
+function taskReviewEvidenceSatisfied(config, feature, task, target) {
+  return !!target && reviewEvidenceSatisfied(config, feature, "task", task.reviewEvidence) && task.reviewDecisionOutcome === "approve" && task.reviewedHead === target.targetSha && task.reviewedTree === target.targetTree;
+}
+function recordedTaskReviewSatisfied(config, feature, projectGitCwd, task, currentTargetSha) {
+  if (!currentTargetSha || !task.reviewedHead || !task.reviewedTree || task.reviewDecisionOutcome !== "approve" || !reviewEvidenceSatisfied(config, feature, "task", task.reviewEvidence)) {
+    return false;
+  }
+  const actualTree = runGitCapture(
+    ["rev-parse", `${task.reviewedHead}^{tree}`],
+    projectGitCwd
+  ) || "";
+  return actualTree === task.reviewedTree && isAncestor(projectGitCwd, task.reviewedHead, currentTargetSha);
+}
+function resolvePreviousTaskReviewBase(config, feature, tasks, task) {
+  const taskIndex = tasks.tasks.indexOf(task);
+  for (let index = taskIndex - 1; index >= 0; index -= 1) {
+    const previous = tasks.tasks[index];
+    if (previous.reviewDecisionOutcome === "approve" && previous.reviewedHead && previous.reviewedTree && reviewEvidenceSatisfied(config, feature, "task", previous.reviewEvidence)) {
+      return {
+        reviewedHead: previous.reviewedHead,
+        reviewedTree: previous.reviewedTree
+      };
+    }
+  }
+  return null;
 }
 function issueExistsRemotely(issueNumber, feature) {
   if (!issueNumber) return false;
@@ -8549,25 +9216,40 @@ function prExistsRemotely(prRef, feature) {
   );
   return result.code === 0;
 }
-function buildAction(category, summary, approvalRequired, command = null, reviewer) {
+function buildAction(category, summary, approvalRequired, command = null, agent, actionContext) {
   return {
     category,
     summary,
     approvalRequired,
     command,
-    ...reviewer ? {
-      executor: reviewer.type,
-      model: reviewer.model,
-      reasoningEffort: reviewer.reasoningEffort,
-      onUnavailable: reviewer.onUnavailable
-    } : {}
+    ...agent ? {
+      executor: agent.type,
+      model: agent.model,
+      reasoningEffort: agent.reasoningEffort,
+      onUnavailable: agent.onUnavailable
+    } : {},
+    ...actionContext || {}
+  };
+}
+function resolveAgentReviewer(config, scope) {
+  const defaults = createDefaultAgentReviewerConfig();
+  const configured = resolveAgentReviewPhase(config, scope).reviewer;
+  const model = typeof configured?.model === "string" && configured.model.trim() ? configured.model.trim() : defaults.model;
+  const reasoningEffort = AGENT_REVIEW_REASONING_EFFORTS.includes(
+    configured?.reasoningEffort
+  ) ? configured?.reasoningEffort : defaults.reasoningEffort;
+  return {
+    type: "subagent",
+    model,
+    reasoningEffort,
+    onUnavailable: configured?.onUnavailable === "error" ? "error" : defaults.onUnavailable
   };
 }
-function resolvePrePrReviewer(config) {
-  const defaults = createDefaultPrePrReviewerConfig();
-  const configured = config.workflow?.prePrReview?.reviewer;
+function resolveTaskExecutor(config) {
+  const defaults = createDefaultAgentExecutionTaskConfig();
+  const configured = config.workflow?.agentExecution?.task;
   const model = typeof configured?.model === "string" && configured.model.trim() ? configured.model.trim() : defaults.model;
-  const reasoningEffort = PRE_PR_REVIEW_REASONING_EFFORTS.includes(
+  const reasoningEffort = AGENT_REVIEW_REASONING_EFFORTS.includes(
     configured?.reasoningEffort
   ) ? configured?.reasoningEffort : defaults.reasoningEffort;
   return {
@@ -8577,6 +9259,23 @@ function resolvePrePrReviewer(config) {
     onUnavailable: configured?.onUnavailable === "error" ? "error" : defaults.onUnavailable
   };
 }
+function createTaskWorkerContract() {
+  return {
+    role: "task_implementation_worker",
+    executeDirectly: true,
+    spawnSubagents: false,
+    runWorkflowStage: false,
+    editProjectCode: true,
+    runTaskScopedVerification: true,
+    followVerificationContract: true,
+    addUnplannedDurableTests: false,
+    editDocs: false,
+    changeTaskState: false,
+    commit: false,
+    requestApproval: false,
+    remoteActions: false
+  };
+}
 function buildStageOption(label, reply, category, summary, command = null) {
   return {
     label,
@@ -8884,6 +9583,73 @@ function resolveFeatureSelectionError(selection) {
     blockedReasonCode: null
   };
 }
+function resolvePlanReviewPayload(config, feature, review, target) {
+  const targetMatches = review.reviewedSpecHash === target.specHash && review.reviewedPlanHash === target.planHash;
+  const actionContext = {
+    reviewScope: "plan",
+    specHash: target.specHash,
+    planHash: target.planHash,
+    docsDirectory: config.docsDir
+  };
+  if (targetMatches && review.decisionOutcome === "changes_requested") {
+    return {
+      status: "ok",
+      reasonCode: "WORKFLOW_STAGE_RESOLVED",
+      docsDir: config.docsDir,
+      featureRef: buildFeatureRef(feature),
+      stage: "plan_review_fix",
+      nextAction: buildAction(
+        "plan_review_fix",
+        "Address the independent Plan review findings in spec.md or plan.md, keep implementation blocked, and request a fresh review for the resulting document hashes.",
+        false,
+        null,
+        void 0,
+        actionContext
+      ),
+      approvalRequired: false,
+      implementationAllowed: false,
+      blockedReasonCode: "PLAN_REVIEW_NOT_APPROVED"
+    };
+  }
+  if (targetMatches && review.decisionOutcome === "blocked") {
+    return {
+      status: "ok",
+      reasonCode: "WORKFLOW_STAGE_RESOLVED",
+      docsDir: config.docsDir,
+      featureRef: buildFeatureRef(feature),
+      stage: "plan_review",
+      nextAction: buildAction(
+        "plan_review",
+        "Resolve the recorded Plan review blocker before Plan approval.",
+        false,
+        null,
+        void 0,
+        actionContext
+      ),
+      approvalRequired: false,
+      implementationAllowed: false,
+      blockedReasonCode: "PLAN_REVIEW_NOT_APPROVED"
+    };
+  }
+  return {
+    status: "ok",
+    reasonCode: "WORKFLOW_STAGE_RESOLVED",
+    docsDir: config.docsDir,
+    featureRef: buildFeatureRef(feature),
+    stage: "plan_review",
+    nextAction: buildAction(
+      "plan_review",
+      "Delegate a fresh read-only review of spec.md and plan.md. Verify the Verification Contract, NONE/UPDATE/ADD decisions, requirement coverage, independent oracles, stable observation boundaries, realistic failure/rollback cases, exclusions, and focused/full verification scope. Record Plan Review status, evidence, decision, reviewer metadata, Reviewed Spec Hash, and Reviewed Plan Hash without modifying the documents.",
+      false,
+      null,
+      resolveAgentReviewer(config, "plan"),
+      actionContext
+    ),
+    approvalRequired: false,
+    implementationAllowed: false,
+    blockedReasonCode: "PLAN_REVIEW_NOT_APPROVED"
+  };
+}
 async function collectWorkflowStage(cwd, selector, component) {
   const config = await getConfig(cwd);
   if (!config) {
@@ -8918,7 +9684,13 @@ async function collectWorkflowStage(cwd, selector, component) {
   const planStatus = parseApprovalStatus(
     extractFieldValue2(planContent || "", ["Status", "\uC0C1\uD0DC"]) || void 0
   );
-  const tasks = parseTasksDoc(tasksContent || "");
+  const tasks = parseTasksDoc(tasksContent || "", feature);
+  const planReview = parsePlanReview(planContent || "");
+  const planReviewTarget = buildPlanReviewTarget(
+    specContent || "",
+    planContent || ""
+  );
+  const enforcePlanReview = requirements.planReviewEnabled && (tasks.docStatus !== "approved" || planReview.hasMetadata);
   const issueDraft = parseWorkflowDraftMetadataExtended(issueContent || "");
   const prDraft = parseWorkflowDraftMetadataExtended(prContent || "");
   const remoteReviewState = requirements.requireReview && tasks.prLink ? resolveRemotePrReviewState(tasks.prLink, feature) : "unknown";
@@ -8954,6 +9726,14 @@ async function collectWorkflowStage(cwd, selector, component) {
   }
   if (planStatus !== "approved") {
     const isReviewStage = planStatus === "review";
+    if (isReviewStage && enforcePlanReview && !planReviewSatisfied(config, feature, planReview, planReviewTarget)) {
+      return resolvePlanReviewPayload(
+        config,
+        feature,
+        planReview,
+        planReviewTarget
+      );
+    }
     const approvalRequired = isReviewStage ? resolveActionApprovalRequired(config, "plan_approve", true) : false;
     const actionOptions = approvalRequired ? buildApprovalActionOptions({
       approveSummary: "Approve plan.md and continue to the tasks stage.",
@@ -8977,6 +9757,9 @@ async function collectWorkflowStage(cwd, selector, component) {
       blockedReasonCode: "PLAN_NOT_APPROVED"
     };
   }
+  if (enforcePlanReview && !planReviewSatisfied(config, feature, planReview, planReviewTarget)) {
+    return resolvePlanReviewPayload(config, feature, planReview, planReviewTarget);
+  }
   if (tasks.tasks.length === 0 || tasks.docStatus !== "approved") {
     const isReviewStage = tasks.docStatus === "review";
     const approvalRequired = isReviewStage ? resolveActionApprovalRequired(config, "tasks_approve", true) : false;
@@ -9055,7 +9838,12 @@ async function collectWorkflowStage(cwd, selector, component) {
     const expectedBranch = resolveExpectedBranch(feature, tasks);
     const currentBranch = runGitCapture(["branch", "--show-current"], effectiveProjectGitCwd) || runGitCapture(["rev-parse", "--abbrev-ref", "HEAD"], effectiveProjectGitCwd) || null;
     if (expectedBranch && currentBranch !== expectedBranch) {
-      const branchCommand = requirements.requireWorktree ? buildManagedWorktreeCreateCommand(config, feature.git.projectGitCwd, expectedBranch) : `git checkout -b ${expectedBranch}`;
+      const branchCommand = buildExpectedBranchCommand(
+        config,
+        feature,
+        expectedBranch,
+        requirements.requireWorktree
+      );
       return {
         status: "ok",
         reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -9078,6 +9866,151 @@ async function collectWorkflowStage(cwd, selector, component) {
   const lastDoneTask = getLastDoneTask(tasks);
   const docsDirty = hasUncommittedChanges(feature.git.docsGitCwd);
   const projectDirty = hasUncommittedChanges(effectiveProjectGitCwd);
+  const currentTaskReviewTip = requirements.taskReviewEnabled ? resolveProjectReviewTarget(config, effectiveProjectGitCwd, "task") : null;
+  const unreviewedDoneTask = requirements.taskReviewEnabled ? tasks.tasks.find(
+    (task) => task.status === "DONE" && !recordedTaskReviewSatisfied(
+      config,
+      feature,
+      effectiveProjectGitCwd,
+      task,
+      currentTaskReviewTip?.targetSha || null
+    )
+  ) || null : null;
+  const reviewTask = unreviewedDoneTask || tasks.tasks.find((task) => task.status === "REVIEW") || null;
+  if (requirements.taskReviewEnabled && reviewTask) {
+    if (docsDirty || projectDirty) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "task_commit",
+        nextAction: buildAction(
+          "task_commit",
+          buildTaskCommitSummary({
+            feature,
+            tasks,
+            effectiveProjectGitCwd,
+            docsDirty,
+            projectDirty,
+            gateFailureReason: "the task must have a clean checkpoint commit before independent review"
+          }),
+          false
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "TASK_COMMIT_REQUIRED"
+      };
+    }
+    const reviewTarget = resolveProjectReviewTarget(
+      config,
+      effectiveProjectGitCwd,
+      "task",
+      resolvePreviousTaskReviewBase(config, feature, tasks, reviewTask)
+    );
+    if (!reviewTarget) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "task_commit",
+        nextAction: buildAction(
+          "task_commit",
+          "Create a project commit for the task before requesting independent review.",
+          false
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "TASK_COMMIT_REQUIRED"
+      };
+    }
+    const reviewContext = {
+      reviewScope: "task",
+      ...reviewTask.taskId ? { taskId: reviewTask.taskId } : {},
+      ...reviewTarget
+    };
+    const evidenceMatchesTarget = reviewTask.reviewedHead === reviewTarget.targetSha && reviewTask.reviewedTree === reviewTarget.targetTree;
+    if (evidenceMatchesTarget && reviewTask.reviewDecisionOutcome === "changes_requested") {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        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 a fresh review.`,
+          false,
+          null,
+          void 0,
+          reviewContext
+        ),
+        approvalRequired: false,
+        implementationAllowed: true,
+        blockedReasonCode: "TASK_REVIEW_NOT_APPROVED"
+      };
+    }
+    if (evidenceMatchesTarget && reviewTask.reviewDecisionOutcome === "blocked") {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "task_review",
+        nextAction: buildAction(
+          "task_review",
+          `Resolve the recorded review blocker for ${reviewTask.taskId || reviewTask.title} before continuing.`,
+          false,
+          null,
+          void 0,
+          reviewContext
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "TASK_REVIEW_NOT_APPROVED"
+      };
+    }
+    if (taskReviewEvidenceSatisfied(config, feature, reviewTask, reviewTarget)) {
+      const completionSummary = 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.`;
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "task_review",
+        nextAction: buildAction(
+          "task_review_complete",
+          completionSummary,
+          false,
+          null,
+          void 0,
+          reviewContext
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "TASK_REVIEW_NOT_APPROVED"
+      };
+    }
+    return {
+      status: "ok",
+      reasonCode: "WORKFLOW_STAGE_RESOLVED",
+      docsDir: config.docsDir,
+      featureRef: buildFeatureRef(feature),
+      stage: "task_review",
+      nextAction: buildAction(
+        "task_review",
+        `Delegate a fresh read-only review of ${reviewTask.taskId || reviewTask.title} for ${reviewTarget.baseSha}..${reviewTarget.targetSha}. Record evidence, decision, reviewer metadata, Reviewed Head, and Reviewed Tree without modifying code.`,
+        false,
+        null,
+        resolveAgentReviewer(config, "task"),
+        reviewContext
+      ),
+      approvalRequired: false,
+      implementationAllowed: false,
+      blockedReasonCode: "TASK_REVIEW_NOT_APPROVED"
+    };
+  }
   const pendingDoneTransitions = countPendingDoneTransitions(feature) || 0;
   const taskCommitCheckpointRequired = !activeTaskOpen && !!lastDoneTask && (projectDirty || pendingDoneTransitions > 0);
   if (taskCommitCheckpointRequired) {
@@ -9107,8 +10040,135 @@ async function collectWorkflowStage(cwd, selector, component) {
   }
   const committedTaskGate = taskCommitGatePolicy !== "off" && lastDoneTask ? checkTaskCommitGate(feature, effectiveProjectGitCwd, lastDoneTask) : { pass: true };
   const committedTaskGateRequiresCheckpoint = taskCommitGatePolicy === "strict" || committedTaskGate.reason === "DONE_TRANSITIONS_COUNT";
+  if (committedTaskGateRequiresCheckpoint && !committedTaskGate.pass) {
+    return {
+      status: "ok",
+      reasonCode: "WORKFLOW_STAGE_RESOLVED",
+      docsDir: config.docsDir,
+      featureRef: buildFeatureRef(feature),
+      stage: "task_commit",
+      nextAction: buildAction(
+        "task_commit",
+        buildTaskCommitSummary({
+          feature,
+          tasks,
+          effectiveProjectGitCwd,
+          docsDirty,
+          projectDirty,
+          gateFailureReason: describeTaskCommitGateFailure(committedTaskGate)
+        }),
+        false
+      ),
+      approvalRequired: false,
+      implementationAllowed: false,
+      blockedReasonCode: "TASK_COMMIT_REQUIRED"
+    };
+  }
+  let resolvedLocalState = null;
+  if (allTasksDone(tasks) && config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) !== "none") {
+    resolvedLocalState = await resolveLocalIntegrationContext(config, feature);
+  }
+  const remoteReviewAlreadyComplete = currentReviewState === "merged" && tasks.prStatus === "approved" && prDraft.prStatus === "approved";
+  const featureReviewNeededForLifecycle = allTasksDone(tasks) && requirements.featureReviewEnabled && !resolvedLocalState?.integrationComplete && !remoteReviewAlreadyComplete;
+  if (featureReviewNeededForLifecycle) {
+    const expectedBranch = resolveExpectedBranch(feature, tasks);
+    const currentBranch = runGitCapture(["branch", "--show-current"], effectiveProjectGitCwd) || runGitCapture(
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      effectiveProjectGitCwd
+    ) || null;
+    if (requirements.requireBranch && expectedBranch && currentBranch !== expectedBranch) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "branch",
+        nextAction: buildAction(
+          "branch_create",
+          requirements.requireWorktree ? `Restore or create the managed worktree for ${expectedBranch} before Feature review.` : `Switch back to ${expectedBranch} before Feature review.`,
+          false,
+          buildExpectedBranchCommand(
+            config,
+            feature,
+            expectedBranch,
+            requirements.requireWorktree
+          )
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "BRANCH_NOT_READY"
+      };
+    }
+    const reviewTarget = resolveProjectReviewTarget(
+      config,
+      effectiveProjectGitCwd,
+      "feature"
+    );
+    const reviewContext = reviewTarget ? { reviewScope: "feature", ...reviewTarget } : null;
+    const evidenceMatchesTarget = !!reviewTarget && tasks.prePrReviewedHead === reviewTarget.targetSha && tasks.prePrReviewedTree === reviewTarget.targetTree;
+    if (reviewContext && evidenceMatchesTarget && tasks.prePrDecisionOutcome === "changes_requested") {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "feature_review_fix",
+        nextAction: buildAction(
+          "feature_review_fix",
+          "Address the Feature review findings, commit the remediation, and request a fresh review of the new code tree before implementation approval.",
+          false,
+          null,
+          void 0,
+          reviewContext
+        ),
+        approvalRequired: false,
+        implementationAllowed: true,
+        blockedReasonCode: "PRE_PR_REVIEW_NOT_APPROVED"
+      };
+    }
+    if (reviewContext && evidenceMatchesTarget && tasks.prePrDecisionOutcome === "blocked") {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "pre_pr_review",
+        nextAction: buildAction(
+          "pre_pr_review",
+          "Resolve the recorded Feature review blocker before implementation approval or integration.",
+          false,
+          null,
+          void 0,
+          reviewContext
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "PRE_PR_REVIEW_NOT_APPROVED"
+      };
+    }
+    if (!featureReviewSatisfied(config, feature, tasks, reviewTarget)) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "pre_pr_review",
+        nextAction: buildAction(
+          "pre_pr_review",
+          reviewTarget ? `Delegate an independent read-only Feature review to a fresh subagent for ${reviewTarget.baseSha}..${reviewTarget.targetSha}. Record 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,
+          reviewContext || void 0
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "PRE_PR_REVIEW_NOT_APPROVED"
+      };
+    }
+  }
   if (!allTasksDone(tasks)) {
-    const currentTask = nextTodoTask(tasks);
+    const currentTask = nextExecutableTask(tasks);
     if (committedTaskGateRequiresCheckpoint && !committedTaskGate.pass) {
       return {
         status: "ok",
@@ -9135,6 +10195,7 @@ async function collectWorkflowStage(cwd, selector, component) {
     }
     const commitWarning = taskCommitGatePolicy === "warn" && !committedTaskGate.pass ? `
 Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)}` : "";
+    const delegationGuidance = requirements.taskExecutionEnabled ? " Delegate implementation and task-scoped verification to a fresh configured subagent under the returned workerContract. The worker executes directly and must not run workflow-stage or delegate again. The main agent retains docs updates, task state transitions, commits, approvals, and remote actions" : "";
     return {
       status: "ok",
       reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -9143,8 +10204,20 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       stage: "implementation",
       nextAction: buildAction(
         "task_execute",
-        currentTask ? `Continue the next implementation task: ${currentTask.title}${commitWarning}` : "Continue the active implementation task.",
-        false
+        `Continue the next implementation task: ${currentTask.title}.${delegationGuidance}${requirements.taskReviewEnabled ? " When implementation and checks are complete, move it to REVIEW instead of DONE" : ""}${commitWarning}`,
+        false,
+        null,
+        requirements.taskExecutionEnabled ? resolveTaskExecutor(config) : void 0,
+        {
+          taskId: currentTask.taskId,
+          taskIdSource: currentTask.taskIdSource,
+          taskTitle: currentTask.title,
+          workingDirectory: effectiveProjectGitCwd,
+          ...requirements.taskExecutionEnabled ? {
+            docsDirectory: config.docsDir,
+            workerContract: createTaskWorkerContract()
+          } : {}
+        }
       ),
       approvalRequired: false,
       implementationAllowed: true,
@@ -9208,29 +10281,23 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       blockedReasonCode: "IMPLEMENTATION_APPROVAL_REQUIRED"
     };
   }
-  if (requirements.prePrReviewEnabled && !prePrSatisfied(config, feature, tasks)) {
-    return {
-      status: "ok",
-      reasonCode: "WORKFLOW_STAGE_RESOLVED",
-      docsDir: config.docsDir,
-      featureRef: buildFeatureRef(feature),
-      stage: "pre_pr_review",
-      nextAction: buildAction(
-        "pre_pr_review",
-        "Delegate an independent read-only Pre-PR review to a fresh subagent and record its findings, decision, and reviewer metadata as evidence.",
-        false,
-        null,
-        resolvePrePrReviewer(config)
-      ),
-      approvalRequired: false,
-      implementationAllowed: false,
-      blockedReasonCode: "PRE_PR_REVIEW_NOT_APPROVED"
-    };
-  }
   if (config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) !== "none") {
-    const localState = await resolveLocalIntegrationContext(config, feature);
+    const localState = resolvedLocalState || await resolveLocalIntegrationContext(config, feature);
     const localVerifyCommand = `npx lee-spec-kit local verify ${buildFeatureArgs(feature)} --json`;
     const localMergeBaseCommand = `npx lee-spec-kit local merge ${buildFeatureArgs(feature)} --json`;
+    if (localState.cleanedIntegrationStillValid) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "done",
+        nextAction: null,
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: null
+      };
+    }
     if (!localState.integrationComplete) {
       const featureVerified = !!localState.state && ["feature_verified", "merged", "verified", "cleaned"].includes(
         localState.state.status