lee-spec-kit 0.9.0 → 0.9.2

package/dist/index.js

@@ -12,6 +12,7 @@ import { spawn, execFileSync, spawnSync } from 'child_process';
 import os from 'os';
 import crypto, { createHash } from 'crypto';
 import fs21 from 'fs';
+import fs26 from 'fs/promises';
 
 async function walkFiles(fsAdapter, rootDir, options = {}) {
   const out = [];
@@ -1231,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(
@@ -1306,8 +1308,8 @@ Before taking the next workflow step:
 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
+15. For a local workflow, do not report completion directly after implementation approval; follow the exact returned \`local verify\` / \`local merge\` / \`local cleanup\` commands until \`workflow-stage\` proves verification, integration, and cleanup and returns \`done\`; \`feature_remediation\` explicitly permits Feature worktree fixes
+16. In a \`local-ff\` or \`local-squash\` workflow, keep implementation approval and local merge approval distinct when \`local_merge\` is required: the first accepts the implementation, and the second authorizes the configured integration strategy, post-merge checks, and local cleanup
 
 Approval and remote actions:
 
@@ -1315,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}
@@ -1887,7 +1895,8 @@ 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",
@@ -2534,6 +2543,7 @@ async function runInit(options) {
             baseBranch: resolveInitialBaseBranch(cwd, docsRepo, projectRoot),
             completionStrategy: "local-ff",
             deleteFeatureBranchAfterMerge: true,
+            featureChecks: [],
             postMergeChecks: []
           } : {},
           prePrReview: {
@@ -3481,6 +3491,11 @@ function isLegacyGeneratedApprovalConfig(approval) {
   ];
   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(
     "-f, --force",
@@ -3720,7 +3735,7 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
       "none",
       "workflow.completionStrategy"
     );
-    if (workflow.completionStrategy !== "local-ff" && workflow.completionStrategy !== "none") {
+    if (workflow.completionStrategy !== "local-ff" && workflow.completionStrategy !== "local-squash" && workflow.completionStrategy !== "none") {
       workflow.completionStrategy = "none";
       changedPaths.push("workflow.completionStrategy");
     }
@@ -3734,6 +3749,33 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
       workflow.deleteFeatureBranchAfterMerge = true;
       changedPaths.push("workflow.deleteFeatureBranchAfterMerge");
     }
+    if (!Object.prototype.hasOwnProperty.call(workflow, "featureChecks")) {
+      workflow.featureChecks = Array.isArray(workflow.postMergeChecks) ? workflow.postMergeChecks : [];
+      workflow.postMergeChecks = [];
+      changedPaths.push("workflow.featureChecks");
+      changedPaths.push("workflow.postMergeChecks");
+    }
+    setIfMissing(workflow, "featureChecks", [], "workflow.featureChecks");
+    if (!Array.isArray(workflow.featureChecks)) {
+      workflow.featureChecks = [];
+      changedPaths.push("workflow.featureChecks");
+    } else {
+      const normalizedFeatureChecks = workflow.featureChecks.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(normalizedFeatureChecks) !== JSON.stringify(workflow.featureChecks)) {
+        workflow.featureChecks = normalizedFeatureChecks;
+        changedPaths.push("workflow.featureChecks");
+      }
+    }
     setIfMissing(workflow, "postMergeChecks", [], "workflow.postMergeChecks");
     if (!Array.isArray(workflow.postMergeChecks)) {
       workflow.postMergeChecks = [];
@@ -3822,7 +3864,7 @@ async function backfillMissingConfigDefaults(cwd, docsDir) {
     const migration = migrateLegacyApprovalSettings(approval);
     raw.approval = migration.approval;
     changedPaths.push(...migration.changedPaths);
-    if (isPlainObject(raw.approval) && isLegacyGeneratedApprovalConfig(raw.approval)) {
+    if (isPlainObject(raw.approval) && (isLegacyGeneratedApprovalConfig(raw.approval) || isPreviousDefaultApprovalConfig(raw.approval))) {
       raw.approval = createDefaultApprovalConfig();
       changedPaths.push("approval");
     }
@@ -6697,6 +6739,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 = {
@@ -6717,7 +6767,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);
@@ -6736,6 +6787,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;
 }
@@ -7197,11 +7249,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) {
@@ -7242,7 +7292,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({
@@ -7551,6 +7601,44 @@ function integrationsCommand(program2) {
   registerCodexIntegration(integrations);
   registerCodexHooksIntegration(integrations);
 }
+
+// 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);
@@ -7591,7 +7679,8 @@ function isPrePrEvidenceSatisfied(check) {
 }
 var BRANCH_LABELS2 = ["Branch", "\uBE0C\uB79C\uCE58"];
 function resolveLocalCompletionStrategy(config) {
-  return config.workflow?.completionStrategy === "local-ff" ? "local-ff" : "none";
+  const strategy = config.workflow?.completionStrategy;
+  return strategy === "local-ff" || strategy === "local-squash" ? strategy : "none";
 }
 async function resolveLocalIntegrationContext(config, feature) {
   const projectRoot = resolveProjectRoot(config, feature);
@@ -7611,6 +7700,9 @@ async function resolveLocalIntegrationContext(config, feature) {
     );
   }
   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}`
@@ -7624,6 +7716,14 @@ async function resolveLocalIntegrationContext(config, feature) {
   );
   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 && integratedCommit === baseTip && !!featureTree && integratedTree === featureTree && state.integratedTree === featureTree;
+  const squashEvidencePresent = !!featureTip && evidenceTip === featureTip;
+  const squashIntegrationComplete = squashCommitMatchesSource && squashEvidencePresent;
   return {
     projectRoot,
     featureWorktree: effectiveFeatureWorktree,
@@ -7631,16 +7731,25 @@ async function resolveLocalIntegrationContext(config, feature) {
     baseBranch,
     featureBranch,
     featureTip,
+    featureTree,
     baseTip,
     currentBranch,
     state,
-    baseContainsFeature: !!featureTip && !!baseTip && isAncestor(projectRoot, featureTip, `refs/heads/${baseBranch}`),
+    completionStrategy,
+    baseContainsFeature,
+    integrationComplete: completionStrategy === "local-squash" ? squashIntegrationComplete : !!featureTip && baseTip === featureTip,
+    evidenceRef,
+    squashCommitMatchesSource,
+    squashEvidencePresent,
     projectRootClean: isClean(projectRoot),
     featureWorktreeClean: isClean(effectiveFeatureWorktree),
     docsClean: isClean(feature.git.docsGitCwd),
     managedFeatureWorktree,
     featureBranchExists: !!featureBranchTip,
-    postMergeChecks: normalizePostMergeChecks(config.workflow?.postMergeChecks),
+    featureChecks: Array.isArray(config.workflow?.featureChecks) ? normalizeWorkflowChecks(config.workflow.featureChecks) : normalizeWorkflowChecks(config.workflow?.postMergeChecks),
+    // Compatibility: pre-0.9.2 postMergeChecks are treated as Feature checks.
+    // Projects can opt into true post-integration checks by defining featureChecks.
+    postMergeChecks: Array.isArray(config.workflow?.featureChecks) ? normalizeWorkflowChecks(config.workflow?.postMergeChecks) : [],
     deleteFeatureBranchAfterMerge: config.workflow?.deleteFeatureBranchAfterMerge !== false
   };
 }
@@ -7663,22 +7772,71 @@ async function readLocalIntegrationState(projectRoot, feature) {
   }
 }
 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;
+  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) {
+function runLocalChecks(cwd, checks, targetSha, logDir, phase) {
   const results = [];
+  fs.ensureDirSync(logDir);
   for (const check of checks) {
     const args = Array.isArray(check.args) ? check.args.map(String) : [];
-    const result = runProcess(check.command, args, projectRoot);
+    const startedAt = /* @__PURE__ */ new Date();
+    const result = runProcess(check.command, args, cwd);
+    const finishedAt = /* @__PURE__ */ new Date();
+    const runtime = {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      path: process.env.PATH || ""
+    };
+    const index = results.length + 1;
+    const logPath = path8.join(logDir, `${phase}-${String(index).padStart(2, "0")}.log`);
+    const log = [
+      `phase: ${phase}`,
+      `targetSha: ${targetSha}`,
+      `cwd: ${cwd}`,
+      `command: ${JSON.stringify([check.command, ...args])}`,
+      `startedAt: ${startedAt.toISOString()}`,
+      `finishedAt: ${finishedAt.toISOString()}`,
+      `exitCode: ${result.code}`,
+      `runtime: ${JSON.stringify(runtime)}`,
+      "",
+      "--- stdout ---",
+      result.stdout,
+      "--- stderr ---",
+      result.stderr
+    ].join("\n");
+    fs.writeFileSync(logPath, log, { encoding: "utf-8", mode: 384 });
     results.push({
       command: check.command,
       args,
-      exitCode: result.code
+      cwd,
+      targetSha,
+      startedAt: startedAt.toISOString(),
+      finishedAt: finishedAt.toISOString(),
+      durationMs: finishedAt.getTime() - startedAt.getTime(),
+      exitCode: result.code,
+      runtime,
+      ...preview(result.stdout) ? { stdoutPreview: preview(result.stdout) } : {},
+      ...preview(result.stderr) ? { stderrPreview: preview(result.stderr) } : {},
+      logPath
     });
     if (result.code !== 0) break;
   }
   return results;
 }
+function resolveLocalIntegrationLogDir(projectRoot, feature, targetSha) {
+  return path8.join(
+    path8.dirname(resolveStatePath(projectRoot, feature)),
+    "logs",
+    resolveFeatureStateKey(feature),
+    targetSha.slice(0, 12)
+  );
+}
+function preview(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 2e3 ? `${trimmed.slice(0, 2e3)}
+\u2026[truncated]` : trimmed;
+}
 function gitRun(cwd, args) {
   return runProcess("git", args, cwd);
 }
@@ -7688,6 +7846,12 @@ function currentGitBranch(cwd) {
 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",
@@ -7711,7 +7875,7 @@ function resolveProjectRoot(config, feature) {
 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);
+  const key = resolveFeatureStateKey(feature);
   return path8.join(
     commonDir,
     "lee-spec-kit",
@@ -7719,6 +7883,12 @@ function resolveStatePath(projectRoot, feature) {
     `${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") : "";
@@ -7758,7 +7928,7 @@ function resolveRegisteredBranchWorktree(projectRoot, branch) {
   }
   return null;
 }
-function normalizePostMergeChecks(value) {
+function normalizeWorkflowChecks(value) {
   if (!Array.isArray(value)) return [];
   return value.filter(
     (entry) => !!entry && typeof entry === "object" && typeof entry.command === "string" && !!entry.command.trim()
@@ -7777,6 +7947,11 @@ var PR_STATUS_LABELS = ["PR Status", "PR \uC0C1\uD0DC"];
 var PRE_PR_REVIEW_LABELS = ["Pre-PR Review", "PR \uC804 \uB9AC\uBDF0"];
 var PRE_PR_EVIDENCE_LABELS = ["Pre-PR Evidence", "PR \uC804 \uB9AC\uBDF0 Evidence"];
 var PRE_PR_DECISION_LABELS = ["Pre-PR Decision", "PR \uC804 \uB9AC\uBDF0 Decision"];
+var COMPLETION_MARKERS = {
+  allTasks: "lee-spec-kit:completion:all-tasks",
+  tests: "lee-spec-kit:completion:tests",
+  finalOutcome: "lee-spec-kit:completion:final-outcome"
+};
 function resolveWorkflowRequirements(config) {
   const workflow = config.workflow || {};
   const hasCanonicalMode = workflow.mode === "github" || workflow.mode === "local";
@@ -7831,6 +8006,16 @@ function withoutFencedCodeBlocks(content) {
   }
   return lines;
 }
+function parseCompletionCheckbox(lines, marker, legacyPattern) {
+  const markerToken = `<!-- ${marker} -->`;
+  const markedLines = lines.filter((line) => line.includes(markerToken));
+  if (markedLines.length > 0) {
+    return markedLines.length === 1 && parseMarkdownCheckbox(markedLines[0]) === true;
+  }
+  return lines.some(
+    (line) => legacyPattern.test(line) && parseMarkdownCheckbox(line) === true
+  );
+}
 function parseTasksDoc(content) {
   const issueRaw = extractFieldValue2(content, ISSUE_LABELS);
   const issueNumberMatch = issueRaw?.match(/^#(\d+)$/);
@@ -7851,16 +8036,20 @@ function parseTasksDoc(content) {
       title: match[2].trim()
     });
   }
-  const allTasksChecked = nonCodeLines.some(
-    (line) => /(All tasks are|모든 태스크가)/i.test(line) && parseMarkdownCheckbox(line) === true
+  const allTasksChecked = parseCompletionCheckbox(
+    nonCodeLines,
+    COMPLETION_MARKERS.allTasks,
+    /(All tasks are|모든 태스크가)/i
   );
-  const testsChecked = nonCodeLines.some(
-    (line) => /(Tests executed and passing|테스트 실행 및 통과)/i.test(line) && parseMarkdownCheckbox(line) === true
+  const testsChecked = parseCompletionCheckbox(
+    nonCodeLines,
+    COMPLETION_MARKERS.tests,
+    /(Tests executed and passing|테스트 실행 및 통과)/i
   );
-  const finalOutcomeChecked = nonCodeLines.some(
-    (line) => /(Final outcome shared and any required user confirmation recorded|Final user approval|최종 결과를 공유했고, 필요한 사용자 확인을 문서화된 workflow checkpoint 기준으로 기록함)/i.test(
-      line
-    ) && parseMarkdownCheckbox(line) === true
+  const finalOutcomeChecked = parseCompletionCheckbox(
+    nonCodeLines,
+    COMPLETION_MARKERS.finalOutcome,
+    /(Final outcome shared and any required user confirmation recorded|Final user approval|최종 결과를 공유했고, 필요한 사용자 확인을 문서화된 workflow checkpoint 기준으로 기록함)/i
   );
   const prStatus = (() => {
     const value = (extractFieldValue2(content, PR_STATUS_LABELS) || "").trim().toLowerCase();
@@ -8116,8 +8305,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}`);
@@ -8987,11 +9181,13 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       "implementation_approve",
       true
     );
-    const localIntegrationApproval = config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) === "local-ff";
+    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: 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.",
+      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 {
@@ -9002,7 +9198,7 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       stage: "implementation_approve",
       nextAction: buildAction(
         "implementation_approve",
-        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.",
+        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,
@@ -9031,10 +9227,51 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       blockedReasonCode: "PRE_PR_REVIEW_NOT_APPROVED"
     };
   }
-  if (config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) === "local-ff") {
+  if (config.workflow?.mode === "local" && resolveLocalCompletionStrategy(config) !== "none") {
     const localState = await resolveLocalIntegrationContext(config, feature);
+    const localVerifyCommand = `npx lee-spec-kit local verify ${buildFeatureArgs(feature)} --json`;
     const localMergeBaseCommand = `npx lee-spec-kit local merge ${buildFeatureArgs(feature)} --json`;
-    if (!localState.baseContainsFeature) {
+    if (!localState.integrationComplete) {
+      const featureVerified = !!localState.state && ["feature_verified", "merged", "verified", "cleaned"].includes(
+        localState.state.status
+      ) && localState.state.verifiedFeatureTip === localState.featureTip && localState.state.verifiedFeatureTree === localState.featureTree;
+      const featureVerificationFailed = localState.state?.status === "feature_failed" && localState.state.featureTip === localState.featureTip;
+      if (featureVerificationFailed) {
+        return {
+          status: "ok",
+          reasonCode: "WORKFLOW_STAGE_RESOLVED",
+          docsDir: config.docsDir,
+          featureRef: buildFeatureRef(feature),
+          stage: "feature_remediation",
+          nextAction: buildAction(
+            "feature_remediation",
+            `Fix the failed checks in ${localState.featureBranch} at ${localState.featureWorktree}, commit the remediation, then verify the new Feature tip. Re-run the command without code changes to retry an environmental failure.`,
+            false,
+            localVerifyCommand
+          ),
+          approvalRequired: false,
+          implementationAllowed: true,
+          blockedReasonCode: "FEATURE_REMEDIATION_REQUIRED"
+        };
+      }
+      if (!featureVerified) {
+        return {
+          status: "ok",
+          reasonCode: "WORKFLOW_STAGE_RESOLVED",
+          docsDir: config.docsDir,
+          featureRef: buildFeatureRef(feature),
+          stage: "feature_verify",
+          nextAction: buildAction(
+            "feature_verify",
+            `Run the configured Feature checks in ${localState.featureBranch} before integration and bind the result to its exact commit and tree.`,
+            false,
+            localVerifyCommand
+          ),
+          approvalRequired: false,
+          implementationAllowed: false,
+          blockedReasonCode: "FEATURE_VERIFICATION_REQUIRED"
+        };
+      }
       const approvalRequired = resolveActionApprovalRequired(
         config,
         "local_merge",
@@ -9042,7 +9279,7 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
       );
       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.`,
+        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 {
@@ -9053,7 +9290,7 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
         stage: "local_merge",
         nextAction: buildAction(
           "local_merge",
-          `Fast-forward ${localState.featureBranch} into ${localState.baseBranch}; do not create a merge commit.`,
+          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
         ),
@@ -9991,35 +10228,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;
@@ -10046,6 +10269,7 @@ function commitAuditCommand(program2) {
             2
           )
         );
+        if (options.enforce) process.exitCode = 1;
         return;
       }
       process.stderr.write(`[${cliError.code}] ${cliError.message}
@@ -10054,6 +10278,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) {
@@ -10277,10 +10513,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;
@@ -10290,15 +10533,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) {
@@ -10609,7 +10852,15 @@ async function collectDocsAudit(cwd) {
 // 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(
+  local.command("verify [feature-name]").description("Verify the exact Feature tip before local integration").option("--component <component>", "Component name for multi projects").option("--json", "Output JSON for agents and hooks").action(
+    async (featureName, options) => {
+      await runLocalAction(
+        options,
+        () => runLocalVerify(featureName, options)
+      );
+    }
+  );
+  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(
@@ -10629,6 +10880,111 @@ function localCommand(program2) {
     }
   );
 }
+async function runLocalVerify(featureName, options) {
+  const cwd = process.cwd();
+  const stage = await collectWorkflowStage(cwd, featureName, options.component);
+  if (stage.status !== "ok" || !stage.nextAction || !["feature_verify", "feature_remediation"].includes(stage.nextAction.category)) {
+    return blocked(
+      "LOCAL_FEATURE_VERIFY_STAGE_REQUIRED",
+      stage.featureRef,
+      "The active workflow is not at feature_verify or feature_remediation."
+    );
+  }
+  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;
+  const context = await resolveLocalIntegrationContext(config, feature);
+  if (!context.featureTip || !context.featureTree) {
+    return blocked("LOCAL_MERGE_REF_NOT_FOUND", feature.folderName);
+  }
+  if (!context.featureWorktreeClean || !context.docsClean) {
+    return blocked(
+      "LOCAL_FEATURE_VERIFY_DIRTY_WORKTREE",
+      feature.folderName,
+      "Feature worktree and docs repo must be clean before verification."
+    );
+  }
+  const targetTip = context.featureTip;
+  const targetTree = context.featureTree;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const logDir = resolveLocalIntegrationLogDir(
+    context.projectRoot,
+    feature,
+    targetTip
+  );
+  const verification = runLocalChecks(
+    context.featureWorktree,
+    context.featureChecks,
+    targetTip,
+    logDir,
+    "feature"
+  );
+  const refreshed = await resolveLocalIntegrationContext(config, feature);
+  const changedDuringVerification = refreshed.featureTip !== targetTip || refreshed.featureTree !== targetTree || !refreshed.featureWorktreeClean;
+  const failed = verification.some((entry) => entry.exitCode !== 0);
+  const baseState = {
+    version: 1,
+    featureRef: feature.folderName,
+    component: feature.type,
+    baseBranch: context.baseBranch,
+    featureBranch: context.featureBranch,
+    featureTip: targetTip,
+    mergedBaseTip: context.baseTip || targetTip,
+    strategy: context.completionStrategy,
+    status: failed || changedDuringVerification ? "feature_failed" : "feature_verified",
+    mergedAt: context.state?.mergedAt || now,
+    featureVerifiedAt: failed || changedDuringVerification ? null : now,
+    verifiedAt: null,
+    cleanedAt: null,
+    ...failed || changedDuringVerification ? {} : {
+      verifiedFeatureTip: targetTip,
+      verifiedFeatureTree: targetTree
+    },
+    featureVerification: verification,
+    postMergeVerification: [],
+    verification
+  };
+  await writeLocalIntegrationState(context.projectRoot, feature, baseState);
+  if (changedDuringVerification) {
+    return {
+      ...blocked(
+        "LOCAL_FEATURE_CHANGED_DURING_VERIFICATION",
+        feature.folderName,
+        "The Feature tip, tree, or worktree changed while checks were running."
+      ),
+      featureTip: refreshed.featureTip,
+      verification
+    };
+  }
+  if (failed) {
+    return {
+      ...blocked("LOCAL_FEATURE_CHECK_FAILED", feature.folderName),
+      featureTip: targetTip,
+      verification
+    };
+  }
+  return {
+    status: "ok",
+    reasonCode: "LOCAL_FEATURE_VERIFIED",
+    featureRef: feature.folderName,
+    baseBranch: context.baseBranch,
+    featureBranch: context.featureBranch,
+    featureTip: targetTip,
+    baseTip: context.baseTip,
+    completionStrategy: context.completionStrategy,
+    verification
+  };
+}
 async function runLocalAction(options, action) {
   try {
     const payload = await action();
@@ -10700,6 +11056,15 @@ async function runLocalMerge(featureName, options) {
       "Both the configured base branch and Feature tip must exist."
     );
   }
+  if (!context.integrationComplete && (!context.state || !["feature_verified", "merged", "verified", "cleaned"].includes(
+    context.state.status
+  ) || context.state.verifiedFeatureTip !== context.featureTip || context.state.verifiedFeatureTree !== context.featureTree)) {
+    return blocked(
+      "LOCAL_FEATURE_VERIFICATION_REQUIRED",
+      feature.folderName,
+      "Verify the exact Feature tip before local integration."
+    );
+  }
   if (!context.featureWorktreeClean || !context.projectRootClean || !context.docsClean) {
     return blocked(
       "LOCAL_MERGE_DIRTY_WORKTREE",
@@ -10708,7 +11073,9 @@ async function runLocalMerge(featureName, options) {
     );
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  let state = context.state || {
+  const originalBaseTip = context.baseTip;
+  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,
@@ -10716,20 +11083,39 @@ async function runLocalMerge(featureName, options) {
     featureBranch: context.featureBranch,
     featureTip: context.featureTip,
     mergedBaseTip: context.baseTip,
+    strategy: context.completionStrategy,
     status: "merged",
     mergedAt: now,
     verifiedAt: null,
     cleanedAt: null,
     verification: []
   };
-  if (!context.baseContainsFeature) {
+  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(
-        "LOCAL_MERGE_NOT_FAST_FORWARD",
+        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}.`
       );
@@ -10747,26 +11133,22 @@ async function runLocalMerge(featureName, options) {
         );
       }
     }
-    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 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,
+      originalBaseTip,
+      ...integratedTree ? { integratedTree } : {},
+      ...context.completionStrategy === "local-squash" ? { evidenceRef: context.evidenceRef } : {},
       status: "merged",
       mergedAt: now,
       verifiedAt: null,
@@ -10776,19 +11158,39 @@ async function runLocalMerge(featureName, options) {
     await writeLocalIntegrationState(context.projectRoot, feature, state);
     context = await resolveLocalIntegrationContext(config, feature);
   }
-  if (!context.baseContainsFeature) {
+  if (!context.integrationComplete) {
     return blocked("LOCAL_MERGE_VERIFICATION_FAILED", feature.folderName);
   }
-  const verification = runPostMergeChecks(
+  const integratedTip = resolveRef(
     context.projectRoot,
-    context.postMergeChecks
+    `refs/heads/${context.baseBranch}`
   );
-  const failedCheck = verification.find((entry) => entry.exitCode !== 0);
+  const verificationTarget = integratedTip || state.featureTip;
+  const postMergeVerification = runLocalChecks(
+    context.projectRoot,
+    context.postMergeChecks,
+    verificationTarget,
+    resolveLocalIntegrationLogDir(
+      context.projectRoot,
+      feature,
+      verificationTarget
+    ),
+    "post-merge"
+  );
+  const featureVerification = state.featureVerification || context.state?.featureVerification || [];
+  const verification = [...featureVerification, ...postMergeVerification];
+  const failedCheck = postMergeVerification.find((entry) => entry.exitCode !== 0);
   if (failedCheck) {
+    rollbackLocalIntegration(context, originalBaseTip);
     await writeLocalIntegrationState(context.projectRoot, feature, {
       ...state,
-      status: "merged",
+      status: "feature_failed",
+      mergedBaseTip: originalBaseTip,
+      integratedCommit: void 0,
+      integratedTree: void 0,
       verification,
+      featureVerification,
+      postMergeVerification,
       verifiedAt: null
     });
     return {
@@ -10814,7 +11216,9 @@ async function runLocalMerge(featureName, options) {
     mergedBaseTip: baseTip || verifiedFeatureTip,
     status: "verified",
     verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    verification
+    verification,
+    featureVerification,
+    postMergeVerification
   };
   await writeLocalIntegrationState(context.projectRoot, feature, verifiedState);
   return {
@@ -10825,9 +11229,19 @@ async function runLocalMerge(featureName, options) {
     featureBranch: context.featureBranch,
     featureTip: context.featureTip,
     baseTip,
+    completionStrategy: context.completionStrategy,
     verification
   };
 }
+function rollbackLocalIntegration(context, originalBaseTip) {
+  gitRun(context.projectRoot, ["reset", "--hard", originalBaseTip]);
+  if (context.completionStrategy === "local-squash") {
+    gitRun(context.projectRoot, ["update-ref", "-d", context.evidenceRef]);
+  }
+  if (!context.managedFeatureWorktree) {
+    gitRun(context.projectRoot, ["checkout", context.featureBranch]);
+  }
+}
 async function runLocalCleanup(featureName, options) {
   const cwd = process.cwd();
   const stage = await collectWorkflowStage(cwd, featureName, options.component);
@@ -10855,7 +11269,7 @@ async function runLocalCleanup(featureName, options) {
   }
   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) {
+  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) {
@@ -10881,7 +11295,7 @@ async function runLocalCleanup(featureName, options) {
   if (context.deleteFeatureBranchAfterMerge && context.featureBranchExists) {
     const removeBranch = gitRun(context.projectRoot, [
       "branch",
-      "-d",
+      context.completionStrategy === "local-squash" ? "-D" : "-d",
       context.featureBranch
     ]);
     if (removeBranch.code !== 0) {
@@ -10905,9 +11319,106 @@ async function runLocalCleanup(featureName, options) {
     baseBranch: context.baseBranch,
     featureBranch: context.featureBranch,
     featureTip: context.featureTip,
-    baseTip: context.baseTip
+    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",