lee-spec-kit 0.9.1 → 0.9.3

package/README.en.md

@@ -79,7 +79,8 @@ The overall approach is influenced by [spec-kit](https://github.com/github/spec-
 - `integrations codex`: install/remove the optional global `[features].hooks` setting
 - `commit-audit --json`
 - `workflow-audit --json`
-- `local merge <feature-ref> --json`: integrate a completed local Feature using its configured fast-forward or squash strategy and run post-merge checks
+- `local verify <feature-ref> --json`: run checks in the local Feature worktree and bind the result to its exact tip/tree
+- `local merge <feature-ref> --json`: integrate a verified local Feature using its configured fast-forward or squash strategy
 - `local cleanup <feature-ref> --json`: remove the managed worktree and optionally delete the integrated Feature branch
 
 Supported modes:

package/README.md

@@ -79,7 +79,8 @@ npx lee-spec-kit feature user-auth
 - `integrations codex`: 선택적 전역 `[features].hooks` 설정 설치/제거
 - `commit-audit --json`: hooks용 commit-time docs path + canonical commit subject validator
 - `workflow-audit --json`: hooks용 docs sync validator
-- `local merge <feature-ref> --json`: 완료된 local Feature를 설정된 fast-forward 또는 squash 전략으로 base branch에 통합하고 사후 검증 실행
+- `local verify <feature-ref> --json`: local Feature worktree에서 검사를 실행하고 결과를 정확한 tip/tree에 결속
+- `local merge <feature-ref> --json`: 검증된 local Feature를 설정된 fast-forward 또는 squash 전략으로 base branch에 통합
 - `local cleanup <feature-ref> --json`: managed worktree 제거 및 설정에 따른 통합 완료 Feature 브랜치 삭제
 
 지원 모드:

package/dist/index.js

@@ -1308,7 +1308,7 @@ 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\`
+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:
@@ -2543,6 +2543,7 @@ async function runInit(options) {
             baseBranch: resolveInitialBaseBranch(cwd, docsRepo, projectRoot),
             completionStrategy: "local-ff",
             deleteFeatureBranchAfterMerge: true,
+            featureChecks: [],
             postMergeChecks: []
           } : {},
           prePrReview: {
@@ -3748,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 = [];
@@ -7693,9 +7721,17 @@ async function resolveLocalIntegrationContext(config, feature) {
   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 squashCommitMatchesSource = completionStrategy === "local-squash" && state?.strategy === "local-squash" && !!featureTip && state.featureTip === featureTip && !!integratedCommit && !!baseTip && integratedCommit === baseTip && !!featureTree && integratedTree === featureTree && state.integratedTree === featureTree;
   const squashEvidencePresent = !!featureTip && evidenceTip === featureTip;
   const squashIntegrationComplete = squashCommitMatchesSource && squashEvidencePresent;
+  const recordedStrategy = state?.strategy || "local-ff";
+  const recordedIntegratedCommit = state?.integratedCommit || state?.mergedBaseTip || null;
+  const baseContainsRecordedIntegration = !!recordedIntegratedCommit && isAncestor(
+    projectRoot,
+    recordedIntegratedCommit,
+    `refs/heads/${baseBranch}`
+  );
+  const cleanedIntegrationStillValid = state?.status === "cleaned" && recordedStrategy === completionStrategy && state.featureTip === featureTip && baseContainsRecordedIntegration && (completionStrategy === "local-squash" ? state.integratedCommit === recordedIntegratedCommit && state.integratedTree === featureTree && squashEvidencePresent : state.mergedBaseTip === featureTip && baseContainsFeature);
   return {
     projectRoot,
     featureWorktree: effectiveFeatureWorktree,
@@ -7703,12 +7739,14 @@ async function resolveLocalIntegrationContext(config, feature) {
     baseBranch,
     featureBranch,
     featureTip,
+    featureTree,
     baseTip,
     currentBranch,
     state,
     completionStrategy,
     baseContainsFeature,
-    integrationComplete: completionStrategy === "local-squash" ? squashIntegrationComplete : baseContainsFeature,
+    integrationComplete: completionStrategy === "local-squash" ? squashIntegrationComplete : !!featureTip && baseTip === featureTip,
+    cleanedIntegrationStillValid,
     evidenceRef,
     squashCommitMatchesSource,
     squashEvidencePresent,
@@ -7717,7 +7755,10 @@ async function resolveLocalIntegrationContext(config, feature) {
     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
   };
 }
@@ -7742,20 +7783,69 @@ async function readLocalIntegrationState(projectRoot, feature) {
 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) {
+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);
 }
@@ -7847,7 +7937,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()
@@ -7866,6 +7956,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";
@@ -7920,6 +8015,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+)$/);
@@ -7940,16 +8045,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();
@@ -9129,8 +9238,62 @@ Task commit boundary warning: ${describeTaskCommitGateFailure(committedTaskGate)
   }
   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.cleanedIntegrationStillValid) {
+      return {
+        status: "ok",
+        reasonCode: "WORKFLOW_STAGE_RESOLVED",
+        docsDir: config.docsDir,
+        featureRef: buildFeatureRef(feature),
+        stage: "done",
+        nextAction: null,
+        approvalRequired: false,
+        implementationAllowed: false,
+        blockedReasonCode: null
+      };
+    }
     if (!localState.integrationComplete) {
+      const featureVerified = !!localState.state && ["feature_verified", "merged", "verified", "cleaned"].includes(
+        localState.state.status
+      ) && 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",
@@ -10711,6 +10874,14 @@ 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("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"
@@ -10731,6 +10902,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();
@@ -10802,6 +11078,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",
@@ -10810,6 +11095,7 @@ async function runLocalMerge(featureName, options) {
     );
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  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,
@@ -10882,6 +11168,7 @@ async function runLocalMerge(featureName, options) {
       mergedBaseTip: mergedBaseTip || context.featureTip,
       strategy: context.completionStrategy,
       integratedCommit: mergedBaseTip || context.featureTip,
+      originalBaseTip,
       ...integratedTree ? { integratedTree } : {},
       ...context.completionStrategy === "local-squash" ? { evidenceRef: context.evidenceRef } : {},
       status: "merged",
@@ -10896,16 +11183,36 @@ async function runLocalMerge(featureName, options) {
   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 {
@@ -10931,7 +11238,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 {
@@ -10946,6 +11255,15 @@ async function runLocalMerge(featureName, options) {
     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);