lee-spec-kit 0.8.7 → 0.9.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { hasLeeSpecKitCodexBootstrap } from './chunk-LYFRLOFQ.js';
+import { hasLeeSpecKitCodexBootstrap } from './chunk-3AFCPGGS.js';
 import { runGitCapture, runGitOrThrow } from './chunk-GR7JQBWF.js';
 import { __dirname as __dirname$1 } from './chunk-7V7RMGEU.js';
 import { program } from 'commander';
@@ -10,7 +10,8 @@ import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 import { spawn, execFileSync, spawnSync } from 'child_process';
 import os from 'os';
-import { createHash } from 'crypto';
+import crypto, { createHash } from 'crypto';
+import fs21 from 'fs';
 
 async function walkFiles(fsAdapter, rootDir, options = {}) {
   const out = [];
@@ -236,14 +237,15 @@ var koCli = {
   "idea.nextSteps1": "  1. \uBC94\uC704, PRD Refs, \uC2B9\uACA9 \uBA54\uBAA8\uB97C \uC791\uC131",
   "idea.nextSteps2": "  2. Feature\uB85C \uC2B9\uACA9: npx lee-spec-kit feature <name> --idea {ideaId}",
   "idea.nextSteps3": "  3. Feature\uB85C \uB9CC\uB4E4\uC9C0 \uC54A\uC744 \uACBD\uC6B0 Dropped\uB85C \uD45C\uC2DC",
-  "setup.codexBootstrapInstalled": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC124\uCE58 \uC644\uB8CC: {path}",
-  "setup.codexBootstrapAlreadyInstalled": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC774 \uC774\uBBF8 \uC124\uCE58\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4: {path}",
-  "setup.codexBootstrapRemoved": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC81C\uAC70 \uC644\uB8CC: {path}",
-  "setup.codexBootstrapAlreadyAbsent": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC774 \uC774\uBBF8 \uC5C6\uC2B5\uB2C8\uB2E4: {path}",
-  "setup.codexHooksInstalled": "\u2705 Repo-local Codex hooks \uC124\uCE58 \uC644\uB8CC: {path}",
-  "setup.codexHooksAlreadyInstalled": "\u2705 Repo-local Codex hooks \uAC00 \uC774\uBBF8 \uC124\uCE58\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4: {path}",
-  "setup.codexHooksRemoved": "\u2705 Repo-local Codex hooks \uC81C\uAC70 \uC644\uB8CC: {path}",
-  "setup.codexHooksAlreadyAbsent": "\u2705 Repo-local Codex hooks \uAC00 \uC774\uBBF8 \uC5C6\uC2B5\uB2C8\uB2E4: {path}",
+  "integrations.codexBootstrapInstalled": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC124\uCE58 \uC644\uB8CC: {path}",
+  "integrations.codexBootstrapAlreadyInstalled": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC774 \uC774\uBBF8 \uC124\uCE58\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4: {path}",
+  "integrations.codexBootstrapRemoved": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC81C\uAC70 \uC644\uB8CC: {path}",
+  "integrations.codexBootstrapAlreadyAbsent": "\u2705 \uC120\uD0DD\uC801 Codex bootstrap \uC774 \uC774\uBBF8 \uC5C6\uC2B5\uB2C8\uB2E4: {path}",
+  "integrations.codexHooksInstalled": "\u2705 Repo-local Codex hooks \uC124\uCE58 \uC644\uB8CC: {path}",
+  "integrations.codexHooksAlreadyInstalled": "\u2705 Repo-local Codex hooks \uAC00 \uC774\uBBF8 \uC124\uCE58\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4: {path}",
+  "integrations.codexHooksRemoved": "\u2705 Repo-local Codex hooks \uC81C\uAC70 \uC644\uB8CC: {path}",
+  "integrations.codexHooksAlreadyAbsent": "\u2705 Repo-local Codex hooks \uAC00 \uC774\uBBF8 \uC5C6\uC2B5\uB2C8\uB2E4: {path}",
+  "integrations.codexHooksTrustRequired": "Codex\uC5D0\uC11C /hooks\uB97C \uC2E4\uD589\uD574 \uC124\uCE58\uB41C \uD504\uB85C\uC81D\uD2B8 \uD6C5\uC744 \uAC80\uD1A0\uD558\uACE0 \uC2E0\uB8B0\uD558\uC138\uC694. \uD6C5 \uC815\uC758\uAC00 \uBCC0\uACBD\uB418\uBA74 \uB2E4\uC2DC \uAC80\uD1A0\uD574\uC57C \uD569\uB2C8\uB2E4.",
   "github.cmdGithubDescription": "GitHub \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uB3C4\uC6B0\uBBF8 (issue/pr \uBCF8\uBB38 \uD15C\uD50C\uB9BF \uC0DD\uC131, \uAC80\uC99D, merge \uC7AC\uC2DC\uB3C4)",
   "github.cmdIssueDescription": "feature \uBB38\uC11C \uAE30\uBC18 GitHub issue \uBCF8\uBB38 \uC0DD\uC131/\uC0DD\uC131",
   "github.cmdPrDescription": "GitHub PR \uBCF8\uBB38 \uC0DD\uC131/\uC0DD\uC131 + tasks \uB3D9\uAE30\uD654 + merge \uC7AC\uC2DC\uB3C4",
@@ -518,14 +520,15 @@ var enCli = {
   "idea.nextSteps1": "  1. Fill scope, PRD refs, and promotion notes",
   "idea.nextSteps2": "  2. Promote it with: npx lee-spec-kit feature <name> --idea {ideaId}",
   "idea.nextSteps3": "  3. Mark it dropped if it should not become a feature",
-  "setup.codexBootstrapInstalled": "\u2705 Optional Codex bootstrap installed: {path}",
-  "setup.codexBootstrapAlreadyInstalled": "\u2705 Optional Codex bootstrap already installed: {path}",
-  "setup.codexBootstrapRemoved": "\u2705 Optional Codex bootstrap removed: {path}",
-  "setup.codexBootstrapAlreadyAbsent": "\u2705 Optional Codex bootstrap is already absent: {path}",
-  "setup.codexHooksInstalled": "\u2705 Repo-local Codex hooks installed: {path}",
-  "setup.codexHooksAlreadyInstalled": "\u2705 Repo-local Codex hooks already installed: {path}",
-  "setup.codexHooksRemoved": "\u2705 Repo-local Codex hooks removed: {path}",
-  "setup.codexHooksAlreadyAbsent": "\u2705 Repo-local Codex hooks are already absent: {path}",
+  "integrations.codexBootstrapInstalled": "\u2705 Optional Codex bootstrap installed: {path}",
+  "integrations.codexBootstrapAlreadyInstalled": "\u2705 Optional Codex bootstrap already installed: {path}",
+  "integrations.codexBootstrapRemoved": "\u2705 Optional Codex bootstrap removed: {path}",
+  "integrations.codexBootstrapAlreadyAbsent": "\u2705 Optional Codex bootstrap is already absent: {path}",
+  "integrations.codexHooksInstalled": "\u2705 Repo-local Codex hooks installed: {path}",
+  "integrations.codexHooksAlreadyInstalled": "\u2705 Repo-local Codex hooks already installed: {path}",
+  "integrations.codexHooksRemoved": "\u2705 Repo-local Codex hooks removed: {path}",
+  "integrations.codexHooksAlreadyAbsent": "\u2705 Repo-local Codex hooks are already absent: {path}",
+  "integrations.codexHooksTrustRequired": "Review and trust the installed project hooks with /hooks in Codex. Changed hook definitions require review again.",
   "github.cmdGithubDescription": "GitHub workflow helpers (issue/pr templates, validation, merge retry)",
   "github.cmdIssueDescription": "Generate/create GitHub issue body from feature docs with validation",
   "github.cmdPrDescription": "Generate/create GitHub PR body with validation, tasks PR sync, and merge retry",
@@ -1301,6 +1304,10 @@ 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 merge\` / \`local cleanup\` commands until \`workflow-stage\` proves integration, verification, and cleanup and returns \`done\`
+16. In a \`local-ff\` workflow, present the implementation approval summary exactly as returned because that checkpoint authorizes the remaining fast-forward integration, post-merge checks, and configured local cleanup; ask again at \`local_merge\` only when that category is explicitly configured as required
 
 Approval and remote actions:
 
@@ -1882,6 +1889,14 @@ var DEFAULT_APPROVAL_REQUIRE_CHECK_CATEGORIES = [
   "spec_approve",
   "implementation_approve"
 ];
+var PRE_PR_REVIEW_REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+];
 function createDefaultApprovalConfig() {
   return {
     mode: "category",
@@ -1889,6 +1904,14 @@ function createDefaultApprovalConfig() {
     requireCheckCategories: [...DEFAULT_APPROVAL_REQUIRE_CHECK_CATEGORIES]
   };
 }
+function createDefaultPrePrReviewerConfig() {
+  return {
+    type: "subagent",
+    model: "inherit",
+    reasoningEffort: "high",
+    onUnavailable: "inherit"
+  };
+}
 
 // src/commands/init.ts
 function checkGitRepo(cwd) {
@@ -1915,6 +1938,25 @@ function getGitTopLevelOrNull(cwd) {
     return null;
   }
 }
+function getCurrentBranchOrMain(cwd) {
+  try {
+    const branch = execFileSync("git", ["branch", "--show-current"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return branch || "main";
+  } catch {
+    return "main";
+  }
+}
+function resolveInitialBaseBranch(cwd, docsRepo, projectRoot) {
+  if (docsRepo === "standalone") {
+    const firstProjectRoot = resolveStandaloneInitProjectRoots(projectRoot, cwd)[0];
+    if (firstProjectRoot) return getCurrentBranchOrMain(firstProjectRoot);
+  }
+  return getCurrentBranchOrMain(getGitTopLevelOrNull(cwd) || cwd);
+}
 function isSameOrWithinDir(parentDir, candidateDir) {
   const resolvedParent = path8.resolve(parentDir);
   const resolvedCandidate = path8.resolve(candidateDir);
@@ -2484,21 +2526,19 @@ async function runInit(options) {
         createdAt: getLocalDateString(),
         docsRepo,
         workflow: {
-          preset: workflowMode,
           mode: workflowMode,
           requireWorktree: docsRepo === "standalone",
           codeDirtyScope: "auto",
           taskCommitGate: "warn",
-          auto: {
-            defaultPreset: "pr-handoff"
-          },
+          ...workflowMode === "local" ? {
+            baseBranch: resolveInitialBaseBranch(cwd, docsRepo, projectRoot),
+            completionStrategy: "local-ff",
+            deleteFeatureBranchAfterMerge: true,
+            postMergeChecks: []
+          } : {},
           prePrReview: {
-            skills: ["code-review-excellence"],
-            fallback: "builtin-checklist",
             evidenceMode: "path_required",
-            decisionEnum: ["approve", "changes_requested", "blocked"],
-            enforceExecutionEvidence: false,
-            executionCommandPrefixes: []
+            reviewer: createDefaultPrePrReviewerConfig()
           }
         },
         pr: {
@@ -3316,9 +3356,118 @@ async function getNextIdeaId(docsDir) {
   const width = Math.max(3, String(next).length);
   return `I${String(next).padStart(width, "0")}`;
 }
+
+// src/config/legacy-approval.ts
+var LEGACY_APPROVAL_CATEGORY_STEPS = [
+  ["spec_write", 2],
+  ["spec_approve", 3],
+  ["plan_write", 4],
+  ["plan_approve", 5],
+  ["tasks_write", 6],
+  ["tasks_approve", 6],
+  ["issue_prepare", 8],
+  ["issue_create", 8],
+  ["branch_create", 9],
+  ["task_execute", 10],
+  ["implementation_approve", 10],
+  ["pre_pr_review", 12],
+  ["pr_prepare", 13],
+  ["pr_create", 13],
+  ["code_review", 14],
+  ["pr_merge", 14]
+];
+
+// src/config/migrate.ts
+var OBSOLETE_PRE_PR_REVIEW_KEYS = [
+  "skills",
+  "fallback",
+  "decisionEnum",
+  "enforceExecutionEvidence",
+  "executionCommandPrefixes"
+];
 function hasOwnKey(value, key) {
   return Object.prototype.hasOwnProperty.call(value, key);
 }
+function isPlainRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function migrateLegacyWorkflowSettings(workflow) {
+  const changedPaths = [];
+  const hasCanonicalMode = workflow.mode === "github" || workflow.mode === "local";
+  const legacyPreset = workflow.preset;
+  const canonicalMode = hasCanonicalMode ? workflow.mode : legacyPreset === "local" ? "local" : "github";
+  if (workflow.mode !== canonicalMode) {
+    workflow.mode = canonicalMode;
+    changedPaths.push("workflow.mode");
+  }
+  if (!hasCanonicalMode && legacyPreset === "strict" && workflow.requireWorktree === void 0) {
+    workflow.requireWorktree = true;
+    changedPaths.push("workflow.requireWorktree");
+  }
+  if (hasOwnKey(workflow, "preset")) {
+    delete workflow.preset;
+    changedPaths.push("workflow.preset");
+  }
+  if (hasOwnKey(workflow, "auto")) {
+    delete workflow.auto;
+    changedPaths.push("workflow.auto");
+  }
+  if (isPlainRecord(workflow.prePrReview)) {
+    const prePrReview = workflow.prePrReview;
+    for (const key of OBSOLETE_PRE_PR_REVIEW_KEYS) {
+      if (!hasOwnKey(prePrReview, key)) continue;
+      delete prePrReview[key];
+      changedPaths.push(`workflow.prePrReview.${key}`);
+    }
+  }
+  return changedPaths;
+}
+function migrateLegacyApprovalSettings(approval) {
+  if (approval.mode === "steps") {
+    const requiredSteps = new Set(
+      (Array.isArray(approval.requireCheckSteps) ? approval.requireCheckSteps : []).map(
+        (value) => typeof value === "number" ? value : Number(value)
+      ).filter((value) => Number.isFinite(value))
+    );
+    const requireCheckCategories = [];
+    const skipCheckCategories = [];
+    for (const [category, step] of LEGACY_APPROVAL_CATEGORY_STEPS) {
+      if (requiredSteps.has(step)) {
+        requireCheckCategories.push(category);
+      } else {
+        skipCheckCategories.push(category);
+      }
+    }
+    const migratedApproval = { ...approval };
+    delete migratedApproval.requireCheckSteps;
+    delete migratedApproval.taskExecuteCheck;
+    return {
+      approval: {
+        ...migratedApproval,
+        mode: "category",
+        default: "keep",
+        requireCheckCategories,
+        skipCheckCategories
+      },
+      changedPaths: ["approval"]
+    };
+  }
+  const changedPaths = [];
+  if (hasOwnKey(approval, "requireCheckSteps")) {
+    delete approval.requireCheckSteps;
+    changedPaths.push("approval.requireCheckSteps");
+  }
+  if (hasOwnKey(approval, "taskExecuteCheck")) {
+    delete approval.taskExecuteCheck;
+    changedPaths.push("approval.taskExecuteCheck");
+  }
+  return { approval, changedPaths };
+}
+
+// src/commands/update.ts
+function hasOwnKey2(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
 function isLegacyGeneratedApprovalConfig(approval) {
   const mode = typeof approval.mode === "string" ? approval.mode : "";
   if (mode && mode !== "category" && mode !== "steps" && mode !== "builtin") {
@@ -3328,10 +3477,9 @@ function isLegacyGeneratedApprovalConfig(approval) {
     "default",
     "requireCheckSteps",
     "requireCheckCategories",
-    "skipCheckCategories",
-    "taskExecuteCheck"
+    "skipCheckCategories"
   ];
-  return !overrideKeys.some((key) => hasOwnKey(approval, key));
+  return !overrideKeys.some((key) => hasOwnKey2(approval, key));
 }
 function updateCommand(program2) {
   program2.command("update").description("Update docs templates to the latest version").option("--agents", "Update agents/ folder only").option("--agents-md", "Sync project-scoped AGENTS.md entrypoint").option(
@@ -3517,38 +3665,6 @@ async function collectAgentsMdTargets(cwd, config) {
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeSkillList(raw) {
-  if (!Array.isArray(raw)) return [];
-  const deduped = /* @__PURE__ */ new Set();
-  for (const item of raw) {
-    const value = String(item || "").trim();
-    if (!value) continue;
-    deduped.add(value);
-  }
-  return [...deduped];
-}
-function normalizeStringList(raw) {
-  if (!Array.isArray(raw)) return [];
-  const deduped = /* @__PURE__ */ new Set();
-  for (const item of raw) {
-    const value = String(item || "").trim();
-    if (!value) continue;
-    deduped.add(value);
-  }
-  return [...deduped];
-}
-function normalizeDecisionEnumList(raw) {
-  if (!Array.isArray(raw)) return [];
-  const deduped = /* @__PURE__ */ new Set();
-  for (const item of raw) {
-    const value = String(item || "").trim().toLowerCase();
-    if (!value) continue;
-    if (value === "approve" || value === "changes_requested" || value === "blocked") {
-      deduped.add(value);
-    }
-  }
-  return [...deduped];
-}
 async function backfillMissingConfigDefaults(cwd, docsDir) {
   const configPath = path8.join(docsDir, ".lee-spec-kit.json");
   if (!await fs.pathExists(configPath)) {
@@ -3576,9 +3692,7 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
     changedPaths.push("workflow");
   }
   const workflow = raw.workflow;
-  const inferredPreset = workflow.mode === "local" ? "local" : "github";
-  setIfMissing(workflow, "preset", inferredPreset, "workflow.preset");
-  setIfMissing(workflow, "mode", "github", "workflow.mode");
+  changedPaths.push(...migrateLegacyWorkflowSettings(workflow));
   setIfMissing(
     workflow,
     "requireWorktree",
@@ -3591,31 +3705,62 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
   }
   setIfMissing(workflow, "codeDirtyScope", "auto", "workflow.codeDirtyScope");
   setIfMissing(workflow, "taskCommitGate", "warn", "workflow.taskCommitGate");
-  if (!isPlainObject(workflow.auto)) {
-    workflow.auto = {};
-    changedPaths.push("workflow.auto");
+  if (workflow.mode === "local") {
+    setIfMissing(workflow, "baseBranch", "main", "workflow.baseBranch");
+    if (typeof workflow.baseBranch !== "string" || !workflow.baseBranch.trim()) {
+      workflow.baseBranch = "main";
+      changedPaths.push("workflow.baseBranch");
+    } else if (workflow.baseBranch !== workflow.baseBranch.trim()) {
+      workflow.baseBranch = workflow.baseBranch.trim();
+      changedPaths.push("workflow.baseBranch");
+    }
+    setIfMissing(
+      workflow,
+      "completionStrategy",
+      "none",
+      "workflow.completionStrategy"
+    );
+    if (workflow.completionStrategy !== "local-ff" && workflow.completionStrategy !== "none") {
+      workflow.completionStrategy = "none";
+      changedPaths.push("workflow.completionStrategy");
+    }
+    setIfMissing(
+      workflow,
+      "deleteFeatureBranchAfterMerge",
+      true,
+      "workflow.deleteFeatureBranchAfterMerge"
+    );
+    if (typeof workflow.deleteFeatureBranchAfterMerge !== "boolean") {
+      workflow.deleteFeatureBranchAfterMerge = true;
+      changedPaths.push("workflow.deleteFeatureBranchAfterMerge");
+    }
+    setIfMissing(workflow, "postMergeChecks", [], "workflow.postMergeChecks");
+    if (!Array.isArray(workflow.postMergeChecks)) {
+      workflow.postMergeChecks = [];
+      changedPaths.push("workflow.postMergeChecks");
+    } else {
+      const normalizedPostMergeChecks = workflow.postMergeChecks.flatMap(
+        (value) => {
+          if (!isPlainObject(value) || typeof value.command !== "string") {
+            return [];
+          }
+          const command = value.command.trim();
+          if (!command) return [];
+          const args = Array.isArray(value.args) ? value.args.filter((arg) => typeof arg === "string") : [];
+          return [{ command, ...args.length > 0 ? { args } : {} }];
+        }
+      );
+      if (JSON.stringify(normalizedPostMergeChecks) !== JSON.stringify(workflow.postMergeChecks)) {
+        workflow.postMergeChecks = normalizedPostMergeChecks;
+        changedPaths.push("workflow.postMergeChecks");
+      }
+    }
   }
-  const workflowAuto = workflow.auto;
-  setIfMissing(workflowAuto, "defaultPreset", "pr-handoff", "workflow.auto.defaultPreset");
   if (!isPlainObject(workflow.prePrReview)) {
     workflow.prePrReview = {};
     changedPaths.push("workflow.prePrReview");
   }
   const prePrReview = workflow.prePrReview;
-  if (prePrReview.skills === void 0) {
-    prePrReview.skills = ["code-review-excellence"];
-    changedPaths.push("workflow.prePrReview.skills");
-  } else {
-    const normalizedSkills = normalizeSkillList(prePrReview.skills);
-    if (normalizedSkills.length === 0) {
-      prePrReview.skills = ["code-review-excellence"];
-      changedPaths.push("workflow.prePrReview.skills");
-    } else if (JSON.stringify(normalizedSkills) !== JSON.stringify(prePrReview.skills)) {
-      prePrReview.skills = normalizedSkills;
-      changedPaths.push("workflow.prePrReview.skills");
-    }
-  }
-  setIfMissing(prePrReview, "fallback", "builtin-checklist", "workflow.prePrReview.fallback");
   setIfMissing(
     prePrReview,
     "evidenceMode",
@@ -3630,35 +3775,32 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
     delete prePrReview.findings;
     changedPaths.push("workflow.prePrReview.findings");
   }
-  if (prePrReview.decisionEnum === void 0) {
-    prePrReview.decisionEnum = ["approve", "changes_requested", "blocked"];
-    changedPaths.push("workflow.prePrReview.decisionEnum");
+  const defaultReviewer = createDefaultPrePrReviewerConfig();
+  if (!isPlainObject(prePrReview.reviewer)) {
+    prePrReview.reviewer = defaultReviewer;
+    changedPaths.push("workflow.prePrReview.reviewer");
   } else {
-    const normalizedDecisionEnum = normalizeDecisionEnumList(prePrReview.decisionEnum);
-    if (normalizedDecisionEnum.length === 0) {
-      prePrReview.decisionEnum = ["approve", "changes_requested", "blocked"];
-      changedPaths.push("workflow.prePrReview.decisionEnum");
-    } else if (JSON.stringify(normalizedDecisionEnum) !== JSON.stringify(prePrReview.decisionEnum)) {
-      prePrReview.decisionEnum = normalizedDecisionEnum;
-      changedPaths.push("workflow.prePrReview.decisionEnum");
+    const reviewer = prePrReview.reviewer;
+    if (reviewer.type !== "subagent") {
+      reviewer.type = defaultReviewer.type;
+      changedPaths.push("workflow.prePrReview.reviewer.type");
+    }
+    if (typeof reviewer.model !== "string" || !reviewer.model.trim()) {
+      reviewer.model = defaultReviewer.model;
+      changedPaths.push("workflow.prePrReview.reviewer.model");
+    } else if (reviewer.model !== reviewer.model.trim()) {
+      reviewer.model = reviewer.model.trim();
+      changedPaths.push("workflow.prePrReview.reviewer.model");
+    }
+    if (typeof reviewer.reasoningEffort !== "string" || !PRE_PR_REVIEW_REASONING_EFFORTS.includes(
+      reviewer.reasoningEffort
+    )) {
+      reviewer.reasoningEffort = defaultReviewer.reasoningEffort;
+      changedPaths.push("workflow.prePrReview.reviewer.reasoningEffort");
     }
-  }
-  setIfMissing(
-    prePrReview,
-    "enforceExecutionEvidence",
-    false,
-    "workflow.prePrReview.enforceExecutionEvidence"
-  );
-  if (prePrReview.executionCommandPrefixes === void 0) {
-    prePrReview.executionCommandPrefixes = [];
-    changedPaths.push("workflow.prePrReview.executionCommandPrefixes");
-  } else {
-    const normalizedExecutionCommandPrefixes = normalizeStringList(
-      prePrReview.executionCommandPrefixes
-    );
-    if (JSON.stringify(normalizedExecutionCommandPrefixes) !== JSON.stringify(prePrReview.executionCommandPrefixes)) {
-      prePrReview.executionCommandPrefixes = normalizedExecutionCommandPrefixes;
-      changedPaths.push("workflow.prePrReview.executionCommandPrefixes");
+    if (reviewer.onUnavailable !== "inherit" && reviewer.onUnavailable !== "error") {
+      reviewer.onUnavailable = defaultReviewer.onUnavailable;
+      changedPaths.push("workflow.prePrReview.reviewer.onUnavailable");
     }
   }
   if (!isPlainObject(raw.pr)) {
@@ -3677,7 +3819,10 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
     changedPaths.push("approval");
   } else {
     const approval = raw.approval;
-    if (isLegacyGeneratedApprovalConfig(approval)) {
+    const migration = migrateLegacyApprovalSettings(approval);
+    raw.approval = migration.approval;
+    changedPaths.push(...migration.changedPaths);
+    if (isPlainObject(raw.approval) && isLegacyGeneratedApprovalConfig(raw.approval)) {
       raw.approval = createDefaultApprovalConfig();
       changedPaths.push("approval");
     }
@@ -7298,30 +7443,27 @@ async function runDetect(options) {
 function registerCodexIntegration(parent) {
   parent.command("codex").alias("codex-bootstrap").description(
     "Install or remove the optional Codex bootstrap that re-reads the current workspace ./AGENTS.md"
-  ).option(
-    "--remove",
-    "Remove the lee-spec-kit managed Codex bootstrap block"
-  ).action(async (options) => {
+  ).option("--remove", "Remove the lee-spec-kit managed Codex bootstrap block").action(async (options) => {
     const lang = DEFAULT_LANG;
     try {
       const {
         getCodexConfigPath,
         removeLeeSpecKitCodexBootstrap,
         upsertLeeSpecKitCodexBootstrap
-      } = await import('./bootstrap-G37N6RGB.js');
+      } = await import('./bootstrap-Q77MTW3Q.js');
       const filePath = getCodexConfigPath();
       if (options.remove) {
         const result2 = await removeLeeSpecKitCodexBootstrap(filePath);
-        const message = result2.changed ? tr(lang, "cli", "setup.codexBootstrapRemoved", {
+        const message = result2.changed ? tr(lang, "cli", "integrations.codexBootstrapRemoved", {
           path: filePath
-        }) : tr(lang, "cli", "setup.codexBootstrapAlreadyAbsent", {
+        }) : tr(lang, "cli", "integrations.codexBootstrapAlreadyAbsent", {
           path: filePath
         });
         console.log(chalk.green(message));
         return;
       }
       const result = await upsertLeeSpecKitCodexBootstrap(filePath);
-      const key = result.action === "noop" ? "setup.codexBootstrapAlreadyInstalled" : "setup.codexBootstrapInstalled";
+      const key = result.action === "noop" ? "integrations.codexBootstrapAlreadyInstalled" : "integrations.codexBootstrapInstalled";
       console.log(chalk.green(tr(lang, "cli", key, { path: filePath })));
     } catch (error) {
       const cliError = toCliError(error);
@@ -7338,7 +7480,10 @@ function registerCodexIntegration(parent) {
 function registerCodexHooksIntegration(parent) {
   parent.command("codex-hooks").description(
     "Install or remove workspace-local Codex official hooks for the lee-spec-kit docs workflow"
-  ).option("--remove", "Remove lee-spec-kit managed workspace-local Codex hooks").action(async (options) => {
+  ).option(
+    "--remove",
+    "Remove lee-spec-kit managed workspace-local Codex hooks"
+  ).action(async (options) => {
     const lang = DEFAULT_LANG;
     try {
       const config = await getConfig(process.cwd());
@@ -7353,24 +7498,42 @@ function registerCodexHooksIntegration(parent) {
         removeLeeSpecKitCodexHooks,
         resolveCodexHooksRepoRoot,
         upsertLeeSpecKitCodexHooks
-      } = await import('./hooks-UUAAVDS3.js');
-      const repoRoot = config.docsRepo === "standalone" ? resolveConfiguredStandaloneWorkspaceRoot(config) : resolveCodexHooksRepoRoot(process.cwd());
-      if (!repoRoot) {
+      } = await import('./hooks-373Z6JG2.js');
+      const workflowRoot = config.docsRepo === "standalone" ? resolveConfiguredStandaloneWorkspaceRoot(config) : resolveCodexHooksRepoRoot(process.cwd());
+      if (!workflowRoot) {
         throw createCliError(
           "PRECONDITION_FAILED",
           "Standalone workspaceRoot is missing or invalid. Run `npx lee-spec-kit update --agents-md` from the shared workspace root to migrate this project."
         );
       }
-      const filePath = getRepoHooksConfigPath(repoRoot);
+      const repoRoots = config.docsRepo === "standalone" ? [workflowRoot, ...resolveStandaloneProjectRoots(config)] : [workflowRoot];
+      const uniqueRepoRoots = [...new Set(repoRoots)];
+      const filePaths = uniqueRepoRoots.map(
+        (repoRoot) => getRepoHooksConfigPath(repoRoot)
+      );
+      const displayPath = filePaths.join(", ");
       if (options.remove) {
-        const result2 = await removeLeeSpecKitCodexHooks(repoRoot);
-        const key2 = result2.changed ? "setup.codexHooksRemoved" : "setup.codexHooksAlreadyAbsent";
-        console.log(chalk.green(tr(lang, "cli", key2, { path: filePath })));
+        const results2 = await Promise.all(
+          uniqueRepoRoots.map(
+            (repoRoot) => removeLeeSpecKitCodexHooks(repoRoot)
+          )
+        );
+        const key2 = results2.some((result) => result.changed) ? "integrations.codexHooksRemoved" : "integrations.codexHooksAlreadyAbsent";
+        console.log(chalk.green(tr(lang, "cli", key2, { path: displayPath })));
         return;
       }
-      const result = await upsertLeeSpecKitCodexHooks(repoRoot);
-      const key = result.action === "noop" ? "setup.codexHooksAlreadyInstalled" : "setup.codexHooksInstalled";
-      console.log(chalk.green(tr(lang, "cli", key, { path: filePath })));
+      const results = await Promise.all(
+        uniqueRepoRoots.map(
+          (repoRoot) => upsertLeeSpecKitCodexHooks(repoRoot, workflowRoot)
+        )
+      );
+      const key = results.every((result) => result.action === "noop") ? "integrations.codexHooksAlreadyInstalled" : "integrations.codexHooksInstalled";
+      console.log(chalk.green(tr(lang, "cli", key, { path: displayPath })));
+      console.log(
+        chalk.yellow(
+          tr(lang, "cli", "integrations.codexHooksTrustRequired")
+        )
+      );
     } catch (error) {
       const cliError = toCliError(error);
       const suggestions = getCliErrorSuggestions(cliError.code, lang);
@@ -7388,27 +7551,227 @@ function integrationsCommand(program2) {
   registerCodexIntegration(integrations);
   registerCodexHooksIntegration(integrations);
 }
-var LEGACY_STEP_BY_ACTION = {
-  spec_write: 2,
-  spec_approve: 3,
-  plan_write: 4,
-  plan_approve: 5,
-  tasks_write: 6,
-  tasks_approve: 6,
-  issue_prepare: 8,
-  issue_create: 8,
-  branch_create: 9,
-  task_execute: 10,
-  implementation_approve: 10,
-  pre_pr_review: 12,
-  pr_prepare: 13,
-  pr_create: 13,
-  code_review: 14,
-  pr_merge: 14
-};
+function isSameOrWithin2(parentDir, candidatePath) {
+  const relative = path8.relative(parentDir, candidatePath);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
+}
+function isPrePrEvidenceSatisfied(check) {
+  const evidence = check.evidence?.trim();
+  if (!evidence) return false;
+  if (check.evidenceMode === "any") return true;
+  const normalizedEvidence = evidence.replaceAll("\\", "/");
+  const docsDir = path8.resolve(check.docsDir);
+  const candidates = /* @__PURE__ */ new Set();
+  if (path8.isAbsolute(normalizedEvidence)) {
+    candidates.add(path8.resolve(normalizedEvidence));
+  } else {
+    candidates.add(path8.resolve(docsDir, normalizedEvidence));
+    candidates.add(path8.resolve(check.featureDir, normalizedEvidence));
+    const [evidenceRoot, ...evidenceParts] = normalizedEvidence.split("/");
+    if (evidenceRoot?.toLowerCase() === path8.basename(docsDir).toLowerCase() && evidenceParts.length > 0) {
+      candidates.add(path8.resolve(docsDir, ...evidenceParts));
+    }
+  }
+  let realDocsDir;
+  try {
+    realDocsDir = fs21.realpathSync(docsDir);
+  } catch {
+    return false;
+  }
+  for (const candidate of candidates) {
+    try {
+      const realCandidate = fs21.realpathSync(candidate);
+      if (!isSameOrWithin2(realDocsDir, realCandidate)) continue;
+      if (fs21.statSync(realCandidate).isFile()) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+var BRANCH_LABELS2 = ["Branch", "\uBE0C\uB79C\uCE58"];
+function resolveLocalCompletionStrategy(config) {
+  return config.workflow?.completionStrategy === "local-ff" ? "local-ff" : "none";
+}
+async function resolveLocalIntegrationContext(config, feature) {
+  const projectRoot = resolveProjectRoot(config, feature);
+  const featureWorktree = path8.resolve(feature.git.projectGitCwd);
+  const baseBranch = String(config.workflow?.baseBranch || "main").trim() || "main";
+  assertValidBranch(projectRoot, baseBranch, "baseBranch");
+  const tasksContent = await readTasks(feature.path);
+  const configuredFeatureBranch = extractMetadataValue(
+    tasksContent,
+    BRANCH_LABELS2
+  );
+  const featureBranch = configuredFeatureBranch || `feat/${feature.slug}`;
+  assertValidBranch(projectRoot, featureBranch, "feature branch");
+  if (featureBranch === baseBranch) {
+    throw new Error(
+      "Local feature branch must differ from workflow.baseBranch."
+    );
+  }
+  const state = await readLocalIntegrationState(projectRoot, feature);
+  const featureBranchTip = resolveRef(
+    projectRoot,
+    `refs/heads/${featureBranch}`
+  );
+  const featureTip = featureBranchTip || state?.featureTip || null;
+  const baseTip = resolveRef(projectRoot, `refs/heads/${baseBranch}`);
+  const currentBranch = currentGitBranch(projectRoot);
+  const registeredWorktree = resolveRegisteredBranchWorktree(
+    projectRoot,
+    featureBranch
+  );
+  const managedFeatureWorktree = !!registeredWorktree && path8.resolve(registeredWorktree) !== path8.resolve(projectRoot);
+  const effectiveFeatureWorktree = registeredWorktree || (fs.existsSync(featureWorktree) ? featureWorktree : projectRoot);
+  return {
+    projectRoot,
+    featureWorktree: effectiveFeatureWorktree,
+    docsGitCwd: feature.git.docsGitCwd,
+    baseBranch,
+    featureBranch,
+    featureTip,
+    baseTip,
+    currentBranch,
+    state,
+    baseContainsFeature: !!featureTip && !!baseTip && isAncestor(projectRoot, featureTip, `refs/heads/${baseBranch}`),
+    projectRootClean: isClean(projectRoot),
+    featureWorktreeClean: isClean(effectiveFeatureWorktree),
+    docsClean: isClean(feature.git.docsGitCwd),
+    managedFeatureWorktree,
+    featureBranchExists: !!featureBranchTip,
+    postMergeChecks: normalizePostMergeChecks(config.workflow?.postMergeChecks),
+    deleteFeatureBranchAfterMerge: config.workflow?.deleteFeatureBranchAfterMerge !== false
+  };
+}
+async function writeLocalIntegrationState(projectRoot, feature, state) {
+  const statePath = resolveStatePath(projectRoot, feature);
+  await fs.ensureDir(path8.dirname(statePath));
+  await fs.writeJson(statePath, state, { spaces: 2 });
+}
+async function readLocalIntegrationState(projectRoot, feature) {
+  const statePath = resolveStatePath(projectRoot, feature);
+  if (!await fs.pathExists(statePath)) return null;
+  try {
+    const state = await fs.readJson(statePath);
+    if (state?.version !== 1 || state.featureRef !== feature.folderName || typeof state.featureTip !== "string") {
+      return null;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+function localCleanupComplete(context) {
+  return context.baseContainsFeature && context.currentBranch === context.baseBranch && !context.managedFeatureWorktree && (!context.deleteFeatureBranchAfterMerge || !context.featureBranchExists) && context.projectRootClean && context.docsClean && context.state?.status === "cleaned" && context.state.featureTip === context.featureTip && context.state.mergedBaseTip === context.baseTip;
+}
+function runPostMergeChecks(projectRoot, checks) {
+  const results = [];
+  for (const check of checks) {
+    const args = Array.isArray(check.args) ? check.args.map(String) : [];
+    const result = runProcess(check.command, args, projectRoot);
+    results.push({
+      command: check.command,
+      args,
+      exitCode: result.code
+    });
+    if (result.code !== 0) break;
+  }
+  return results;
+}
+function gitRun(cwd, args) {
+  return runProcess("git", args, cwd);
+}
+function currentGitBranch(cwd) {
+  return runGitCapture(["branch", "--show-current"], cwd) || runGitCapture(["rev-parse", "--abbrev-ref", "HEAD"], cwd) || null;
+}
+function resolveRef(cwd, ref) {
+  return runGitCapture(["rev-parse", "--verify", ref], cwd) || null;
+}
+function isAncestor(cwd, ancestor, descendant) {
+  return runProcess(
+    "git",
+    ["merge-base", "--is-ancestor", ancestor, descendant],
+    cwd
+  ).code === 0;
+}
+function resolveProjectRoot(config, feature) {
+  if (config.docsRepo === "standalone") {
+    const roots = resolveStandaloneProjectRoots(
+      config,
+      feature.type === "single" ? void 0 : feature.type
+    );
+    if (roots[0]) return path8.resolve(roots[0]);
+  }
+  return runGitCapture(
+    ["rev-parse", "--show-toplevel"],
+    feature.git.projectGitCwd
+  ) || path8.resolve(feature.git.projectGitCwd);
+}
+function resolveStatePath(projectRoot, feature) {
+  const commonDirRaw = runGitCapture(["rev-parse", "--git-common-dir"], projectRoot) || ".git";
+  const commonDir = path8.isAbsolute(commonDirRaw) ? commonDirRaw : path8.resolve(projectRoot, commonDirRaw);
+  const key = crypto.createHash("sha256").update(`${feature.type}:${feature.folderName}`).digest("hex").slice(0, 24);
+  return path8.join(
+    commonDir,
+    "lee-spec-kit",
+    "local-integrations",
+    `${key}.json`
+  );
+}
+async function readTasks(featureDir) {
+  const tasksPath = path8.join(featureDir, "tasks.md");
+  return await fs.pathExists(tasksPath) ? fs.readFile(tasksPath, "utf-8") : "";
+}
+function extractMetadataValue(content, labels) {
+  for (const label of labels) {
+    const match = content.match(
+      new RegExp(`^\\s*-\\s*\\*\\*${label}\\*\\*:\\s*(.*?)\\s*$`, "mi")
+    );
+    const value = String(match?.[1] || "").trim().replace(/^`(.+)`$/, "$1");
+    if (value && value !== "-") return value;
+  }
+  return null;
+}
+function assertValidBranch(cwd, branch, label) {
+  if (runProcess("git", ["check-ref-format", "--branch", branch], cwd).code !== 0) {
+    throw new Error(`Invalid ${label}: ${branch}`);
+  }
+}
+function isClean(cwd) {
+  return (runGitCapture(
+    ["status", "--porcelain", "--untracked-files=normal"],
+    cwd
+  ) || "") === "";
+}
+function resolveRegisteredBranchWorktree(projectRoot, branch) {
+  const output = runGitCapture(["worktree", "list", "--porcelain"], projectRoot) || "";
+  let currentPath = null;
+  for (const line of output.split(/\r?\n/u)) {
+    if (line.startsWith("worktree ")) {
+      currentPath = line.slice("worktree ".length).trim();
+      continue;
+    }
+    if (line === `branch refs/heads/${branch}` && currentPath) {
+      return currentPath;
+    }
+  }
+  return null;
+}
+function normalizePostMergeChecks(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (entry) => !!entry && typeof entry === "object" && typeof entry.command === "string" && !!entry.command.trim()
+  ).map((entry) => ({
+    command: entry.command.trim(),
+    args: Array.isArray(entry.args) ? entry.args.map(String) : []
+  }));
+}
+
+// src/utils/workflow-stage.ts
 var DOC_STATUS_LABELS = ["Doc Status", "\uBB38\uC11C \uC0C1\uD0DC"];
 var ISSUE_LABELS = ["Issue", "Issue Number", "\uC774\uC288", "\uC774\uC288 \uBC88\uD638"];
-var BRANCH_LABELS2 = ["Branch", "\uBE0C\uB79C\uCE58"];
+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"];
@@ -7416,12 +7779,14 @@ var PRE_PR_EVIDENCE_LABELS = ["Pre-PR Evidence", "PR \uC804 \uB9AC\uBDF0 Evidenc
 var PRE_PR_DECISION_LABELS = ["Pre-PR Decision", "PR \uC804 \uB9AC\uBDF0 Decision"];
 function resolveWorkflowRequirements(config) {
   const workflow = config.workflow || {};
-  const workflowMode = workflow.mode || workflow.preset || "github";
+  const hasCanonicalMode = workflow.mode === "github" || workflow.mode === "local";
+  const workflowMode = hasCanonicalMode ? workflow.mode : workflow.preset === "local" ? "local" : "github";
   const isLocalWorkflow = workflowMode === "local";
+  const legacyStrictRequiresWorktree = !hasCanonicalMode && workflow.preset === "strict";
   return {
     requireIssue: workflow.requireIssue ?? !isLocalWorkflow,
     requireBranch: workflow.requireBranch ?? true,
-    requireWorktree: config.docsRepo === "standalone" ? true : workflow.requireWorktree ?? false,
+    requireWorktree: config.docsRepo === "standalone" ? true : workflow.requireWorktree ?? legacyStrictRequiresWorktree,
     requirePr: workflow.requirePr ?? !isLocalWorkflow,
     requireReview: workflow.requireReview ?? !isLocalWorkflow,
     requireMerge: workflow.requireMerge ?? !isLocalWorkflow,
@@ -7470,7 +7835,7 @@ function parseTasksDoc(content) {
   const issueRaw = extractFieldValue2(content, ISSUE_LABELS);
   const issueNumberMatch = issueRaw?.match(/^#(\d+)$/);
   const issueNumber = issueNumberMatch ? Number(issueNumberMatch[1]) : null;
-  const branchRaw = extractFieldValue2(content, BRANCH_LABELS2);
+  const branchRaw = extractFieldValue2(content, BRANCH_LABELS3);
   const prRaw = extractFieldValue2(content, PR_LABELS);
   const prePrDecision = extractFieldValue2(content, PRE_PR_DECISION_LABELS);
   const tasks = [];
@@ -7964,8 +8329,13 @@ function nextTodoTask(tasks) {
 function allTasksDone(tasks) {
   return tasks.tasks.length > 0 && tasks.tasks.every((task) => task.status === "DONE");
 }
-function prePrSatisfied(tasks) {
-  return tasks.prePrReviewStatus === "done" && !!tasks.prePrEvidence && !!tasks.prePrDecision && tasks.prePrDecisionOutcome === "approve";
+function prePrSatisfied(config, feature, tasks) {
+  return tasks.prePrReviewStatus === "done" && isPrePrEvidenceSatisfied({
+    docsDir: config.docsDir,
+    featureDir: feature.path,
+    evidence: tasks.prePrEvidence,
+    evidenceMode: config.workflow?.prePrReview?.evidenceMode
+  }) && !!tasks.prePrDecision && tasks.prePrDecisionOutcome === "approve";
 }
 function issueExistsRemotely(issueNumber, feature) {
   if (!issueNumber) return false;
@@ -7985,12 +8355,32 @@ function prExistsRemotely(prRef, feature) {
   );
   return result.code === 0;
 }
-function buildAction(category, summary, approvalRequired, command = null) {
+function buildAction(category, summary, approvalRequired, command = null, reviewer) {
   return {
     category,
     summary,
     approvalRequired,
-    command
+    command,
+    ...reviewer ? {
+      executor: reviewer.type,
+      model: reviewer.model,
+      reasoningEffort: reviewer.reasoningEffort,
+      onUnavailable: reviewer.onUnavailable
+    } : {}
+  };
+}
+function resolvePrePrReviewer(config) {
+  const defaults = createDefaultPrePrReviewerConfig();
+  const configured = config.workflow?.prePrReview?.reviewer;
+  const model = typeof configured?.model === "string" && configured.model.trim() ? configured.model.trim() : defaults.model;
+  const reasoningEffort = PRE_PR_REVIEW_REASONING_EFFORTS.includes(
+    configured?.reasoningEffort
+  ) ? configured?.reasoningEffort : defaults.reasoningEffort;
+  return {
+    type: "subagent",
+    model,
+    reasoningEffort,
+    onUnavailable: configured?.onUnavailable === "error" ? "error" : defaults.onUnavailable
   };
 }
 function buildStageOption(label, reply, category, summary, command = null) {
@@ -8012,7 +8402,9 @@ function resolveActionApprovalRequired(config, category, builtinRequiresUserChec
     const requiredSteps = new Set(
       (approval.requireCheckSteps ?? []).map((value) => typeof value === "number" ? value : Number(value)).filter((value) => Number.isFinite(value))
     );
-    const legacyStep = LEGACY_STEP_BY_ACTION[category];
+    const legacyStep = LEGACY_APPROVAL_CATEGORY_STEPS.find(
+      ([legacyCategory]) => legacyCategory === category
+    )?.[1];
     return typeof legacyStep === "number" ? requiredSteps.has(legacyStep) : builtinRequiresUserCheck;
   }
   const requiredCategories = new Set(
@@ -8595,8 +8987,11 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       "implementation_approve",
       true
     );
+    const localIntegrationApproval = config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) === "local-ff";
+    const localBaseBranch = config.workflow?.baseBranch?.trim() || "main";
+    const localCleanupSummary = config.workflow?.deleteFeatureBranchAfterMerge === false ? "remove any managed Feature worktree" : "remove any managed Feature worktree and delete the integrated local Feature branch";
     const actionOptions = approvalRequired ? buildApprovalActionOptions({
-      approveSummary: "Approve the completed implementation and continue to the pre-PR or PR preparation stage.",
+      approveSummary: localIntegrationApproval ? `Approve the completed implementation and authorize fast-forward integration into ${localBaseBranch}, post-merge verification, and cleanup that will ${localCleanupSummary}.` : "Approve the completed implementation and continue to the pre-PR or PR preparation stage.",
       holdSummary: "Request implementation changes before the workflow continues."
     }) : void 0;
     return {
@@ -8607,7 +9002,7 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       stage: "implementation_approve",
       nextAction: buildAction(
         "implementation_approve",
-        "Share the completed implementation, get user approval, and record the completion checkpoint in tasks.md.",
+        localIntegrationApproval ? `Share the completed implementation and get user approval for the remaining local completion flow: fast-forward into ${localBaseBranch}, run post-merge checks, then ${localCleanupSummary}. Record that approval in tasks.md.` : "Share the completed implementation, get user approval, and record the completion checkpoint in tasks.md.",
         approvalRequired
       ),
       approvalRequired,
@@ -8617,7 +9012,7 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       blockedReasonCode: "IMPLEMENTATION_APPROVAL_REQUIRED"
     };
   }
-  if (requirements.prePrReviewEnabled && !prePrSatisfied(tasks)) {
+  if (requirements.prePrReviewEnabled && !prePrSatisfied(config, feature, tasks)) {
     return {
       status: "ok",
       reasonCode: "WORKFLOW_STAGE_RESOLVED",
@@ -8626,14 +9021,97 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       stage: "pre_pr_review",
       nextAction: buildAction(
         "pre_pr_review",
-        "Run and record the Pre-PR review until tasks.md shows an approve decision with evidence.",
-        false
+        "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) === "local-ff") {
+    const localState = await resolveLocalIntegrationContext(config, feature);
+    const localMergeBaseCommand = `npx lee-spec-kit local merge ${buildFeatureArgs(feature)} --json`;
+    if (!localState.baseContainsFeature) {
+      const approvalRequired = resolveActionApprovalRequired(
+        config,
+        "local_merge",
+        false
+      );
+      const command = approvalRequired ? `${localMergeBaseCommand} --confirm OK` : localMergeBaseCommand;
+      const actionOptions = approvalRequired ? buildApprovalActionOptions({
+        approveSummary: `Fast-forward ${localState.featureBranch} into ${localState.baseBranch} and run the configured post-merge checks.`,
+        holdSummary: "Keep the completed Feature branch unmerged for now."
+      }) : void 0;
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "local_merge",
+        nextAction: buildAction(
+          "local_merge",
+          `Fast-forward ${localState.featureBranch} into ${localState.baseBranch}; do not create a merge commit.`,
+          approvalRequired,
+          command
+        ),
+        approvalRequired,
+        implementationAllowed: false,
+        primaryActionLabel: actionOptions ? "A" : void 0,
+        actionOptions,
+        blockedReasonCode: "LOCAL_MERGE_REQUIRED"
+      };
+    }
+    if (!localState.state || !["verified", "cleaned"].includes(localState.state.status) || localState.state.featureTip !== localState.featureTip || localState.state.mergedBaseTip !== localState.baseTip) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "local_verify",
+        nextAction: buildAction(
+          "local_verify",
+          "Run the configured post-merge checks and record verification against the integrated Feature tip.",
+          false,
+          localMergeBaseCommand
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "LOCAL_VERIFICATION_REQUIRED"
+      };
+    }
+    if (!localCleanupComplete(localState)) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "local_cleanup",
+        nextAction: buildAction(
+          "local_cleanup",
+          "Remove the clean managed worktree and delete the local Feature branch according to workflow policy.",
+          false,
+          `npx lee-spec-kit local cleanup ${buildFeatureArgs(feature)} --json`
+        ),
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: "LOCAL_CLEANUP_REQUIRED"
+      };
+    }
+    return {
+      status: "ok",
+      reasonCode: "WORKFLOW_STAGE_RESOLVED",
+      docsDir: config.docsDir,
+      featureRef: buildFeatureRef(feature),
+      stage: "done",
+      nextAction: null,
+      approvalRequired: false,
+      implementationAllowed: false,
+      blockedReasonCode: null
+    };
+  }
   if (requirements.requirePr) {
     const prReady = prDraft.status === "ready";
     const prCreated = !!tasks.prLink && prExistsRemotely(tasks.prLink, feature);
@@ -9694,13 +10172,13 @@ function collectManagedWorktreeRepoRoots(config, projectRoot) {
     const line = rawLine.trim();
     if (!line.startsWith("worktree ")) continue;
     const worktreePath = path8.resolve(line.slice("worktree ".length).trim());
-    if (isSameOrWithin2(path8.resolve(managedRoot), worktreePath)) {
+    if (isSameOrWithin3(path8.resolve(managedRoot), worktreePath)) {
       roots.add(worktreePath);
     }
   }
   return [...roots];
 }
-function isSameOrWithin2(parentDir, candidateDir) {
+function isSameOrWithin3(parentDir, candidateDir) {
   const resolvedParent = path8.resolve(parentDir);
   const resolvedCandidate = path8.resolve(candidateDir);
   return resolvedParent === resolvedCandidate || resolvedCandidate.startsWith(`${resolvedParent}${path8.sep}`);
@@ -9721,10 +10199,10 @@ function parseStagedPaths(output) {
     staged.set(`path:${normalizeSlashes3(parts[1])}`, `${status}:path`);
   }
   return [...staged.entries()].map(([encodedPath, encodedStatus]) => {
-    const [role, path27] = encodedPath.split(":", 2);
+    const [role, path30] = encodedPath.split(":", 2);
     const [status, entryRole] = encodedStatus.split(":", 2);
     return {
-      path: path27,
+      path: path30,
       status,
       role: entryRole || role || "path"
     };
@@ -9834,6 +10312,610 @@ function toAllowedSet(values, extras) {
 function normalizeSlashes3(value) {
   return value.replace(/\\/g, "/");
 }
+var DESIGN_DOC_KINDS = [
+  "ux-design",
+  "design-system",
+  "visual-reference"
+];
+var ALLOWED_DESIGN_KINDS = new Set(DESIGN_DOC_KINDS);
+var FILENAME_RULES = [
+  {
+    pattern: /(?:^|-)(?:system|backend|frontend)-architecture(?:-|$)|(?:^|-)architecture-overview(?:-|$)/i,
+    classification: {
+      kind: "architecture-overview",
+      suggestedLocations: ["docs/prd/*-overview.md"]
+    }
+  },
+  {
+    pattern: /(?:^|-)(?:data-model|api-design|database-schema|implementation-plan|implementation-roadmap)(?:-|$)/i,
+    classification: {
+      kind: "feature-plan",
+      suggestedLocations: [
+        "docs/ideas/I###-*.md (before Feature promotion)",
+        "the active Feature plan.md"
+      ]
+    }
+  },
+  {
+    pattern: /(?:^|-)(?:open-source-research|candidate-comparison|technology-comparison)(?:-|$)/i,
+    classification: {
+      kind: "idea",
+      suggestedLocations: [
+        "docs/ideas/I###-*.md (before Feature promotion)",
+        "the active Feature decisions.md"
+      ]
+    }
+  },
+  {
+    pattern: /(?:^|-)(?:technical-decision|architecture-decision|tradeoff|adr)(?:-|$)/i,
+    classification: {
+      kind: "feature-decisions",
+      suggestedLocations: [
+        "docs/ideas/I###-*.md (before Feature promotion)",
+        "the active Feature decisions.md"
+      ]
+    }
+  }
+];
+async function collectDocsTaxonomyViolations(docsDir) {
+  const designsDir = path8.join(docsDir, "designs");
+  if (!await fs.pathExists(designsDir)) return [];
+  const markdownFiles = await collectMarkdownFiles(designsDir);
+  const violations = [];
+  for (const filePath of markdownFiles) {
+    if (path8.basename(filePath).toLowerCase() === "readme.md") continue;
+    const content = await fs.readFile(filePath, "utf-8");
+    const displayPath = `docs/${normalizeSlashes4(path8.relative(docsDir, filePath))}`;
+    const frontmatter = parseLeeSpecKitFrontmatter(content);
+    if (frontmatter.present && !frontmatter.valid) {
+      violations.push(
+        createViolation(
+          displayPath,
+          "INVALID_DOC_FRONTMATTER",
+          frontmatter.kind,
+          null,
+          "frontmatter",
+          "lee-spec-kit frontmatter must contain a well-formed kind entry.",
+          []
+        )
+      );
+      continue;
+    }
+    if (frontmatter.kind) {
+      if (!isKnownDocKind(frontmatter.kind)) {
+        violations.push(
+          createViolation(
+            displayPath,
+            "INVALID_DOC_KIND",
+            frontmatter.kind,
+            null,
+            "frontmatter",
+            `Unknown lee-spec-kit document kind: ${frontmatter.kind}`,
+            []
+          )
+        );
+        continue;
+      }
+      if (!ALLOWED_DESIGN_KINDS.has(frontmatter.kind)) {
+        violations.push(
+          createViolation(
+            displayPath,
+            "MISPLACED_MANAGED_DOC",
+            frontmatter.kind,
+            frontmatter.kind,
+            "frontmatter",
+            `Document kind "${frontmatter.kind}" does not belong in docs/designs/.`,
+            suggestedLocationsForKind(frontmatter.kind)
+          )
+        );
+        continue;
+      }
+      if (frontmatter.scope && frontmatter.scope !== "project") {
+        violations.push(
+          createViolation(
+            displayPath,
+            "INVALID_DOC_SCOPE",
+            frontmatter.kind,
+            frontmatter.kind,
+            "frontmatter",
+            "Documents in docs/designs/ must use lee-spec-kit scope: project.",
+            []
+          )
+        );
+      }
+      continue;
+    }
+    const inferred = classifyFilename(
+      path8.basename(filePath, path8.extname(filePath))
+    );
+    if (inferred) {
+      violations.push(
+        createViolation(
+          displayPath,
+          "MISPLACED_MANAGED_DOC",
+          null,
+          inferred.kind,
+          "filename",
+          `The filename strongly suggests a ${inferred.kind} document, which does not belong in docs/designs/.`,
+          inferred.suggestedLocations
+        )
+      );
+      continue;
+    }
+    violations.push(
+      createViolation(
+        displayPath,
+        "DOC_KIND_MISSING",
+        null,
+        null,
+        null,
+        "Add lee-spec-kit frontmatter with kind: ux-design, design-system, or visual-reference.",
+        []
+      )
+    );
+  }
+  return violations.sort((a, b) => a.path.localeCompare(b.path));
+}
+function createViolation(displayPath, violationCode, declaredKind, detectedKind, detectedBy, message, suggestedLocations) {
+  return {
+    path: displayPath,
+    violationCode,
+    declaredKind,
+    detectedKind,
+    detectedBy,
+    confidence: detectedBy ? "high" : null,
+    message,
+    suggestedLocations
+  };
+}
+async function collectMarkdownFiles(rootDir) {
+  const files = [];
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = path8.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.toLowerCase() === "assets") continue;
+      files.push(...await collectMarkdownFiles(absolutePath));
+      continue;
+    }
+    if (entry.isFile() && path8.extname(entry.name).toLowerCase() === ".md") {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+function parseLeeSpecKitFrontmatter(content) {
+  const normalized = content.replace(/^\uFEFF/, "");
+  if (!normalized.startsWith("---\n") && !normalized.startsWith("---\r\n")) {
+    return { present: false, valid: true, kind: null, scope: null };
+  }
+  const lines = normalized.split(/\r?\n/);
+  const closingIndex = lines.findIndex(
+    (line, index) => index > 0 && line.trim() === "---"
+  );
+  if (closingIndex < 0) {
+    return { present: true, valid: false, kind: null, scope: null };
+  }
+  const frontmatterLines = lines.slice(1, closingIndex);
+  const rootIndex = frontmatterLines.findIndex(
+    (line) => /^lee-spec-kit:\s*$/.test(line.trim())
+  );
+  if (rootIndex < 0) {
+    return { present: true, valid: false, kind: null, scope: null };
+  }
+  let kind = null;
+  let scope = null;
+  for (const line of frontmatterLines.slice(rootIndex + 1)) {
+    if (/^\S/.test(line)) break;
+    const match = line.match(/^\s+(kind|scope):\s*(.*?)\s*$/);
+    if (!match) continue;
+    const value = stripYamlScalarQuotes(match[2]);
+    if (match[1] === "kind") kind = value || null;
+    if (match[1] === "scope") scope = value || null;
+  }
+  return { present: true, valid: !!kind, kind, scope };
+}
+function stripYamlScalarQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function classifyFilename(stem) {
+  for (const rule of FILENAME_RULES) {
+    if (rule.pattern.test(stem)) return rule.classification;
+  }
+  return null;
+}
+function isKnownDocKind(kind) {
+  return (/* @__PURE__ */ new Set([
+    ...DESIGN_DOC_KINDS,
+    "product-requirements",
+    "architecture-overview",
+    "idea",
+    "feature-spec",
+    "feature-plan",
+    "feature-decisions"
+  ])).has(kind);
+}
+function suggestedLocationsForKind(kind) {
+  if (kind === "architecture-overview") return ["docs/prd/*-overview.md"];
+  if (kind === "idea") return ["docs/ideas/I###-*.md"];
+  if (kind === "product-requirements") return ["docs/prd/"];
+  if (kind === "feature-spec") return ["the active Feature spec.md"];
+  if (kind === "feature-plan") return ["the active Feature plan.md"];
+  if (kind === "feature-decisions") return ["the active Feature decisions.md"];
+  return [];
+}
+function normalizeSlashes4(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/commands/docs-audit.ts
+function docsAuditCommand(program2) {
+  program2.command("docs-audit").description(
+    "Audit whether managed documents are stored in the right location"
+  ).option("--json", "Output JSON for agents and automation").action(async (options) => {
+    try {
+      const payload = await collectDocsAudit(process.cwd());
+      if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+      }
+      console.log(`${payload.status}: ${payload.reasonCode}`);
+      for (const violation of payload.violations) {
+        console.log(`- ${violation.path}: ${violation.message}`);
+      }
+    } catch (error) {
+      const cliError = toCliError(error);
+      const payload = {
+        status: "error",
+        reasonCode: cliError.code === "CONFIG_NOT_FOUND" ? "CONFIG_NOT_FOUND" : "UNEXPECTED_ERROR",
+        mode: "warn",
+        docsDir: null,
+        violations: []
+      };
+      if (options.json) {
+        console.log(
+          JSON.stringify({ ...payload, error: cliError.message }, null, 2)
+        );
+      } else {
+        process.stderr.write(`[${cliError.code}] ${cliError.message}
+`);
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+async function collectDocsAudit(cwd) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw createCliError(
+      "CONFIG_NOT_FOUND",
+      "Config file not found. Run `init` first."
+    );
+  }
+  const violations = await collectDocsTaxonomyViolations(config.docsDir);
+  return {
+    status: violations.length > 0 ? "warning" : "ok",
+    reasonCode: violations.length > 0 ? "DOCS_TAXONOMY_WARNING" : "DOCS_TAXONOMY_OK",
+    mode: "warn",
+    docsDir: config.docsDir,
+    violations
+  };
+}
+
+// src/commands/local.ts
+function localCommand(program2) {
+  const local = program2.command("local").description("Integrate and clean up local workflow feature branches");
+  local.command("merge [feature-name]").description("Fast-forward a completed local feature and verify the result").option("--component <component>", "Component name for multi projects").option(
+    "--confirm <token>",
+    "Approval token when local_merge requires approval"
+  ).option("--json", "Output JSON for agents and hooks").action(
+    async (featureName, options) => {
+      await runLocalAction(
+        options,
+        () => runLocalMerge(featureName, options)
+      );
+    }
+  );
+  local.command("cleanup [feature-name]").description("Remove the verified local feature worktree and branch").option("--component <component>", "Component name for multi projects").option("--json", "Output JSON for agents and hooks").action(
+    async (featureName, options) => {
+      await runLocalAction(
+        options,
+        () => runLocalCleanup(featureName, options)
+      );
+    }
+  );
+}
+async function runLocalAction(options, action) {
+  try {
+    const payload = await action();
+    if (options.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      console.log(`${payload.status}: ${payload.reasonCode}`);
+    }
+    if (payload.status !== "ok") process.exitCode = 1;
+  } catch (error) {
+    const cliError = toCliError(error);
+    const payload = {
+      status: "error",
+      reasonCode: cliError.code,
+      featureRef: null,
+      error: cliError.message
+    };
+    if (options.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      process.stderr.write(`[${cliError.code}] ${cliError.message}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+async function runLocalMerge(featureName, options) {
+  const cwd = process.cwd();
+  const stage = await collectWorkflowStage(cwd, featureName, options.component);
+  if (stage.status !== "ok" || !stage.nextAction || !["local_merge", "local_verify"].includes(stage.nextAction.category)) {
+    return blocked(
+      "LOCAL_MERGE_STAGE_REQUIRED",
+      stage.featureRef,
+      "The active workflow is not at local_merge or local_verify."
+    );
+  }
+  if (stage.approvalRequired && options.confirm !== "OK") {
+    return blocked(
+      "APPROVAL_REQUIRED",
+      stage.featureRef,
+      "Re-run with --confirm OK after the configured local_merge approval."
+    );
+  }
+  const selection = await resolveFeatureSelection(
+    cwd,
+    featureName,
+    options.component
+  );
+  if (selection.status !== "selected" || !selection.matchedFeature) {
+    return blocked(
+      "FEATURE_SELECTION_REQUIRED",
+      null,
+      "Select exactly one Feature."
+    );
+  }
+  const config = await getConfig(cwd);
+  if (!config || config.workflow?.mode !== "local") {
+    return blocked(
+      "LOCAL_WORKFLOW_REQUIRED",
+      selection.matchedFeature.folderName
+    );
+  }
+  const feature = selection.matchedFeature;
+  let context = await resolveLocalIntegrationContext(config, feature);
+  if (!context.featureTip || !context.baseTip) {
+    return blocked(
+      "LOCAL_MERGE_REF_NOT_FOUND",
+      feature.folderName,
+      "Both the configured base branch and Feature tip must exist."
+    );
+  }
+  if (!context.featureWorktreeClean || !context.projectRootClean || !context.docsClean) {
+    return blocked(
+      "LOCAL_MERGE_DIRTY_WORKTREE",
+      feature.folderName,
+      "Feature worktree, base worktree, and docs repo must be clean."
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let state = context.state || {
+    version: 1,
+    featureRef: feature.folderName,
+    component: feature.type,
+    baseBranch: context.baseBranch,
+    featureBranch: context.featureBranch,
+    featureTip: context.featureTip,
+    mergedBaseTip: context.baseTip,
+    status: "merged",
+    mergedAt: now,
+    verifiedAt: null,
+    cleanedAt: null,
+    verification: []
+  };
+  if (!context.baseContainsFeature) {
+    if (!isAncestor(
+      context.projectRoot,
+      `refs/heads/${context.baseBranch}`,
+      context.featureTip
+    )) {
+      return blocked(
+        "LOCAL_MERGE_NOT_FAST_FORWARD",
+        feature.folderName,
+        `${context.baseBranch} is not an ancestor of ${context.featureBranch}.`
+      );
+    }
+    if (currentGitBranch(context.projectRoot) !== context.baseBranch) {
+      const checkout = gitRun(context.projectRoot, [
+        "checkout",
+        context.baseBranch
+      ]);
+      if (checkout.code !== 0) {
+        return blocked(
+          "LOCAL_BASE_CHECKOUT_FAILED",
+          feature.folderName,
+          checkout.stderr
+        );
+      }
+    }
+    const merge = gitRun(context.projectRoot, [
+      "merge",
+      "--ff-only",
+      context.featureBranch
+    ]);
+    if (merge.code !== 0) {
+      return blocked(
+        "LOCAL_MERGE_NOT_FAST_FORWARD",
+        feature.folderName,
+        merge.stderr
+      );
+    }
+    const mergedBaseTip = resolveRef(
+      context.projectRoot,
+      `refs/heads/${context.baseBranch}`
+    );
+    state = {
+      ...state,
+      featureTip: context.featureTip,
+      mergedBaseTip: mergedBaseTip || context.featureTip,
+      status: "merged",
+      mergedAt: now,
+      verifiedAt: null,
+      cleanedAt: null,
+      verification: []
+    };
+    await writeLocalIntegrationState(context.projectRoot, feature, state);
+    context = await resolveLocalIntegrationContext(config, feature);
+  }
+  if (!context.baseContainsFeature) {
+    return blocked("LOCAL_MERGE_VERIFICATION_FAILED", feature.folderName);
+  }
+  const verification = runPostMergeChecks(
+    context.projectRoot,
+    context.postMergeChecks
+  );
+  const failedCheck = verification.find((entry) => entry.exitCode !== 0);
+  if (failedCheck) {
+    await writeLocalIntegrationState(context.projectRoot, feature, {
+      ...state,
+      status: "merged",
+      verification,
+      verifiedAt: null
+    });
+    return {
+      ...blocked("LOCAL_POST_MERGE_CHECK_FAILED", feature.folderName),
+      baseBranch: context.baseBranch,
+      featureBranch: context.featureBranch,
+      featureTip: context.featureTip,
+      baseTip: resolveRef(
+        context.projectRoot,
+        `refs/heads/${context.baseBranch}`
+      ),
+      verification
+    };
+  }
+  const baseTip = resolveRef(
+    context.projectRoot,
+    `refs/heads/${context.baseBranch}`
+  );
+  const verifiedFeatureTip = context.featureTip || state.featureTip;
+  const verifiedState = {
+    ...state,
+    featureTip: verifiedFeatureTip,
+    mergedBaseTip: baseTip || verifiedFeatureTip,
+    status: "verified",
+    verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    verification
+  };
+  await writeLocalIntegrationState(context.projectRoot, feature, verifiedState);
+  return {
+    status: "ok",
+    reasonCode: "LOCAL_MERGE_VERIFIED",
+    featureRef: feature.folderName,
+    baseBranch: context.baseBranch,
+    featureBranch: context.featureBranch,
+    featureTip: context.featureTip,
+    baseTip,
+    verification
+  };
+}
+async function runLocalCleanup(featureName, options) {
+  const cwd = process.cwd();
+  const stage = await collectWorkflowStage(cwd, featureName, options.component);
+  if (stage.status !== "ok" || stage.nextAction?.category !== "local_cleanup") {
+    return blocked(
+      "LOCAL_CLEANUP_STAGE_REQUIRED",
+      stage.featureRef,
+      "The active workflow is not at local_cleanup."
+    );
+  }
+  const selection = await resolveFeatureSelection(
+    cwd,
+    featureName,
+    options.component
+  );
+  if (selection.status !== "selected" || !selection.matchedFeature) {
+    return blocked("FEATURE_SELECTION_REQUIRED", null);
+  }
+  const config = await getConfig(cwd);
+  if (!config || config.workflow?.mode !== "local") {
+    return blocked(
+      "LOCAL_WORKFLOW_REQUIRED",
+      selection.matchedFeature.folderName
+    );
+  }
+  const feature = selection.matchedFeature;
+  let context = await resolveLocalIntegrationContext(config, feature);
+  if (!context.baseContainsFeature || !context.state || !["verified", "cleaned"].includes(context.state.status) || context.state.featureTip !== context.featureTip || context.state.mergedBaseTip !== context.baseTip) {
+    return blocked("LOCAL_MERGE_NOT_VERIFIED", feature.folderName);
+  }
+  if (!context.featureWorktreeClean || !context.projectRootClean || !context.docsClean) {
+    return blocked("LOCAL_CLEANUP_DIRTY_WORKTREE", feature.folderName);
+  }
+  if (currentGitBranch(context.projectRoot) !== context.baseBranch) {
+    return blocked("LOCAL_BASE_NOT_CHECKED_OUT", feature.folderName);
+  }
+  if (context.managedFeatureWorktree) {
+    const remove = gitRun(context.projectRoot, [
+      "worktree",
+      "remove",
+      context.featureWorktree
+    ]);
+    if (remove.code !== 0) {
+      return blocked(
+        "LOCAL_WORKTREE_REMOVE_FAILED",
+        feature.folderName,
+        remove.stderr
+      );
+    }
+  }
+  if (context.deleteFeatureBranchAfterMerge && context.featureBranchExists) {
+    const removeBranch = gitRun(context.projectRoot, [
+      "branch",
+      "-d",
+      context.featureBranch
+    ]);
+    if (removeBranch.code !== 0) {
+      return blocked(
+        "LOCAL_BRANCH_DELETE_FAILED",
+        feature.folderName,
+        removeBranch.stderr
+      );
+    }
+  }
+  await writeLocalIntegrationState(context.projectRoot, feature, {
+    ...context.state,
+    status: "cleaned",
+    cleanedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  context = await resolveLocalIntegrationContext(config, feature);
+  return {
+    status: "ok",
+    reasonCode: "LOCAL_CLEANUP_COMPLETE",
+    featureRef: feature.folderName,
+    baseBranch: context.baseBranch,
+    featureBranch: context.featureBranch,
+    featureTip: context.featureTip,
+    baseTip: context.baseTip
+  };
+}
+function blocked(reasonCode, featureRef, error) {
+  return {
+    status: "blocked",
+    reasonCode,
+    featureRef,
+    ...error ? { error } : {}
+  };
+}
 function isBannerDisabled() {
   const v = (process.env.LEE_SPEC_KIT_NO_BANNER || "").trim();
   return v === "1";
@@ -10005,8 +11087,10 @@ function configureRootCommandSurface() {
     ["detect", "Workflow Policy Commands:"],
     ["github", "Workflow Policy Commands:"],
     ["workflow-stage", "Workflow Policy Commands:"],
+    ["local", "Workflow Policy Commands:"],
     ["integrations", "Codex Integration Commands:"],
     ["commit-audit", "Codex Integration Commands:"],
+    ["docs-audit", "Codex Integration Commands:"],
     ["workflow-audit", "Codex Integration Commands:"]
   ]);
   for (const command of program.commands) {
@@ -10019,7 +11103,9 @@ function configureRootCommandSurface() {
   }
 }
 var cliVersion = getCliVersion();
-program.name("lee-spec-kit").description("Document-centered harness engineering toolkit for AI agent development").version(cliVersion).option("--no-banner", "Hide banner in help output");
+program.name("lee-spec-kit").description(
+  "Document-centered harness engineering toolkit for AI agent development"
+).version(cliVersion).option("--no-banner", "Hide banner in help output");
 if (shouldShowBanner()) {
   program.addHelpText("beforeAll", getBanner({ version: cliVersion }));
 }
@@ -10037,6 +11123,8 @@ workflowStageCommand(program);
 integrationsCommand(program);
 workflowAuditCommand(program);
 commitAuditCommand(program);
+docsAuditCommand(program);
+localCommand(program);
 configureRootCommandSurface();
 await program.parseAsync();
 //# sourceMappingURL=index.js.map