lee-spec-kit 0.8.8 → 0.9.1

package/dist/index.js

@@ -10,7 +10,9 @@ 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';
+import fs26 from 'fs/promises';
 
 async function walkFiles(fsAdapter, rootDir, options = {}) {
   const out = [];
@@ -236,15 +238,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}",
-  "setup.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.",
+  "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",
@@ -519,15 +521,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}",
-  "setup.codexHooksTrustRequired": "Review and trust the installed project hooks with /hooks in Codex. Changed hook definitions require review again.",
+  "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",
@@ -1230,7 +1232,8 @@ var ENGINE_MANAGED_AGENT_FILES = [
   "agents.md",
   "git-workflow.md",
   "issue-template.md",
-  "pr-template.md"
+  "pr-template.md",
+  "ui-ux-design.md"
 ];
 var ENGINE_MANAGED_AGENT_DIRS = ["skills"];
 var ENGINE_MANAGED_FEATURE_PATH = path8.join(
@@ -1303,6 +1306,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\` 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:
 
@@ -1310,14 +1317,20 @@ Approval and remote actions:
 - If \`workflow-stage --json\` reports \`approvalRequired === true\`, stop at that boundary and ask the user before proceeding
 - If \`workflow-stage --json\` returns labeled \`actionOptions\` at any approval boundary, keep the same option labels and exact \`reply\` tokens in the user prompt and do not improvise different reply formats
 - If \`workflow-stage --json\` reports \`nextAction.category === "task_commit"\`, make the docs commit and project commit for the just-finished task before starting the next task or moving to the next stage
-- Before \`git commit\`, prefer \`npx lee-spec-kit commit-audit --json\` when hooks or manual checks need commit-time docs path enforcement
+- Before \`git commit\`, prefer \`npx lee-spec-kit commit-audit --json\`; Feature-scoped commits use \`#123\` when an Issue is linked and the stable Feature ID such as \`F027\` for issue-less local workflows
 - Before remote GitHub actions, share the plan or artifact being sent
 - Respect repo policy from docs and config first; hooks only enforce guardrails and continuation checks
 
 Validation:
 
-- Prefer \`npx lee-spec-kit commit-audit --json\` for commit-time staged docs path validation
+- Prefer \`npx lee-spec-kit commit-audit --json\` for commit-time staged docs path validation and canonical commit-subject validation
 - Prefer \`npx lee-spec-kit workflow-audit --json\` as the default docs-sync validator for Codex hooks and end-of-turn checks; it expects the active feature docs to carry one fresh \`lee-spec-kit:workflow-sync\` marker after meaningful code/doc sync
+
+Optional UI/UX design policy:
+
+- Only when the user request explicitly mentions a design system, UI/visual redesign, design consistency, shared UI/component-library consolidation, branding/theme/token redesign, or implementation from Figma/design images, read and apply \`npx lee-spec-kit docs get ui-ux-design --json\`
+- Do not apply that policy merely because the target is web/frontend, to a non-UI/backend Feature, or to a simple bug fix unrelated to durable design rules
+- Treat it as optional guidance, not a \`requiredDocs\` entry or workflow approval gate
 `;
 function renderManagedSegment(lang, docsRepo) {
   return `${LEE_SPEC_KIT_AGENTS_BEGIN}
@@ -1882,7 +1895,16 @@ async function getConfig(cwd) {
 // src/config/types.ts
 var DEFAULT_APPROVAL_REQUIRE_CHECK_CATEGORIES = [
   "spec_approve",
-  "implementation_approve"
+  "implementation_approve",
+  "local_merge"
+];
+var PRE_PR_REVIEW_REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
 ];
 function createDefaultApprovalConfig() {
   return {
@@ -1891,6 +1913,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) {
@@ -1917,6 +1947,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);
@@ -2486,21 +2535,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: {
@@ -3318,9 +3365,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") {
@@ -3330,10 +3486,14 @@ function isLegacyGeneratedApprovalConfig(approval) {
     "default",
     "requireCheckSteps",
     "requireCheckCategories",
-    "skipCheckCategories",
-    "taskExecuteCheck"
+    "skipCheckCategories"
   ];
-  return !overrideKeys.some((key) => hasOwnKey(approval, key));
+  return !overrideKeys.some((key) => hasOwnKey2(approval, key));
+}
+function isPreviousDefaultApprovalConfig(approval) {
+  const keys = Object.keys(approval).sort();
+  const categories = Array.isArray(approval.requireCheckCategories) ? approval.requireCheckCategories : [];
+  return JSON.stringify(keys) === JSON.stringify(["default", "mode", "requireCheckCategories"]) && approval.mode === "category" && approval.default === "skip" && categories.length === 2 && categories[0] === "spec_approve" && categories[1] === "implementation_approve";
 }
 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(
@@ -3519,38 +3679,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)) {
@@ -3578,9 +3706,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",
@@ -3593,31 +3719,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 !== "local-squash" && 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",
@@ -3632,35 +3789,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)) {
@@ -3679,7 +3833,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) || isPreviousDefaultApprovalConfig(raw.approval))) {
       raw.approval = createDefaultApprovalConfig();
       changedPaths.push("approval");
     }
@@ -6554,6 +6711,14 @@ var BUILTIN_DOC_DEFINITIONS = [
     id: "split-feature",
     title: { ko: "feature \uBD84\uD560 \uAC00\uC774\uB4DC", en: "feature split guide" },
     relativePath: (_, lang) => path8.join(lang, "common", "agents", "skills", "split-feature.md")
+  },
+  {
+    id: "ui-ux-design",
+    title: {
+      ko: "\uC120\uD0DD\uC801 UI/UX \uB514\uC790\uC778 \uBB38\uC11C \uC815\uCC45",
+      en: "Optional UI/UX Design Documentation Policy"
+    },
+    relativePath: (_, lang) => path8.join(lang, "common", "agents", "ui-ux-design.md")
   }
 ];
 var DOC_FOLLOWUPS = {
@@ -6574,7 +6739,8 @@ var DOC_FOLLOWUPS = {
   "execute-task": ["git-workflow", "split-feature"],
   "create-issue": ["issue-doc"],
   "create-pr": ["pr-doc"],
-  "split-feature": []
+  "split-feature": [],
+  "ui-ux-design": []
 };
 function getBuiltinDocIds() {
   return BUILTIN_DOC_DEFINITIONS.map((doc) => doc.id);
@@ -6593,6 +6759,7 @@ function normalizeBuiltinDocId(input) {
   if (normalized === "split-feature") {
     return "split-feature";
   }
+  if (normalized === "ui-ux-design") return "ui-ux-design";
   if (normalized === "agents") return "agents";
   return null;
 }
@@ -7054,11 +7221,9 @@ function findPlaceholderDecisionRange(content) {
   const block = content.slice(match.index, end);
   const isPlaceholder = /\{(?:Decision Title|결정 제목)\}/.test(match[0]) || /-\s+\*\*Decision\*\*:\s*(Final choice|최종 선택)/.test(block);
   if (!isPlaceholder) return null;
-  const sequence = Number(match[1] || "1");
   return {
     start: match.index,
-    end,
-    sequence: Number.isFinite(sequence) ? sequence : 1
+    end
   };
 }
 function formatOptions(options) {
@@ -7099,7 +7264,7 @@ async function runDecisionAdd(featureName, options) {
   const optionItems = (options.option || []).map((value) => value.trim()).filter(Boolean);
   const content = await fs.readFile(target.path, "utf-8");
   const placeholderRange = findPlaceholderDecisionRange(content);
-  const decisionSequence = placeholderRange?.sequence ?? getNextDecisionSequence(content);
+  const decisionSequence = placeholderRange ? 1 : getNextDecisionSequence(content);
   const decisionId = `D${String(decisionSequence).padStart(3, "0")}`;
   const recordedAt = localDate();
   const block = formatDecisionBlock({
@@ -7311,16 +7476,16 @@ function registerCodexIntegration(parent) {
       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);
@@ -7375,7 +7540,7 @@ function registerCodexHooksIntegration(parent) {
             (repoRoot) => removeLeeSpecKitCodexHooks(repoRoot)
           )
         );
-        const key2 = results2.some((result) => result.changed) ? "setup.codexHooksRemoved" : "setup.codexHooksAlreadyAbsent";
+        const key2 = results2.some((result) => result.changed) ? "integrations.codexHooksRemoved" : "integrations.codexHooksAlreadyAbsent";
         console.log(chalk.green(tr(lang, "cli", key2, { path: displayPath })));
         return;
       }
@@ -7384,10 +7549,12 @@ function registerCodexHooksIntegration(parent) {
           (repoRoot) => upsertLeeSpecKitCodexHooks(repoRoot, workflowRoot)
         )
       );
-      const key = results.every((result) => result.action === "noop") ? "setup.codexHooksAlreadyInstalled" : "setup.codexHooksInstalled";
+      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", "setup.codexHooksTrustRequired"))
+        chalk.yellow(
+          tr(lang, "cli", "integrations.codexHooksTrustRequired")
+        )
       );
     } catch (error) {
       const cliError = toCliError(error);
@@ -7406,27 +7573,294 @@ 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
-};
+
+// src/utils/commit-conventions.ts
+var PROJECT_COMMIT_TYPES = [
+  "feat",
+  "fix",
+  "refactor",
+  "test",
+  "style",
+  "chore"
+];
+function resolveFeatureCommitScope(input) {
+  const issueNumber = Number(input.issueNumber || 0);
+  if (Number.isInteger(issueNumber) && issueNumber > 0) {
+    return `#${issueNumber}`;
+  }
+  if (input.workflowMode !== "local") {
+    return null;
+  }
+  const featureId = String(input.featureId || "").trim().toUpperCase();
+  return /^F\d{3,}$/.test(featureId) ? featureId : null;
+}
+function matchesProjectCommitConvention(message, scope) {
+  return matchesCommitConvention(message, scope, PROJECT_COMMIT_TYPES);
+}
+function matchesDocsCommitConvention(message, scope) {
+  return matchesCommitConvention(message, scope, ["docs"]);
+}
+function matchesCommitConvention(message, scope, types) {
+  const normalized = String(message || "").trim();
+  const normalizedScope = String(scope || "").trim();
+  if (!normalized || !normalizedScope) return false;
+  const typePattern = types.join("|");
+  const match = normalized.match(
+    new RegExp(`^(${typePattern})\\((#[0-9]+|F[0-9]{3,})\\):\\s+\\S.+$`, "i")
+  );
+  if (!match) return false;
+  return match[2].toLowerCase() === normalizedScope.toLowerCase();
+}
+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) {
+  const strategy = config.workflow?.completionStrategy;
+  return strategy === "local-ff" || strategy === "local-squash" ? strategy : "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 configuredStrategy = resolveLocalCompletionStrategy(config);
+  const completionStrategy = configuredStrategy === "local-squash" ? "local-squash" : "local-ff";
+  const evidenceRef = resolveEvidenceRef(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);
+  const baseContainsFeature = !!featureTip && !!baseTip && isAncestor(projectRoot, featureTip, `refs/heads/${baseBranch}`);
+  const integratedCommit = state?.integratedCommit || state?.mergedBaseTip;
+  const evidenceTip = resolveRef(projectRoot, evidenceRef);
+  const featureTree = featureTip ? resolveTree(projectRoot, featureTip) : null;
+  const integratedTree = integratedCommit ? resolveTree(projectRoot, integratedCommit) : null;
+  const squashCommitMatchesSource = completionStrategy === "local-squash" && state?.strategy === "local-squash" && !!featureTip && state.featureTip === featureTip && !!integratedCommit && !!baseTip && isAncestor(projectRoot, integratedCommit, `refs/heads/${baseBranch}`) && !!featureTree && integratedTree === featureTree && state.integratedTree === featureTree;
+  const squashEvidencePresent = !!featureTip && evidenceTip === featureTip;
+  const squashIntegrationComplete = squashCommitMatchesSource && squashEvidencePresent;
+  return {
+    projectRoot,
+    featureWorktree: effectiveFeatureWorktree,
+    docsGitCwd: feature.git.docsGitCwd,
+    baseBranch,
+    featureBranch,
+    featureTip,
+    baseTip,
+    currentBranch,
+    state,
+    completionStrategy,
+    baseContainsFeature,
+    integrationComplete: completionStrategy === "local-squash" ? squashIntegrationComplete : baseContainsFeature,
+    evidenceRef,
+    squashCommitMatchesSource,
+    squashEvidencePresent,
+    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.integrationComplete && 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 resolveTree(cwd, commit) {
+  return resolveRef(cwd, `${commit}^{tree}`);
+}
+function preserveLocalIntegrationEvidence(projectRoot, evidenceRef, featureTip) {
+  return gitRun(projectRoot, ["update-ref", evidenceRef, featureTip]);
+}
+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 = resolveFeatureStateKey(feature);
+  return path8.join(
+    commonDir,
+    "lee-spec-kit",
+    "local-integrations",
+    `${key}.json`
+  );
+}
+function resolveEvidenceRef(feature) {
+  return `refs/lee-spec-kit/integrations/${resolveFeatureStateKey(feature)}`;
+}
+function resolveFeatureStateKey(feature) {
+  return crypto.createHash("sha256").update(`${feature.type}:${feature.folderName}`).digest("hex").slice(0, 24);
+}
+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"];
@@ -7434,12 +7868,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,
@@ -7488,7 +7924,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 = [];
@@ -7769,8 +8205,13 @@ function resolveProjectCommitTopic(feature, tasks) {
 }
 function buildTaskCommitSummary(input) {
   const { feature, tasks, effectiveProjectGitCwd, docsDirty, projectDirty, gateFailureReason } = input;
-  const docsMessage = tasks.issueNumber ? `git -C "${feature.git.docsGitCwd}" add "${feature.docs.featurePathFromDocs}" && git -C "${feature.git.docsGitCwd}" commit -m "docs(#${tasks.issueNumber}): ${feature.folderName} \uBB38\uC11C \uC5C5\uB370\uC774\uD2B8"` : `git -C "${feature.git.docsGitCwd}" add "${feature.docs.featurePathFromDocs}" && git -C "${feature.git.docsGitCwd}" commit -m "docs: ${feature.folderName} \uBB38\uC11C \uC5C5\uB370\uC774\uD2B8"`;
-  const projectMessage = tasks.issueNumber ? `Stage only the files touched by the just-finished task in "${effectiveProjectGitCwd}", then commit with: git -C "${effectiveProjectGitCwd}" commit -m "feat(#${tasks.issueNumber}): ${resolveProjectCommitTopic(feature, tasks)}"` : `Stage only the files touched by the just-finished task in "${effectiveProjectGitCwd}", then commit with: git -C "${effectiveProjectGitCwd}" commit -m "feat(${feature.folderName}): ${resolveProjectCommitTopic(feature, tasks)}"`;
+  const scope = resolveFeatureCommitScope({
+    issueNumber: tasks.issueNumber,
+    featureId: feature.id,
+    workflowMode: tasks.issueNumber ? "github" : "local"
+  }) || feature.id;
+  const docsMessage = `git -C "${feature.git.docsGitCwd}" add "${feature.docs.featurePathFromDocs}" && git -C "${feature.git.docsGitCwd}" commit -m "docs(${scope}): ${feature.folderName} \uBB38\uC11C \uC5C5\uB370\uC774\uD2B8"`;
+  const projectMessage = `Stage only the files touched by the just-finished task in "${effectiveProjectGitCwd}", then commit with: git -C "${effectiveProjectGitCwd}" commit -m "feat(${scope}): ${resolveProjectCommitTopic(feature, tasks)}"`;
   const lines = ["Finish the task-level commit checkpoint before continuing."];
   if (gateFailureReason) {
     lines.push(`Current gate failure: ${gateFailureReason}`);
@@ -7982,8 +8423,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;
@@ -8003,12 +8449,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) {
@@ -8030,7 +8496,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(
@@ -8613,8 +9081,13 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       "implementation_approve",
       true
     );
+    const localIntegrationApproval = config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) !== "none";
+    const separateLocalMergeApproval = localIntegrationApproval && resolveActionApprovalRequired(config, "local_merge", false);
+    const localBaseBranch = config.workflow?.baseBranch?.trim() || "main";
+    const localIntegrationLabel = resolveLocalCompletionStrategy(config) === "local-squash" ? `squash integration into ${localBaseBranch}` : `fast-forward integration into ${localBaseBranch}`;
+    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: separateLocalMergeApproval ? `Approve the completed implementation and continue to the separate local merge approval before ${localIntegrationLabel}.` : localIntegrationApproval ? `Approve the completed implementation and authorize ${localIntegrationLabel}, 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 {
@@ -8625,7 +9098,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.",
+        separateLocalMergeApproval ? `Share the completed implementation and get user approval for the implementation itself. Record it in tasks.md; ${localIntegrationLabel} will require a separate local_merge approval.` : localIntegrationApproval ? `Share the completed implementation and get user approval for the remaining local completion flow: ${localIntegrationLabel}, 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,
@@ -8635,7 +9108,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",
@@ -8644,14 +9117,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) !== "none") {
+    const localState = await resolveLocalIntegrationContext(config, feature);
+    const localMergeBaseCommand = `npx lee-spec-kit local merge ${buildFeatureArgs(feature)} --json`;
+    if (!localState.integrationComplete) {
+      const approvalRequired = resolveActionApprovalRequired(
+        config,
+        "local_merge",
+        false
+      );
+      const command = approvalRequired ? `${localMergeBaseCommand} --confirm OK` : localMergeBaseCommand;
+      const actionOptions = approvalRequired ? buildApprovalActionOptions({
+        approveSummary: localState.completionStrategy === "local-squash" ? `Squash ${localState.featureBranch} into ${localState.baseBranch}, preserve the source Feature tip, and run the configured post-merge checks.` : `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",
+          localState.completionStrategy === "local-squash" ? `Create one squash commit from ${localState.featureBranch} on ${localState.baseBranch} and preserve the source Feature tip as internal integration evidence.` : `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);
@@ -9531,35 +10087,21 @@ var DEFAULT_MANAGED_DOC_FILES = [
   ".gitignore"
 ];
 
-// src/utils/commit-conventions.ts
-var PROJECT_COMMIT_PREFIX_PATTERN = /^(feat|fix|refactor|test|chore)\(#(\d+)\):\s+\S.+$/i;
-var DOCS_COMMIT_PREFIX_PATTERN = /^docs\(#(\d+)\):\s+\S.+$/i;
-function matchesProjectCommitConvention(message, issueNumber) {
-  const normalized = String(message || "").trim();
-  if (!normalized) return false;
-  const match = normalized.match(PROJECT_COMMIT_PREFIX_PATTERN);
-  if (!match) return false;
-  return Number(match[2]) === issueNumber;
-}
-function matchesDocsCommitConvention(message, issueNumber) {
-  const normalized = String(message || "").trim();
-  if (!normalized) return false;
-  const match = normalized.match(DOCS_COMMIT_PREFIX_PATTERN);
-  if (!match) return false;
-  return Number(match[1]) === issueNumber;
-}
-
 // src/commands/commit-audit.ts
 var CANONICAL_FEATURE_DOC_PATTERN = /^features\/(?:[^/]+\/)?F\d{3,}[^/]*\/(spec|plan|tasks|decisions|issue|pr)\.md$/i;
 var FEATURE_DOC_CANDIDATE_PATTERN = /^features\/(?:[^/]+\/)?F\d{3,}[^/]*\/(.+)$/i;
 function commitAuditCommand(program2) {
-  program2.command("commit-audit").description("Validate staged docs paths before commit").option("--json", "Output JSON for hooks and agents").option("--git-root <path>", "Override the git root used for staged-path inspection").option("--message <message>", "Validate a commit subject against the current workflow convention").action(async (options) => {
+  program2.command("commit-audit").description("Validate staged docs paths and canonical commit subjects before commit").option("--json", "Output JSON for hooks and agents").option("--git-root <path>", "Override the git root used for staged-path inspection").option("--message <message>", "Validate a commit subject against the current workflow convention").option("--message-file <path>", "Read and validate the commit subject from a commit message file").option("--enforce", "Exit non-zero when commit-audit blocks the commit").action(async (options) => {
     try {
+      const commitMessage = await resolveCommitMessageInput(process.cwd(), options);
       const payload = await collectCommitAudit(
         process.cwd(),
         options.gitRoot,
-        options.message
+        commitMessage
       );
+      if (options.enforce && payload.status === "blocked") {
+        process.exitCode = 1;
+      }
       if (options.json) {
         console.log(JSON.stringify(payload, null, 2));
         return;
@@ -9586,6 +10128,7 @@ function commitAuditCommand(program2) {
             2
           )
         );
+        if (options.enforce) process.exitCode = 1;
         return;
       }
       process.stderr.write(`[${cliError.code}] ${cliError.message}
@@ -9594,6 +10137,18 @@ function commitAuditCommand(program2) {
     }
   });
 }
+async function resolveCommitMessageInput(cwd, options) {
+  if (options.message && options.messageFile) {
+    throw createCliError(
+      "INVALID_ARGUMENT",
+      "Use either --message or --message-file, not both."
+    );
+  }
+  if (options.message) return options.message;
+  if (!options.messageFile) return void 0;
+  const content = await fs26.readFile(path8.resolve(cwd, options.messageFile), "utf-8");
+  return content.split(/\r?\n/u).map((line) => line.trim()).find((line) => line.length > 0 && !line.startsWith("#"));
+}
 async function collectCommitAudit(cwd, gitRootOverride, commitMessage) {
   const config = await getConfig(cwd);
   if (!config) {
@@ -9712,13 +10267,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}`);
@@ -9739,10 +10294,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"
     };
@@ -9817,10 +10372,17 @@ async function collectCommitMessageViolation(cwd, config, repoRoot, stagedEntrie
     return null;
   }
   const selection = await resolveFeatureSelection(cwd);
-  if (selection.status !== "selected" || !selection.matchedFeature?.issueNumber) {
+  if (selection.status !== "selected" || !selection.matchedFeature) {
+    return null;
+  }
+  const scope = resolveFeatureCommitScope({
+    issueNumber: selection.matchedFeature.issueNumber,
+    featureId: selection.matchedFeature.id,
+    workflowMode: config.workflow?.mode
+  });
+  if (!scope) {
     return null;
   }
-  const issueNumber = selection.matchedFeature.issueNumber;
   const docsRepoRoot = runGitCapture(["rev-parse", "--show-toplevel"], config.docsDir);
   const normalizedRepoRoot = path8.resolve(repoRoot);
   const normalizedDocsRepoRoot = docsRepoRoot ? path8.resolve(docsRepoRoot) : null;
@@ -9830,15 +10392,15 @@ async function collectCommitMessageViolation(cwd, config, repoRoot, stagedEntrie
     return !!relativeToDocs && relativeToDocs !== "" && !relativeToDocs.startsWith("..");
   });
   const isDocsCommit = !!normalizedDocsRepoRoot && normalizedDocsRepoRoot === normalizedRepoRoot && (config.docsRepo === "standalone" || docsOnlyCommit);
-  const valid = isDocsCommit ? matchesDocsCommitConvention(normalizedMessage, issueNumber) : matchesProjectCommitConvention(normalizedMessage, issueNumber);
+  const valid = isDocsCommit ? matchesDocsCommitConvention(normalizedMessage, scope) : matchesProjectCommitConvention(normalizedMessage, scope);
   if (valid) {
     return null;
   }
-  const expected = isDocsCommit ? `docs(#${issueNumber}): ...` : `type(#${issueNumber}): ... (feat/fix/refactor/test/chore)`;
+  const expected = isDocsCommit ? `docs(${scope}): ...` : `type(${scope}): ... (feat/fix/refactor/test/style/chore)`;
   return {
     path: "(commit message)",
     kind: "commit_message_policy",
-    detail: `Commit subject must follow the issue-scoped convention for this feature. Expected ${expected}, received "${normalizedMessage}".`
+    detail: `Commit subject must follow the canonical feature-scoped convention. Expected ${expected}, received "${normalizedMessage}".`
   };
 }
 function normalizeEntryName(value) {
@@ -9852,6 +10414,723 @@ 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("Integrate 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();
+  const previousStateStrategy = context.state?.strategy || "local-ff";
+  let state = context.state && context.state.featureTip === context.featureTip && previousStateStrategy === context.completionStrategy ? context.state : {
+    version: 1,
+    featureRef: feature.folderName,
+    component: feature.type,
+    baseBranch: context.baseBranch,
+    featureBranch: context.featureBranch,
+    featureTip: context.featureTip,
+    mergedBaseTip: context.baseTip,
+    strategy: context.completionStrategy,
+    status: "merged",
+    mergedAt: now,
+    verifiedAt: null,
+    cleanedAt: null,
+    verification: []
+  };
+  if (context.completionStrategy === "local-squash" && context.squashCommitMatchesSource && !context.squashEvidencePresent) {
+    const evidence = preserveLocalIntegrationEvidence(
+      context.projectRoot,
+      context.evidenceRef,
+      context.featureTip
+    );
+    if (evidence.code !== 0) {
+      return blocked(
+        "LOCAL_SQUASH_EVIDENCE_FAILED",
+        feature.folderName,
+        evidence.stderr
+      );
+    }
+    context = await resolveLocalIntegrationContext(config, feature);
+  }
+  if (!context.featureTip || !context.baseTip) {
+    return blocked("LOCAL_MERGE_REF_NOT_FOUND", feature.folderName);
+  }
+  if (!context.integrationComplete) {
+    if (!isAncestor(
+      context.projectRoot,
+      `refs/heads/${context.baseBranch}`,
+      context.featureTip
+    )) {
+      return blocked(
+        context.completionStrategy === "local-squash" ? "LOCAL_SQUASH_BASE_NOT_ANCESTOR" : "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 integration = context.completionStrategy === "local-squash" ? integrateLocalSquash(context, feature.folderName, feature.id, feature.slug) : integrateLocalFastForward(context, feature.folderName);
+    if (integration.status !== "ok") return integration.payload;
+    const mergedBaseTip = resolveRef(
+      context.projectRoot,
+      `refs/heads/${context.baseBranch}`
+    );
+    const integratedTree = mergedBaseTip ? resolveTree(context.projectRoot, mergedBaseTip) : null;
+    state = {
+      ...state,
+      featureTip: context.featureTip,
+      mergedBaseTip: mergedBaseTip || context.featureTip,
+      strategy: context.completionStrategy,
+      integratedCommit: mergedBaseTip || context.featureTip,
+      ...integratedTree ? { integratedTree } : {},
+      ...context.completionStrategy === "local-squash" ? { evidenceRef: context.evidenceRef } : {},
+      status: "merged",
+      mergedAt: now,
+      verifiedAt: null,
+      cleanedAt: null,
+      verification: []
+    };
+    await writeLocalIntegrationState(context.projectRoot, feature, state);
+    context = await resolveLocalIntegrationContext(config, feature);
+  }
+  if (!context.integrationComplete) {
+    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,
+    completionStrategy: context.completionStrategy,
+    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.integrationComplete || !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",
+      context.completionStrategy === "local-squash" ? "-D" : "-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,
+    completionStrategy: context.completionStrategy
+  };
+}
+function integrateLocalFastForward(context, featureRef) {
+  const merge = gitRun(context.projectRoot, [
+    "merge",
+    "--ff-only",
+    context.featureBranch
+  ]);
+  if (merge.code !== 0) {
+    return {
+      status: "blocked",
+      payload: blocked(
+        "LOCAL_MERGE_NOT_FAST_FORWARD",
+        featureRef,
+        merge.stderr
+      )
+    };
+  }
+  return { status: "ok" };
+}
+function integrateLocalSquash(context, featureRef, featureId, featureSlug) {
+  const originalBaseTip = context.baseTip;
+  if (!originalBaseTip || !context.featureTip) {
+    return {
+      status: "blocked",
+      payload: blocked("LOCAL_MERGE_REF_NOT_FOUND", featureRef)
+    };
+  }
+  const squash = gitRun(context.projectRoot, [
+    "merge",
+    "--squash",
+    context.featureBranch
+  ]);
+  if (squash.code !== 0) {
+    rollbackSquash(context.projectRoot, originalBaseTip);
+    return {
+      status: "blocked",
+      payload: blocked("LOCAL_SQUASH_FAILED", featureRef, squash.stderr)
+    };
+  }
+  const scope = resolveFeatureCommitScope({
+    featureId,
+    workflowMode: "local"
+  });
+  if (!scope) {
+    rollbackSquash(context.projectRoot, originalBaseTip);
+    return {
+      status: "blocked",
+      payload: blocked(
+        "LOCAL_SQUASH_COMMIT_SCOPE_INVALID",
+        featureRef,
+        `Could not resolve a canonical local commit scope from ${featureId}.`
+      )
+    };
+  }
+  const commit = gitRun(context.projectRoot, [
+    "commit",
+    "-m",
+    `feat(${scope}): integrate ${featureSlug}`
+  ]);
+  if (commit.code !== 0) {
+    rollbackSquash(context.projectRoot, originalBaseTip);
+    return {
+      status: "blocked",
+      payload: blocked("LOCAL_SQUASH_COMMIT_FAILED", featureRef, commit.stderr)
+    };
+  }
+  const integratedCommit = resolveRef(context.projectRoot, "HEAD");
+  const sourceTree = resolveTree(context.projectRoot, context.featureTip);
+  const integratedTree = integratedCommit ? resolveTree(context.projectRoot, integratedCommit) : null;
+  if (!integratedCommit || !sourceTree || integratedTree !== sourceTree) {
+    rollbackSquash(context.projectRoot, originalBaseTip);
+    return {
+      status: "blocked",
+      payload: blocked("LOCAL_SQUASH_TREE_MISMATCH", featureRef)
+    };
+  }
+  const evidence = preserveLocalIntegrationEvidence(
+    context.projectRoot,
+    context.evidenceRef,
+    context.featureTip
+  );
+  if (evidence.code !== 0) {
+    rollbackSquash(context.projectRoot, originalBaseTip);
+    return {
+      status: "blocked",
+      payload: blocked(
+        "LOCAL_SQUASH_EVIDENCE_FAILED",
+        featureRef,
+        evidence.stderr
+      )
+    };
+  }
+  return { status: "ok" };
+}
+function rollbackSquash(projectRoot, originalBaseTip) {
+  gitRun(projectRoot, ["reset", "--hard", originalBaseTip]);
+}
+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";
@@ -10023,8 +11302,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) {
@@ -10037,7 +11318,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 }));
 }
@@ -10055,6 +11338,8 @@ workflowStageCommand(program);
 integrationsCommand(program);
 workflowAuditCommand(program);
 commitAuditCommand(program);
+docsAuditCommand(program);
+localCommand(program);
 configureRootCommandSurface();
 await program.parseAsync();
 //# sourceMappingURL=index.js.map