@pourkit/cli 0.0.0-next-20260608221925 → 0.0.0-next-20260609130908

package/dist/cli.js

@@ -1354,13 +1354,7 @@ function buildRunContextMarkdown(options) {
     );
   }
   if (sections.includes("verification-commands")) {
-    parts.push(
-      ...renderCommandList(
-        target,
-        getVerificationCommands(target),
-        "Verification Commands"
-      )
-    );
+    parts.push(...renderCommandList(target, "Verification Commands"));
   }
   if (sections.includes("review-criteria")) {
     parts.push(...renderCriteria(reviewerCriteria));
@@ -1378,29 +1372,11 @@ function buildRunContextMarkdown(options) {
   }
   return parts.join("\n");
 }
-function renderCommandList(target, commands, heading) {
-  if (commands.length === 0) {
-    return [
-      `## ${heading}`,
-      "",
-      `Run this command from the repository root: \`${buildRunVerificationCommand(target)}\``,
-      "",
-      "Underlying project commands:",
-      "",
-      "(none configured)",
-      ""
-    ];
-  }
+function renderCommandList(target, heading) {
   return [
     `## ${heading}`,
     "",
     `Run this command from the repository root: \`${buildRunVerificationCommand(target)}\``,
-    "",
-    "Underlying project commands:",
-    "",
-    "Run these commands from the repository root exactly as written. Do not substitute equivalent scripts from nested package.json files.",
-    "",
-    ...commands.map((command) => `- ${command.label}: \`${command.command}\``),
     ""
   ];
 }
@@ -8597,7 +8573,20 @@ var LocalPrdRunRecordSchema = z3.object({
       baseCommit: z3.string().min(1)
     }).optional(),
     queue: z3.object({ completedAt: z3.string().min(1) }).optional(),
-    finalReview: z3.object({ completedAt: z3.string().min(1) }).optional(),
+    finalReview: z3.object({
+      completedAt: z3.string().min(1),
+      targetName: z3.string().optional(),
+      prdBranch: z3.string().optional(),
+      mergeBase: z3.string().optional(),
+      verdict: z3.enum([
+        "pass_no_changes",
+        "pass_with_retouch",
+        "needs_human_review",
+        "blocked"
+      ]).optional(),
+      diagnostics: z3.array(z3.string()).optional(),
+      artifactPath: z3.string().optional()
+    }).optional(),
     reconciliation: z3.object({ completedAt: z3.string().min(1) }).optional(),
     complete: z3.object({
       completedAt: z3.string().min(1),
@@ -9278,7 +9267,7 @@ async function runLocalFinalReview(prdId, options) {
   }
   let verdict;
   if (commands.length === 0 || failures.length === 0) {
-    const retouchBranch = `local/${prdId}/retouch`;
+    const retouchBranch = `local-${prdId}-final-review-retouch`;
     try {
       execSync2(`git show-ref --verify --quiet refs/heads/${retouchBranch}`, {
         cwd: root,
@@ -9292,7 +9281,7 @@ async function runLocalFinalReview(prdId, options) {
   } else if (failures.length === commands.length) {
     verdict = "blocked";
   } else {
-    const retouchBranch = `local/${prdId}/retouch`;
+    const retouchBranch = `local-${prdId}-final-review-retouch`;
     try {
       execSync2(`git show-ref --verify --quiet refs/heads/${retouchBranch}`, {
         cwd: root,
@@ -9321,10 +9310,10 @@ async function runLocalFinalReview(prdId, options) {
   }
   return result;
 }
-async function squashFinalReviewRetouch(prdId, repoRoot2) {
+async function squashFinalReviewRetouch(prdId, repoRoot2, title, body) {
   const root = repoRoot2 ?? process.cwd();
   const targetBranch = `local/${prdId}`;
-  const retouchBranch = `local/${prdId}/retouch`;
+  const retouchBranch = `local-${prdId}-final-review-retouch`;
   try {
     execFileSync3(
       "git",
@@ -9371,15 +9360,26 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
       return;
     } catch {
     }
-    execFileSync3(
-      "git",
-      ["commit", "-m", `Squash merge ${retouchBranch} into ${targetBranch}`],
-      {
+    if (title) {
+      const commitBody = body ? `${title}
+
+${body}` : title;
+      execFileSync3("git", ["commit", "-m", commitBody], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
-      }
-    );
+      });
+    } else {
+      execFileSync3(
+        "git",
+        ["commit", "-m", `Squash merge ${retouchBranch} into ${targetBranch}`],
+        {
+          cwd: root,
+          encoding: "utf8",
+          stdio: "pipe"
+        }
+      );
+    }
     const mergeCommit = execFileSync3("git", ["rev-parse", "HEAD"], {
       cwd: root,
       encoding: "utf8",
@@ -10722,10 +10722,6 @@ function loadFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
   return existsSync17(promptPath) ? readFileSync17(promptPath, "utf-8") : promptTemplate;
 }
-function formatVerificationCommands(commands) {
-  if (commands.length === 0) return "No verification commands configured.";
-  return commands.map((cmd) => `- ${cmd.label}: ${cmd.command}`).join("\n");
-}
 function buildFinalReviewPrompt(options) {
   return [
     "# Active PRD Final Review Context",
@@ -10740,9 +10736,6 @@ function buildFinalReviewPrompt(options) {
     "",
     `Run this command before handoff when retouch changes are made: pourkit run-verification --target ${options.targetName}`,
     "",
-    "Underlying project commands:",
-    formatVerificationCommands(options.verificationCommands),
-    "",
     "Evidence Packet (do not infer PRD context from local state files):",
     JSON.stringify(options.evidencePacket, null, 2),
     "",
@@ -10867,9 +10860,6 @@ function buildFinalReviewFinalizerPrompt(options) {
     "Changed paths:",
     ...options.changedPaths.map((p) => `- ${p}`),
     "",
-    "Verification commands given to Final Review:",
-    formatVerificationCommands(options.verificationCommands),
-    "",
     promptBody
   ].join("\n");
 }
@@ -10896,8 +10886,7 @@ async function runFinalReviewPrFinalizer(options) {
           prdBranch: options.prdBranch,
           mergeBase: options.mergeBase,
           summary: options.summary,
-          changedPaths: options.changedPaths,
-          verificationCommands: options.verificationCommands
+          changedPaths: options.changedPaths
         }),
         branchName: options.branchName,
         repoRoot: options.repoRoot,
@@ -10957,17 +10946,32 @@ function ensureFinalReviewWorktree(options) {
     };
   }
   mkdirSync11(dirname5(worktreePath), { recursive: true });
-  const branchResult = spawnSync3(
-    "git",
-    ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
-    { cwd: options.repoRoot, encoding: "utf8" }
-  );
-  if (branchResult.status !== 0) {
-    return {
-      ok: false,
-      reason: `Final Review failed to prepare branch ${options.branchName}.`,
-      diagnostics: collectSpawnDiagnostics(branchResult, "git branch failed")
-    };
+  if (options.isLocal) {
+    const branchResult = spawnSync3(
+      "git",
+      ["branch", "-f", options.branchName, options.checkoutBase],
+      { cwd: options.repoRoot, encoding: "utf8" }
+    );
+    if (branchResult.status !== 0) {
+      return {
+        ok: false,
+        reason: `Final Review failed to prepare branch ${options.branchName}.`,
+        diagnostics: collectSpawnDiagnostics(branchResult, "git branch failed")
+      };
+    }
+  } else {
+    const branchResult = spawnSync3(
+      "git",
+      ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
+      { cwd: options.repoRoot, encoding: "utf8" }
+    );
+    if (branchResult.status !== 0) {
+      return {
+        ok: false,
+        reason: `Final Review failed to prepare branch ${options.branchName}.`,
+        diagnostics: collectSpawnDiagnostics(branchResult, "git branch failed")
+      };
+    }
   }
   const addResult = spawnSync3(
     "git",
@@ -11079,6 +11083,156 @@ async function createOrReuseFinalReviewRetouchPr(options) {
     })
   });
 }
+async function writeAndVerifyLocalDualReceipt(repoRoot2, prdRef, record, targetName, prdBranch, mergeBase, verdict, reviewedAt, isLocalMode) {
+  if (!isLocalMode) return null;
+  let currentRecord = await readLocalPrdRun(repoRoot2, prdRef);
+  if (!currentRecord) {
+    currentRecord = {
+      prdId: normalizePrdRunRef2(prdRef),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      receipts: {},
+      metadata: {}
+    };
+  }
+  const localStoreReceipt = {
+    completedAt: reviewedAt,
+    targetName,
+    prdBranch,
+    mergeBase,
+    verdict,
+    diagnostics: [],
+    artifactPath: ".pourkit/final-review-artifact.json"
+  };
+  await writeLocalPrdRunRecord(repoRoot2, prdRef, {
+    ...currentRecord,
+    receipts: {
+      ...currentRecord.receipts,
+      finalReview: localStoreReceipt
+    }
+  });
+  const prdRunStateResult = readPrdRun(repoRoot2, prdRef);
+  const localStoreResult = await readLocalPrdRun(repoRoot2, prdRef);
+  if (!prdRunStateResult.record?.finalReview) {
+    const reason = `PRD Run State missing finalReview receipt after write for ${prdRef}.`;
+    writePrdRunRecord(repoRoot2, {
+      ...record,
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      targetName,
+      offendingPaths: []
+    });
+    return {
+      prdRef,
+      status: "blocked",
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      offendingPaths: []
+    };
+  }
+  if (!localStoreResult?.receipts.finalReview) {
+    const reason = `Local PRD Run store missing finalReview receipt after write for ${prdRef}.`;
+    writePrdRunRecord(repoRoot2, {
+      ...record,
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      targetName,
+      offendingPaths: []
+    });
+    return {
+      prdRef,
+      status: "blocked",
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      offendingPaths: []
+    };
+  }
+  const stateFr = prdRunStateResult.record.finalReview;
+  const localFr = localStoreResult.receipts.finalReview;
+  const mismatchFields = [];
+  if (stateFr.targetName !== localFr.targetName)
+    mismatchFields.push("targetName");
+  if (stateFr.prdBranch !== localFr.prdBranch) mismatchFields.push("prdBranch");
+  if (stateFr.mergeBase !== localFr.mergeBase) mismatchFields.push("mergeBase");
+  if (stateFr.verdict !== localFr.verdict) mismatchFields.push("verdict");
+  if (!stateFr.artifactPath !== !localFr.artifactPath)
+    mismatchFields.push("artifactPath");
+  if (!stateFr.diagnostics !== !localFr.diagnostics)
+    mismatchFields.push("diagnostics");
+  if (!stateFr.reviewedAt !== !localFr.completedAt)
+    mismatchFields.push("reviewedTimestamp");
+  if (mismatchFields.length > 0) {
+    const reason = `Dual receipt mismatch on fields: ${mismatchFields.join(", ")}`;
+    writePrdRunRecord(repoRoot2, {
+      ...record,
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      targetName,
+      finalReview: stateFr,
+      offendingPaths: []
+    });
+    return {
+      prdRef,
+      status: "blocked",
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      offendingPaths: []
+    };
+  }
+  return null;
+}
+async function verifyLocalDualFinalReviewReceipts(repoRoot2, prdRef) {
+  const prdRunStateResult = readPrdRun(repoRoot2, prdRef);
+  const stateFr = prdRunStateResult.record?.finalReview;
+  const localStoreResult = await readLocalPrdRun(repoRoot2, prdRef);
+  const localFr = localStoreResult?.receipts.finalReview;
+  const diagnostics = [];
+  const validFinalReviewStatuses = /* @__PURE__ */ new Set(["final_reviewed", "succeeded"]);
+  if (!stateFr || !validFinalReviewStatuses.has(stateFr.status)) {
+    diagnostics.push(
+      stateFr ? `PRD Run State finalReview status is "${stateFr.status}". Expected "final_reviewed" or "succeeded".` : "PRD Run State has no finalReview receipt."
+    );
+    return {
+      ok: false,
+      reason: diagnostics[0],
+      diagnostics
+    };
+  }
+  if (!localFr) {
+    diagnostics.push("Local PRD Run Store has no finalReview receipt.");
+    return {
+      ok: false,
+      reason: diagnostics[0],
+      diagnostics
+    };
+  }
+  const mismatchFields = [];
+  if (stateFr.targetName !== localFr.targetName)
+    mismatchFields.push("targetName");
+  if (stateFr.prdBranch !== localFr.prdBranch) mismatchFields.push("prdBranch");
+  if (stateFr.mergeBase !== localFr.mergeBase) mismatchFields.push("mergeBase");
+  if (stateFr.verdict !== localFr.verdict) mismatchFields.push("verdict");
+  if (mismatchFields.length > 0) {
+    const reason = `Dual receipt mismatch on fields: ${mismatchFields.join(", ")}`;
+    diagnostics.push(reason);
+    return { ok: false, reason, diagnostics };
+  }
+  return { ok: true };
+}
 async function runPrdRunFinalReviewCommand(options) {
   const prdRef = normalizePrdRunRef2(options.prdRef);
   const targetName = options.targetName.trim();
@@ -11143,6 +11297,39 @@ async function runPrdRunFinalReviewCommand(options) {
       offendingPaths: []
     };
   }
+  if (record.mode === "local") {
+    const runnableIssues = await getRunnableLocalIssues(
+      prdRef,
+      options.repoRoot
+    );
+    if (runnableIssues.length > 0) {
+      const reason = `PRD Run ${prdRef} is marked "drained" but ${runnableIssues.length} runnable local Issues remain. Queue drain receipt may be premature.`;
+      writePrdRunRecord(options.repoRoot, {
+        ...record,
+        status: "blocked",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        blockedGate: "final-review",
+        blockedReason: reason,
+        diagnostics: [
+          `Current status: ${record.status}`,
+          `Runnable issues remaining: ${runnableIssues.length}`
+        ],
+        targetName,
+        offendingPaths: []
+      });
+      return {
+        prdRef,
+        status: "blocked",
+        blockedGate: "final-review",
+        blockedReason: reason,
+        diagnostics: [
+          `Current status: ${record.status}`,
+          `Runnable issues remaining: ${runnableIssues.length}`
+        ],
+        offendingPaths: []
+      };
+    }
+  }
   if (!options.issueProvider) {
     const reason = "Missing IssueProvider. Cannot validate child completeness.";
     writePrdRunRecord(options.repoRoot, {
@@ -11251,8 +11438,19 @@ async function runPrdRunFinalReviewCommand(options) {
       offendingPaths: []
     };
   }
-  const verificationCommands = targetConfig.strategy.verify?.commands ?? [];
-  const mergeBaseResult = computeFinalReviewMergeBase(options.repoRoot, prdRef);
+  const isLocalMode = record.mode === "local";
+  let mergeBaseResult;
+  let prdBranch;
+  if (isLocalMode) {
+    prdBranch = getLocalPrdBranchName(prdRef);
+    mergeBaseResult = computeLocalFinalReviewMergeBase(
+      options.repoRoot,
+      prdBranch
+    );
+  } else {
+    prdBranch = record.prdBranch ?? prdRef;
+    mergeBaseResult = computeFinalReviewMergeBase(options.repoRoot, prdRef);
+  }
   if (!mergeBaseResult.ok) {
     writePrdRunRecord(options.repoRoot, {
       ...record,
@@ -11265,7 +11463,7 @@ async function runPrdRunFinalReviewCommand(options) {
       finalReview: {
         status: "blocked",
         targetName,
-        prdBranch: record.prdBranch ?? prdRef,
+        prdBranch,
         mergeBase: mergeBaseResult.mergeBase,
         diagnostics: mergeBaseResult.diagnostics,
         reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -11281,7 +11479,6 @@ async function runPrdRunFinalReviewCommand(options) {
       offendingPaths: []
     };
   }
-  const prdBranch = record.prdBranch ?? prdRef;
   const manifestResult = readPlanningArtifactManifest(options.repoRoot, prdRef);
   if (!manifestResult.ok) {
     const reason = `Evidence Packet construction failed: ${manifestResult.reason}`;
@@ -11341,11 +11538,12 @@ async function runPrdRunFinalReviewCommand(options) {
     planning: record.planning,
     finalReview: startReceipt
   });
-  const finalReviewBranchName = buildFinalReviewBranchName(prdBranch);
+  const finalReviewBranchName = isLocalMode ? `${prdBranch.replace(/\//g, "-")}-final-review-retouch` : buildFinalReviewBranchName(prdBranch);
   const worktreeResult = ensureFinalReviewWorktree({
     repoRoot: options.repoRoot,
     branchName: finalReviewBranchName,
-    checkoutBase: prdBranch
+    checkoutBase: prdBranch,
+    isLocal: isLocalMode
   });
   if (!worktreeResult.ok) {
     writePrdRunRecord(options.repoRoot, {
@@ -11386,8 +11584,7 @@ async function runPrdRunFinalReviewCommand(options) {
         repoRoot: options.repoRoot,
         promptTemplate: finalReviewConfig.promptTemplate,
         targetName,
-        evidencePacket,
-        verificationCommands
+        evidencePacket
       }),
       target: targetConfig,
       repoRoot: options.repoRoot,
@@ -11530,6 +11727,7 @@ async function runPrdRunFinalReviewCommand(options) {
   }
   const { verdict, summary, diagnostics: artifactDiagnostics } = artifactResult;
   if (verdict === "pass_no_changes") {
+    const reviewedAt = (/* @__PURE__ */ new Date()).toISOString();
     const receipt = {
       status: "succeeded",
       targetName,
@@ -11538,17 +11736,29 @@ async function runPrdRunFinalReviewCommand(options) {
       verdict: "pass_no_changes",
       artifactPath: ".pourkit/final-review-artifact.json",
       diagnostics: [],
-      reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+      reviewedAt
     };
     writePrdRunRecord(options.repoRoot, {
       ...record,
       status: "final_reviewed",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: reviewedAt,
       targetName,
       start: record.start,
       planning: record.planning,
       finalReview: receipt
     });
+    const blocked = await writeAndVerifyLocalDualReceipt(
+      options.repoRoot,
+      prdRef,
+      record,
+      targetName,
+      prdBranch,
+      mergeBaseResult.mergeBase,
+      "pass_no_changes",
+      reviewedAt,
+      isLocalMode
+    );
+    if (blocked) return blocked;
     return {
       prdRef,
       status: "final_reviewed",
@@ -11557,7 +11767,7 @@ async function runPrdRunFinalReviewCommand(options) {
     };
   }
   if (verdict === "pass_with_retouch") {
-    if (!options.prProvider) {
+    if (!options.prProvider && !isLocalMode) {
       const reason = "Missing PRProvider. Cannot create retouch PR without a PR provider.";
       writePrdRunRecord(options.repoRoot, {
         ...record,
@@ -11588,7 +11798,7 @@ async function runPrdRunFinalReviewCommand(options) {
       };
     }
     const autoMerge = options.autoMerge ?? true;
-    const existingRetouchPrNumber = record.finalReview?.retouchPrNumber;
+    const existingRetouchPrNumber = !isLocalMode ? record.finalReview?.retouchPrNumber : void 0;
     if (existingRetouchPrNumber && autoMerge) {
       const existingPr = await getPrByNumberIfAvailable(
         options.prProvider,
@@ -11674,7 +11884,6 @@ async function runPrdRunFinalReviewCommand(options) {
       mergeBase: mergeBaseResult.mergeBase,
       summary,
       changedPaths: scopeResult.changedPaths,
-      verificationCommands,
       logger: options.logger
     });
     if (!finalizerResult.ok) {
@@ -11706,6 +11915,116 @@ async function runPrdRunFinalReviewCommand(options) {
         offendingPaths: []
       };
     }
+    if (isLocalMode) {
+      let localResult;
+      try {
+        const result = await squashFinalReviewRetouch(
+          prdRef,
+          options.repoRoot,
+          finalizerResult.title,
+          finalizerResult.body
+        );
+        if (!result) {
+          const reason = "Retouch branch missing or empty. Cannot squash-merge.";
+          writePrdRunRecord(options.repoRoot, {
+            ...record,
+            status: "blocked",
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            blockedGate: "final-review",
+            blockedReason: reason,
+            diagnostics: [reason],
+            targetName,
+            finalReview: {
+              status: "blocked",
+              targetName,
+              prdBranch,
+              mergeBase: mergeBaseResult.mergeBase,
+              verdict: "pass_with_retouch",
+              diagnostics: [reason],
+              reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            offendingPaths: []
+          });
+          return {
+            prdRef,
+            status: "blocked",
+            blockedGate: "final-review",
+            blockedReason: reason,
+            diagnostics: [reason],
+            offendingPaths: []
+          };
+        }
+        localResult = result;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        writePrdRunRecord(options.repoRoot, {
+          ...record,
+          status: "blocked",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          blockedGate: "final-review",
+          blockedReason: `Local retouch squash-merge failed: ${msg}`,
+          diagnostics: [msg],
+          targetName,
+          finalReview: {
+            status: "blocked",
+            targetName,
+            prdBranch,
+            mergeBase: mergeBaseResult.mergeBase,
+            verdict: "pass_with_retouch",
+            diagnostics: [msg],
+            reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          offendingPaths: []
+        });
+        return {
+          prdRef,
+          status: "blocked",
+          blockedGate: "final-review",
+          blockedReason: `Local retouch squash-merge failed: ${msg}`,
+          diagnostics: [msg],
+          offendingPaths: []
+        };
+      }
+      const receipt2 = {
+        status: "final_reviewed",
+        targetName,
+        prdBranch,
+        mergeBase: mergeBaseResult.mergeBase,
+        verdict: "pass_with_retouch",
+        artifactPath: ".pourkit/final-review-artifact.json",
+        diagnostics: [],
+        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        retouchMergeCommit: localResult.mergeCommit,
+        changedPaths: localResult.changedPaths
+      };
+      writePrdRunRecord(options.repoRoot, {
+        ...record,
+        status: "final_reviewed",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        targetName,
+        start: record.start,
+        planning: record.planning,
+        finalReview: receipt2
+      });
+      const blocked = await writeAndVerifyLocalDualReceipt(
+        options.repoRoot,
+        prdRef,
+        record,
+        targetName,
+        prdBranch,
+        mergeBaseResult.mergeBase,
+        "pass_with_retouch",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        isLocalMode
+      );
+      if (blocked) return blocked;
+      return {
+        prdRef,
+        status: "final_reviewed",
+        finalReview: receipt2,
+        diagnostics: []
+      };
+    }
     let retouchPr;
     try {
       retouchPr = await createOrReuseFinalReviewRetouchPr({
@@ -13895,6 +14214,37 @@ function computeFinalReviewMergeBase(repoRoot2, prdRef) {
   }
   return { ok: true, mergeBase, diagnostics: fetchDiagnostics };
 }
+function computeLocalFinalReviewMergeBase(repoRoot2, prdBranch) {
+  const mergeBaseResult = spawnSync3("git", ["merge-base", "dev", prdBranch], {
+    cwd: repoRoot2,
+    encoding: "utf8"
+  });
+  if (mergeBaseResult.status !== 0) {
+    const diagnostics = [];
+    if (mergeBaseResult.stderr?.toString?.()?.trim()) {
+      diagnostics.push(mergeBaseResult.stderr.toString().trim());
+    }
+    if (mergeBaseResult.stdout?.toString?.()?.trim()) {
+      diagnostics.push(mergeBaseResult.stdout.toString().trim());
+    }
+    return {
+      ok: false,
+      gate: "final-review",
+      reason: `Final Review merge-base computation failed for dev and ${prdBranch}.`,
+      diagnostics: diagnostics.length > 0 ? diagnostics : ["git merge-base returned non-zero exit status"]
+    };
+  }
+  const mergeBase = mergeBaseResult.stdout?.toString?.()?.trim();
+  if (!mergeBase) {
+    return {
+      ok: false,
+      gate: "final-review",
+      reason: `Final Review merge-base returned empty result for dev and ${prdBranch}.`,
+      diagnostics: [`merge-base stdout was empty for dev..${prdBranch}`]
+    };
+  }
+  return { ok: true, mergeBase, diagnostics: [] };
+}
 function validateReconciliationArtifact2(artifact, context) {
   const errors = [];
   if (!artifact.prdRef) {
@@ -14339,201 +14689,47 @@ async function runPrdRunLaunchCommand(options) {
   let finalReviewResult;
   if (!skipped.includes("final-review")) {
     attempted.push("final-review");
-    const localStorePath2 = join21(
-      options.repoRoot,
-      ".pourkit",
-      "local-prd-runs",
-      prdRef
-    );
-    if (existsSync17(localStorePath2)) {
-      const prdRecord = readPrdRun(options.repoRoot, prdRef);
-      if (prdRecord.record && prdRecord.record.status !== "drained" && !canRetryFinalReviewBlock(prdRecord.record)) {
-        const reason = `Final Review blocked: Queue drain not completed. Status is "${prdRecord.record.status}". Finish all child Issues before Final Review.`;
-        writePrdRunRecord(options.repoRoot, {
-          prdRef,
-          status: "blocked",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          blockedGate: "final-review",
-          blockedReason: reason,
-          diagnostics: [
-            `Current status: ${prdRecord.record.status}. Queue drain receipt is missing. Run child Issues through queue-run before Final Review.`
-          ],
-          targetName: options.targetName,
-          offendingPaths: []
-        });
-        return {
-          prdRef,
-          status: "blocked",
-          attempted,
-          skipped: [
-            ...skipped.includes("prepare") ? ["prepare"] : [],
-            ...skipped.includes("start") ? ["queue"] : [],
-            "reconcile"
-          ],
-          resumed,
-          diagnostics: [
-            `Current status: ${prdRecord.record.status}. Queue drain receipt is missing. Run child Issues through queue-run before Final Review.`
-          ],
-          blockedGate: "final-review",
-          blockedReason: reason,
-          offendingPaths: [],
-          prepare: prepareResult,
-          start: startResult
-        };
-      }
-      const targetConfig = options.config?.targets?.find(
-        (t) => t.name === options.targetName
+    if (existingRecord.record?.mode === "local") {
+      const runnableIssues = await getRunnableLocalIssues(
+        prdRef,
+        options.repoRoot
       );
-      const verificationCommands = targetConfig?.strategy?.verify?.commands ?? [];
-      const localResult = await runLocalFinalReview(prdRef, {
-        repoRoot: options.repoRoot,
-        verificationCommands
-      });
-      if (!localResult.ok) {
-        const reason = localResult.message ?? "Local Final Review blocked.";
-        writePrdRunRecord(options.repoRoot, {
-          prdRef,
-          status: "blocked",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          blockedGate: "final-review",
-          blockedReason: reason,
-          diagnostics: [reason],
-          targetName: options.targetName,
-          offendingPaths: []
-        });
-        return {
-          prdRef,
-          status: "blocked",
-          attempted,
-          skipped: [
-            ...skipped.includes("prepare") ? ["prepare"] : [],
-            ...skipped.includes("start") ? ["queue"] : [],
-            "reconcile"
-          ],
-          resumed,
-          diagnostics: [reason],
-          blockedGate: "final-review",
-          blockedReason: reason,
-          offendingPaths: [],
-          prepare: prepareResult,
-          start: startResult
-        };
-      }
-      if (localResult.verdict === "blocked" || localResult.verdict === "needs_human_review") {
-        const reason = localResult.message ?? `Local Final Review verdict: ${localResult.verdict}`;
-        writePrdRunRecord(options.repoRoot, {
-          prdRef,
-          status: "blocked",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          blockedGate: "final-review",
-          blockedReason: reason,
-          diagnostics: [reason],
-          targetName: options.targetName,
-          offendingPaths: []
-        });
+      if (runnableIssues.length > 0) {
+        const reason = `Config-local Final Review blocked: Queue not drained (${runnableIssues.length} runnable Issues remain).`;
         return {
           prdRef,
           status: "blocked",
           attempted,
-          skipped: [
-            ...skipped.includes("prepare") ? ["prepare"] : [],
-            ...skipped.includes("start") ? ["queue"] : [],
-            "reconcile"
-          ],
+          skipped: ["start", "queue", "reconcile"],
           resumed,
           diagnostics: [reason],
           blockedGate: "final-review",
           blockedReason: reason,
           offendingPaths: [],
           prepare: prepareResult,
-          start: startResult
-        };
-      }
-      let retouchMergeCommit;
-      let changedPaths;
-      if (localResult.verdict === "pass_with_retouch") {
-        try {
-          const evidence = await squashFinalReviewRetouch(
-            prdRef,
-            options.repoRoot
-          );
-          if (evidence) {
-            retouchMergeCommit = evidence.mergeCommit;
-            changedPaths = evidence.changedPaths;
-          }
-        } catch (error) {
-          const reason = error instanceof Error ? error.message : String(error);
-          writePrdRunRecord(options.repoRoot, {
+          start: startResult,
+          finalReview: {
             prdRef,
             status: "blocked",
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
             blockedGate: "final-review",
             blockedReason: reason,
             diagnostics: [reason],
-            targetName: options.targetName,
             offendingPaths: []
-          });
-          return {
-            prdRef,
-            status: "blocked",
-            attempted,
-            skipped: [
-              ...skipped.includes("prepare") ? ["prepare"] : [],
-              ...skipped.includes("start") ? ["queue"] : [],
-              "reconcile"
-            ],
-            resumed,
-            diagnostics: [reason],
-            blockedGate: "final-review",
-            blockedReason: reason,
-            offendingPaths: [],
-            prepare: prepareResult,
-            start: startResult
-          };
-        }
+          }
+        };
       }
-      const receipt = {
-        status: "final_reviewed",
-        targetName: options.targetName,
-        prdBranch: `local/${prdRef}`,
-        mergeBase: localResult.receipt?.mergeBase,
-        diagnostics: [],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        verdict: localResult.verdict ?? "pass_no_changes",
-        retouchMergeCommit,
-        changedPaths
-      };
-      const existingRecord2 = readPrdRun(options.repoRoot, prdRef);
-      writePrdRunRecord(options.repoRoot, {
-        prdRef,
-        status: "final_reviewed",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        targetName: options.targetName,
-        manifestPath: existingRecord2.record?.manifestPath,
-        planning: existingRecord2.record?.planning,
-        start: existingRecord2.record?.start,
-        finalReview: receipt
-      });
-      finalReviewResult = {
-        prdRef,
-        status: "final_reviewed",
-        finalReview: receipt,
-        diagnostics: localResult.message ? [localResult.message] : []
-      };
-      diagnostics.push(...localResult.message ? [localResult.message] : []);
-    } else {
-      finalReviewResult = await runPrdRunFinalReviewCommand({
-        repoRoot: options.repoRoot,
-        prdRef,
-        targetName: options.targetName,
-        autoMerge: options.autoMerge,
-        issueProvider: options.issueProvider,
-        prProvider: options.prProvider,
-        executionProvider: options.executionProvider,
-        config: options.config,
-        logger: options.logger
-      });
     }
+    finalReviewResult = await runPrdRunFinalReviewCommand({
+      repoRoot: options.repoRoot,
+      prdRef,
+      targetName: options.targetName,
+      autoMerge: options.autoMerge,
+      issueProvider: options.issueProvider,
+      prProvider: options.prProvider,
+      executionProvider: options.executionProvider,
+      config: options.config,
+      logger: options.logger
+    });
     const skippedAfterFr = [
       ...skipped.includes("prepare") ? ["prepare"] : [],
       ...skipped.includes("start") ? ["queue"] : [],
@@ -14603,6 +14799,28 @@ async function runPrdRunLaunchCommand(options) {
           finalReview: finalReviewResult
         };
       }
+      if (prdRecord.record?.mode === "local") {
+        const dualCheck = await verifyLocalDualFinalReviewReceipts(
+          options.repoRoot,
+          prdRef
+        );
+        if (!dualCheck.ok) {
+          return {
+            prdRef,
+            status: "blocked",
+            attempted,
+            skipped: [...skipped],
+            resumed,
+            diagnostics: dualCheck.diagnostics,
+            blockedGate: "reconciliation",
+            blockedReason: dualCheck.reason,
+            offendingPaths: [],
+            prepare: prepareResult,
+            start: startResult,
+            finalReview: finalReviewResult
+          };
+        }
+      }
       const localResult = await runLocalReconciliation(prdRef, {
         repoRoot: options.repoRoot
       });
@@ -21169,11 +21387,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260608221925")) {
-    return "0.0.0-next-20260608221925";
+  if (isPackageVersion("0.0.0-next-20260609130908")) {
+    return "0.0.0-next-20260609130908";
   }
-  if (isReleaseVersion("0.0.0-next-20260608221925")) {
-    return "0.0.0-next-20260608221925";
+  if (isReleaseVersion("0.0.0-next-20260609130908")) {
+    return "0.0.0-next-20260609130908";
   }
   try {
     const root = repoRoot();