@pourkit/cli 0.0.0-next-20260613012953 → 0.0.0-next-20260613201753

package/dist/cli.js

@@ -58,20 +58,20 @@ function createLogger(name, filePath) {
       );
     },
     async close() {
-      await new Promise((resolve2) => {
+      await new Promise((resolve3) => {
         if (!fileStream) {
-          resolve2();
+          resolve3();
           return;
         }
         const timer = setTimeout(() => {
           if (!fileStream.destroyed) {
             fileStream.destroy();
           }
-          resolve2();
+          resolve3();
         }, 2e3);
         fileStream.end(() => {
           clearTimeout(timer);
-          resolve2();
+          resolve3();
         });
       });
     }
@@ -265,7 +265,7 @@ async function execJson(command, args, options = {}) {
   return JSON.parse(result.stdout);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function execCaptureWithRetry(command, args, options = {}) {
   const retries = options.retries ?? 3;
@@ -415,6 +415,9 @@ var ReviewRefactorLoopStrategySchema = z.object({
       })
     )
   }).strict().optional(),
+  issueFinalReview: StageAgentConfigSchema.extend({
+    maxAttempts: z.number().int().positive()
+  }),
   finalize: z.object({
     prDescriptionAgent: StageAgentConfigSchema,
     maxAttempts: z.number().int().positive()
@@ -708,6 +711,7 @@ function parseConfig(raw) {
           passWithNotesRefactorAttempts: t.strategy.review.passWithNotesRefactorAttempts
         },
         ...t.strategy.verify ? { verify: { commands: verifyCommands } } : {},
+        issueFinalReview: t.strategy.issueFinalReview,
         finalize: {
           prDescriptionAgent: t.strategy.finalize.prDescriptionAgent,
           maxAttempts: t.strategy.finalize.maxAttempts
@@ -786,13 +790,13 @@ function resolvePrdRunMode(target, opts) {
   return { mode: "github", source: "default", targetName: target.name };
 }
 async function loadRepoConfig(repoRoot2, configFileName = "pourkit.config.ts") {
-  const { existsSync: existsSync17 } = await import("fs");
+  const { existsSync: existsSync19 } = await import("fs");
   const { mkdir: mkdir6, writeFile: writeFile4, rm } = await import("fs/promises");
   const { join: pjoin, basename } = await import("path");
   const { pathToFileURL: pathToFileURL2 } = await import("url");
   const { build } = await import("esbuild");
   const configPath = pjoin(repoRoot2, configFileName);
-  if (!existsSync17(configPath)) {
+  if (!existsSync19(configPath)) {
     throw new Error(
       `No config file found at ${configPath}. Create a ${configFileName} that exports a default PourkitConfig.`
     );
@@ -912,6 +916,7 @@ function updateWorktreeRunState(worktreePath, update) {
       ...existing.review,
       ...update.review ?? {}
     },
+    issueFinalReview: update.issueFinalReview !== void 0 ? { ...existing.issueFinalReview, ...update.issueFinalReview } : existing.issueFinalReview,
     finalizer: update.finalizer !== void 0 ? { ...existing.finalizer, ...update.finalizer } : existing.finalizer,
     finalCommit: update.finalCommit !== void 0 ? { ...existing.finalCommit, ...update.finalCommit } : existing.finalCommit,
     pr: update.pr !== void 0 ? { ...existing.pr, ...update.pr } : existing.pr
@@ -1041,8 +1046,8 @@ async function cleanupRepository(options) {
 // commands/artifact-validation.ts
 import { createHash } from "crypto";
 import { execSync } from "child_process";
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import { isAbsolute, join as join6, resolve } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
+import { isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "path";
 
 // pr/review-verdict.ts
 var ReviewVerdictProtocolError = class extends Error {
@@ -1075,13 +1080,13 @@ function parseReviewVerdict(output) {
 
 // commands/review.ts
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync4,
-  readdirSync,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // execution/agent-output-retry.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, rmSync } from "fs";
@@ -1156,6 +1161,10 @@ function prepareArtifactPath(artifactPath) {
   rmSync(artifactPath, { recursive: true, force: true });
 }
 
+// shared/run-context.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { isAbsolute, join as join5, relative, resolve } from "path";
+
 // commands/run-verification.ts
 init_common();
 function buildRunVerificationCommand(target) {
@@ -1231,6 +1240,7 @@ async function runVerificationCommands(options) {
 var RUN_CONTEXT_PATH_IN_WORKTREE = ".pourkit/.tmp/run-context.md";
 var ALL_RUN_CONTEXT_SECTIONS = [
   "issue",
+  "prd",
   "comments",
   "branch",
   "verification-commands",
@@ -1240,6 +1250,7 @@ var ALL_RUN_CONTEXT_SECTIONS = [
 var STAGE_SECTIONS = {
   builder: [
     "issue",
+    "prd",
     "comments",
     "branch",
     "verification-commands",
@@ -1247,6 +1258,7 @@ var STAGE_SECTIONS = {
   ],
   reviewer: [
     "issue",
+    "prd",
     "comments",
     "branch",
     "verification-commands",
@@ -1255,6 +1267,7 @@ var STAGE_SECTIONS = {
   ],
   refactor: [
     "issue",
+    "prd",
     "comments",
     "branch",
     "verification-commands",
@@ -1283,6 +1296,15 @@ var STAGE_SECTIONS = {
     "verification-commands",
     "artifacts"
   ],
+  issueFinalReview: [
+    "issue",
+    "prd",
+    "comments",
+    "branch",
+    "verification-commands",
+    "review-criteria",
+    "artifacts"
+  ],
   prdFinalReview: [
     "issue",
     "comments",
@@ -1307,8 +1329,10 @@ function buildRunContextArtifact(options) {
 function buildRunContextMarkdown(options) {
   const {
     issue,
+    parentPrdIssue,
     target,
     branchName,
+    repoRoot: repoRoot2,
     reviewerCriteria = [],
     sections = ALL_RUN_CONTEXT_SECTIONS
   } = options;
@@ -1326,6 +1350,9 @@ function buildRunContextMarkdown(options) {
       ""
     );
   }
+  if (sections.includes("prd")) {
+    parts.push(...renderPrdContext(issue, parentPrdIssue, repoRoot2));
+  }
   if (sections.includes("comments")) {
     parts.push("## Comments", "");
     if (issue.comments.length === 0) {
@@ -1370,12 +1397,129 @@ function buildRunContextMarkdown(options) {
   return parts.join("\n");
 }
 function renderCommandList(target, heading) {
-  return [
+  const commands = getVerificationCommands(target);
+  const parts = [
     `## ${heading}`,
     "",
     `Run this command from the repository root: \`${buildRunVerificationCommand(target)}\``,
     ""
   ];
+  if (commands.length > 0) {
+    parts.push(
+      "Configured commands executed by the wrapper:",
+      "",
+      ...commands.map(
+        (command) => `- ${command.label}: \`${command.command}\``
+      ),
+      ""
+    );
+  }
+  return parts;
+}
+function renderPrdContext(issue, parentPrdIssue, repoRoot2) {
+  const parent = extractIssueSection(issue.body, "Parent");
+  const documents = extractIssueSection(issue.body, "Plan Documents");
+  const parentRef = parent?.match(/\bPRD-\d+\b/i)?.[0]?.toUpperCase();
+  const parentPrdPath = parentRef && repoRoot2 ? findParentPrdPath(repoRoot2, parentRef) : null;
+  const documentPaths = repoRoot2 ? extractRepoPaths(documents) : [];
+  if (!parent && !documents) {
+    return [];
+  }
+  const parts = ["## PRD", ""];
+  if (parent) {
+    parts.push(parent, "");
+  } else {
+    parts.push("(not declared in issue body)", "");
+  }
+  if (parentPrdPath && repoRoot2) {
+    parts.push(
+      `### Parent PRD Content: \`${relative(repoRoot2, parentPrdPath)}\``,
+      "",
+      "```markdown",
+      readFileSync3(parentPrdPath, "utf-8").trimEnd(),
+      "```",
+      ""
+    );
+  } else if (parentPrdIssue) {
+    parts.push(
+      `### Parent PRD Content: #${parentPrdIssue.number} ${parentPrdIssue.title}`,
+      "",
+      "```markdown",
+      parentPrdIssue.body.trimEnd() || "(empty PRD body)",
+      "```",
+      ""
+    );
+  }
+  parts.push("## PRD Documents", "");
+  if (documents) {
+    parts.push(documents, "");
+  } else {
+    parts.push("(not declared in issue body)", "");
+  }
+  for (const documentPath of documentPaths) {
+    const absolutePath = resolveRepoPath(repoRoot2, documentPath);
+    if (!absolutePath || !existsSync3(absolutePath)) continue;
+    parts.push(
+      `### Document Content: \`${documentPath}\``,
+      "",
+      "```markdown",
+      readFileSync3(absolutePath, "utf-8").trimEnd(),
+      "```",
+      ""
+    );
+  }
+  return parts;
+}
+function extractIssueSection(body, heading) {
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const section = body.match(
+    new RegExp(`^## ${escapedHeading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`, "im")
+  )?.[1];
+  const trimmed = section?.trim();
+  return trimmed ? trimmed : null;
+}
+function extractRepoPaths(section) {
+  if (!section) return [];
+  const paths = /* @__PURE__ */ new Set();
+  for (const match of section.matchAll(/`([^`]+)`/g)) {
+    const value = match[1]?.trim();
+    if (value) paths.add(value);
+  }
+  return Array.from(paths);
+}
+function resolveRepoPath(repoRoot2, path9) {
+  if (isAbsolute(path9) || path9.includes("\0")) return null;
+  const resolved = resolve(repoRoot2, path9);
+  const repoRelative2 = relative(repoRoot2, resolved);
+  if (repoRelative2.startsWith("..") || isAbsolute(repoRelative2)) return null;
+  return resolved;
+}
+function findParentPrdPath(repoRoot2, parentRef) {
+  const directPath = join5(
+    repoRoot2,
+    ".pourkit",
+    "architecture",
+    parentRef,
+    "PRD.md"
+  );
+  if (existsSync3(directPath)) return directPath;
+  const architectureRoot = join5(repoRoot2, ".pourkit", "architecture");
+  if (!existsSync3(architectureRoot)) return null;
+  return findPrdMirror(architectureRoot, parentRef);
+}
+function findPrdMirror(directory, parentRef) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = join5(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(parentRef)) {
+        const prdPath = join5(entryPath, "PRD.md");
+        if (existsSync3(prdPath)) return prdPath;
+      }
+      const nested = findPrdMirror(entryPath, parentRef);
+      if (nested) return nested;
+    }
+  }
+  return null;
 }
 function renderCriteria(criteria) {
   if (criteria.length === 0) {
@@ -1401,7 +1545,7 @@ function appendProtectedWorkGuidance(promptBody) {
 
 // shared/effect-services.ts
 import { Context, Effect, Layer } from "effect";
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
 var GitExecutionError = class extends Error {
   _tag = "GitExecutionError";
   message;
@@ -1417,7 +1561,7 @@ var FileSystemDefault = Layer.succeed(
   FileSystem,
   FileSystem.of({
     readFile: (path9) => Effect.try({
-      try: () => readFileSync3(path9, "utf-8"),
+      try: () => readFileSync4(path9, "utf-8"),
       catch: (error) => new Error(
         `Failed to read file ${path9}: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -1429,7 +1573,7 @@ var FileSystemDefault = Layer.succeed(
       )
     }),
     exists: (path9) => Effect.try({
-      try: () => existsSync3(path9),
+      try: () => existsSync4(path9),
       catch: (error) => new Error(
         `Failed to check existence of ${path9}: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -1813,12 +1957,12 @@ function extractLatestFindingIds(reviewOutput, iteration) {
   return ids;
 }
 function validateRefactorArtifact(artifactPath, findingIds) {
-  if (!existsSync4(artifactPath)) {
+  if (!existsSync5(artifactPath)) {
     throw new RefactorArtifactValidationError(
       `Refactor artifact missing at ${artifactPath}`
     );
   }
-  const content = readFileSync4(artifactPath, "utf-8");
+  const content = readFileSync5(artifactPath, "utf-8");
   if (!content.trim()) {
     throw new RefactorArtifactValidationError("Refactor artifact is empty");
   }
@@ -1958,6 +2102,7 @@ function runReviewCommandEffect(options) {
     config,
     target,
     issue,
+    parentPrdIssue,
     builderBranch,
     worktreePath,
     repoRoot: repoRoot2,
@@ -1974,13 +2119,13 @@ function runReviewCommandEffect(options) {
       new ReviewerFailure({ message: "No reviewer config found" })
     );
   }
-  const artifactPathInWorktree = join5(
+  const artifactPathInWorktree = join6(
     ".pourkit",
     ".tmp",
     "reviewers",
     `iteration-${iteration ?? 1}.md`
   );
-  const artifactPath = join5(worktreePath, artifactPathInWorktree);
+  const artifactPath = join6(worktreePath, artifactPathInWorktree);
   return Effect2.gen(function* () {
     const exec = yield* ExecutionProvider;
     const fs = yield* FileSystem;
@@ -2041,8 +2186,10 @@ function runReviewCommandEffect(options) {
           artifacts: [
             buildRunContextArtifact({
               issue,
+              parentPrdIssue,
               target,
               branchName: builderBranch,
+              repoRoot: repoRoot2,
               reviewerCriteria: reviewer.criteria,
               sections: STAGE_SECTIONS.reviewer
             })
@@ -2144,7 +2291,7 @@ Before carrying forward old blockers, inspect newer issue comments and the curre
 
 ## Shared Run Context
 
-Read the selected issue requirements, branch context, validation commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}
+Read the selected issue requirements, PRD context, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}
 
 ${hasCriteriaPlaceholder ? "" : `## Review Criteria
 
@@ -2180,12 +2327,12 @@ ${entry.trimEnd()}`).join("\n\n")}
 function renderPriorRefactorArtifactsEffect(worktreePath, currentIteration) {
   return Effect2.gen(function* () {
     const fb = yield* FileSystem;
-    const refactorsDir = join5(worktreePath, ".pourkit", ".tmp", "refactors");
+    const refactorsDir = join6(worktreePath, ".pourkit", ".tmp", "refactors");
     const dirExists = yield* fb.exists(refactorsDir).pipe(Effect2.catchAll(() => Effect2.succeed(false)));
     if (!dirExists) return "";
     const iterationFiles = [];
     for (let i = 0; i < currentIteration; i++) {
-      const filePath = join5(refactorsDir, `iteration-${i}.md`);
+      const filePath = join6(refactorsDir, `iteration-${i}.md`);
       const fileExists = yield* fb.exists(filePath).pipe(Effect2.catchAll(() => Effect2.succeed(false)));
       if (!fileExists) continue;
       const content = yield* fb.readFile(filePath).pipe(Effect2.catchAll(() => Effect2.succeed("")));
@@ -2210,12 +2357,12 @@ ${iterationsBlocks}
 function renderPriorReviewerArtifactsEffect(worktreePath, currentIteration) {
   return Effect2.gen(function* () {
     const fb = yield* FileSystem;
-    const reviewersDir = join5(worktreePath, ".pourkit", ".tmp", "reviewers");
+    const reviewersDir = join6(worktreePath, ".pourkit", ".tmp", "reviewers");
     const dirExists = yield* fb.exists(reviewersDir).pipe(Effect2.catchAll(() => Effect2.succeed(false)));
     if (!dirExists) return "";
     const iterationFiles = [];
     for (let i = 0; i < currentIteration; i++) {
-      const filePath = join5(reviewersDir, `iteration-${i}.md`);
+      const filePath = join6(reviewersDir, `iteration-${i}.md`);
       const fileExists = yield* fb.exists(filePath).pipe(Effect2.catchAll(() => Effect2.succeed(false)));
       if (!fileExists) continue;
       const content = yield* fb.readFile(filePath).pipe(Effect2.catchAll(() => Effect2.succeed("")));
@@ -2256,7 +2403,7 @@ function renderReviewCriteriaEffect(repoRoot2, criteria, fs) {
   return Effect2.gen(function* () {
     const parts = [];
     for (const criterion of criteria) {
-      const snippetPath = join5(
+      const snippetPath = join6(
         repoRoot2,
         ".pourkit",
         "prompts",
@@ -2284,15 +2431,15 @@ function recoverReviewOutputFromString(logContent) {
   return recoveredOutput.length > 0 ? recoveredOutput : null;
 }
 function recoverReviewOutputFromLog(logPath) {
-  if (!existsSync4(logPath)) {
+  if (!existsSync5(logPath)) {
     return null;
   }
-  const logContent = readFileSync4(logPath, "utf-8");
+  const logContent = readFileSync5(logPath, "utf-8");
   return recoverReviewOutputFromString(logContent);
 }
 function readReviewArtifact(artifactPath, logPath) {
-  if (existsSync4(artifactPath)) {
-    const output = readFileSync4(artifactPath, "utf-8");
+  if (existsSync5(artifactPath)) {
+    const output = readFileSync5(artifactPath, "utf-8");
     if (output.trim()) {
       return output;
     }
@@ -2302,7 +2449,7 @@ function readReviewArtifact(artifactPath, logPath) {
     writeFileSync3(artifactPath, recoveredOutput, "utf-8");
     return recoveredOutput;
   }
-  if (!existsSync4(artifactPath)) {
+  if (!existsSync5(artifactPath)) {
     throw new Error(`Reviewer did not produce output at ${artifactPath}`);
   }
   throw new Error(`Reviewer produced empty output at ${artifactPath}`);
@@ -2313,6 +2460,7 @@ function runReviewWithRefactorLoop(options) {
     config,
     target,
     issue,
+    parentPrdIssue,
     builderBranch,
     worktreePath,
     repoRoot: repoRoot2,
@@ -2334,9 +2482,9 @@ function runReviewWithRefactorLoop(options) {
   const passWithNotesRefactorAttempts = strategy.review.passWithNotesRefactorAttempts;
   let resolvedStartingIteration = startingLifetimeIteration;
   {
-    const reviewersDir = join5(worktreePath, ".pourkit", ".tmp", "reviewers");
+    const reviewersDir = join6(worktreePath, ".pourkit", ".tmp", "reviewers");
     try {
-      const files = readdirSync(reviewersDir);
+      const files = readdirSync2(reviewersDir);
       let maxExistingIteration = 0;
       for (const file of files) {
         const match = file.match(/^iteration-(\d+)\.md$/);
@@ -2472,7 +2620,7 @@ function runReviewWithRefactorLoop(options) {
         }
         if (reviewResult.verdict === "NEEDS_REFACTOR" || reviewResult.verdict === "PASS_WITH_NOTES" || reviewResult.verdict === "FAIL") {
           logger.step("info", "Running refactor agent");
-          const refactorArtifactPathInWorktree = join5(
+          const refactorArtifactPathInWorktree = join6(
             ".pourkit",
             ".tmp",
             "refactors",
@@ -2508,8 +2656,10 @@ function runReviewWithRefactorLoop(options) {
                 artifacts: [
                   buildRunContextArtifact({
                     issue,
+                    parentPrdIssue,
                     target,
                     branchName: builderBranch,
+                    repoRoot: repoRoot2,
                     reviewerCriteria: reviewer.criteria,
                     sections: STAGE_SECTIONS.refactor
                   })
@@ -2570,7 +2720,7 @@ function runReviewWithRefactorLoop(options) {
             reviewResult.output,
             lifetimeIteration
           );
-          const refactorArtifactPath = join5(
+          const refactorArtifactPath = join6(
             worktreePath,
             refactorArtifactPathInWorktree
           );
@@ -2661,9 +2811,9 @@ function runReviewWithRefactorLoop(options) {
 }
 function persistIterationArtifactEffect(worktreePath, output, iteration, fs) {
   return Effect2.gen(function* () {
-    const dir = join5(worktreePath, ".pourkit", ".tmp", "reviewers");
+    const dir = join6(worktreePath, ".pourkit", ".tmp", "reviewers");
     yield* fs.mkdir(dir).pipe(Effect2.catchAll(() => Effect2.void));
-    yield* fs.writeFile(join5(dir, `iteration-${iteration}.md`), output).pipe(Effect2.catchAll(() => Effect2.void));
+    yield* fs.writeFile(join6(dir, `iteration-${iteration}.md`), output).pipe(Effect2.catchAll(() => Effect2.void));
   });
 }
 function buildRefactorPromptEffect(repoRoot2, promptTemplate, latestReview, artifactPathInWorktree, iteration, fs) {
@@ -2680,7 +2830,7 @@ function buildRefactorPromptEffect(repoRoot2, promptTemplate, latestReview, arti
 
 ## Shared Run Context
 
-Read the selected issue requirements, branch context, validation commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}
+Read the selected issue requirements, PRD context, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}
 
 ## Latest Review
 
@@ -2939,9 +3089,9 @@ function parseConflictResolutionArtifact(output) {
 }
 
 // prd-run/final-review-validation.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 function parseFinalReviewArtifact(artifactPath) {
-  if (!existsSync5(artifactPath)) {
+  if (!existsSync6(artifactPath)) {
     return {
       ok: false,
       reason: "Final Review artifact not found.",
@@ -2950,7 +3100,7 @@ function parseFinalReviewArtifact(artifactPath) {
   }
   let content;
   try {
-    content = readFileSync5(artifactPath, "utf-8");
+    content = readFileSync6(artifactPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -3146,14 +3296,14 @@ function valid(options, diagnostics = []) {
   };
 }
 function readArtifact(options) {
-  if (!existsSync6(options.artifactPath)) {
+  if (!existsSync7(options.artifactPath)) {
     return {
       ok: false,
       result: invalid(options, `Artifact missing at ${options.artifactPath}`)
     };
   }
   try {
-    const content = readFileSync6(options.artifactPath, "utf-8");
+    const content = readFileSync7(options.artifactPath, "utf-8");
     if (!content.trim()) {
       return { ok: false, result: invalid(options, "Artifact is empty") };
     }
@@ -3167,6 +3317,144 @@ function readArtifact(options) {
     };
   }
 }
+function validateIssueFinalReviewArtifact(parsed, options) {
+  const diagnostics = [];
+  if (parsed.kind !== "issue-final-review") {
+    return {
+      ok: false,
+      reason: `Artifact kind must be "issue-final-review", got ${JSON.stringify(parsed.kind)}`,
+      diagnostics
+    };
+  }
+  diagnostics.push("kind: issue-final-review");
+  if (parsed.issueNumber !== options.issueNumber) {
+    return {
+      ok: false,
+      reason: `Artifact issueNumber ${JSON.stringify(parsed.issueNumber)} does not match expected ${options.issueNumber}`,
+      diagnostics
+    };
+  }
+  diagnostics.push(`issueNumber: ${options.issueNumber}`);
+  if (parsed.branchName !== options.branchName) {
+    return {
+      ok: false,
+      reason: `Artifact branchName ${JSON.stringify(parsed.branchName)} does not match expected ${JSON.stringify(options.branchName)}`,
+      diagnostics
+    };
+  }
+  diagnostics.push(`branchName: ${options.branchName}`);
+  const allowedVerdicts = ["pass", "needs_human_review"];
+  if (!allowedVerdicts.includes(parsed.verdict)) {
+    return {
+      ok: false,
+      reason: `Verdict must be "pass" or "needs_human_review", got ${JSON.stringify(parsed.verdict)}`,
+      diagnostics: [
+        ...diagnostics,
+        `verdict: ${JSON.stringify(parsed.verdict)}`
+      ]
+    };
+  }
+  diagnostics.push(`verdict: ${parsed.verdict}`);
+  if (typeof parsed.summary !== "string" || parsed.summary.trim() === "") {
+    return {
+      ok: false,
+      reason: "Summary must be a non-empty string",
+      diagnostics
+    };
+  }
+  diagnostics.push("summary: present");
+  if (!Array.isArray(parsed.changedPaths) || !parsed.changedPaths.every((p) => typeof p === "string")) {
+    return {
+      ok: false,
+      reason: "changedPaths must be an array of strings",
+      diagnostics
+    };
+  }
+  for (const p of parsed.changedPaths) {
+    const normalized = p.replace(/\\/g, "/");
+    const segments = normalized.split("/");
+    if (normalized.trim() === "" || normalized === "." || normalized === ".." || isAbsolute2(p) || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+      return {
+        ok: false,
+        reason: `changedPaths must not contain absolute paths or path traversal: ${p}`,
+        diagnostics
+      };
+    }
+  }
+  diagnostics.push(
+    `changedPaths: ${parsed.changedPaths.length} paths`
+  );
+  if (typeof parsed.selfRetouched !== "boolean") {
+    return {
+      ok: false,
+      reason: "selfRetouched must be a boolean",
+      diagnostics
+    };
+  }
+  diagnostics.push(`selfRetouched: ${parsed.selfRetouched}`);
+  const verification = parsed.verification;
+  if (!verification || typeof verification !== "object") {
+    return {
+      ok: false,
+      reason: "verification must be an object",
+      diagnostics
+    };
+  }
+  if (typeof verification.required !== "boolean") {
+    return {
+      ok: false,
+      reason: "verification.required must be a boolean",
+      diagnostics
+    };
+  }
+  if (typeof verification.passed !== "boolean") {
+    return {
+      ok: false,
+      reason: "verification.passed must be a boolean",
+      diagnostics
+    };
+  }
+  if (!Array.isArray(verification.commands) || !verification.commands.every((c) => typeof c === "string")) {
+    return {
+      ok: false,
+      reason: "verification.commands must be an array of strings",
+      diagnostics
+    };
+  }
+  if (typeof verification.summary !== "string") {
+    return {
+      ok: false,
+      reason: "verification.summary must be a string",
+      diagnostics
+    };
+  }
+  diagnostics.push("verification: present");
+  if (parsed.selfRetouched === true && parsed.verdict === "pass") {
+    if (verification.required !== true || verification.passed !== true) {
+      return {
+        ok: false,
+        reason: "Self-retouched pass requires verification.required === true and verification.passed === true",
+        diagnostics: [
+          ...diagnostics,
+          `verification.required: ${verification.required}`,
+          `verification.passed: ${verification.passed}`
+        ]
+      };
+    }
+    diagnostics.push("self-retouched verification: valid");
+  }
+  if (parsed.verdict === "needs_human_review") {
+    if (typeof parsed.needsHumanReason !== "string" || parsed.needsHumanReason.trim() === "") {
+      return {
+        ok: false,
+        reason: "needs_human_review verdict requires non-empty needsHumanReason",
+        diagnostics
+      };
+    }
+    diagnostics.push("needsHumanReason: present");
+  }
+  return { ok: true, verdict: parsed.verdict };
+}
 function validateAgentArtifact(options) {
   const artifact = readArtifact(options);
   if (!artifact.ok) return artifact.result;
@@ -3186,7 +3474,7 @@ function validateAgentArtifact(options) {
       case "refactor": {
         let findingIds = options.findingIds ?? [];
         if (findingIds.length === 0 && options.latestReviewArtifactPath) {
-          const latestReview = readFileSync6(
+          const latestReview = readFileSync7(
             options.latestReviewArtifactPath,
             "utf-8"
           );
@@ -3209,10 +3497,10 @@ function validateAgentArtifact(options) {
         if (options.checkConflictMarkers !== false && parsed.status === "resolved") {
           const base = options.worktreePath ?? process.cwd();
           const filesWithMarkers = parsed.files.filter((file) => {
-            const filePath = resolve(base, file);
+            const filePath = resolve2(base, file);
             try {
               return CONFLICT_MARKER_PATTERN.test(
-                readFileSync6(filePath, "utf-8")
+                readFileSync7(filePath, "utf-8")
               );
             } catch {
               return false;
@@ -3228,6 +3516,9 @@ function validateAgentArtifact(options) {
         }
         return valid(options, [`status: ${parsed.status}`]);
       }
+      // QUARANTINED: Retained for Issue Final Review artifact validation via
+      // `runPrdRunValidateFinalReviewCommand`. Remove when Issue Final Review
+      // is migrated to its own dedicated validator kind.
       case "final-review": {
         if (!options.prdRef || !options.checkoutBase || !options.reviewBase) {
           return invalid(
@@ -3248,6 +3539,26 @@ function validateAgentArtifact(options) {
         }
         return valid(options, [`verdict: ${result.artifact.verdict}`]);
       }
+      case "issue-final-review": {
+        if (options.issueNumber === void 0 || !options.branchName) {
+          return invalid(
+            options,
+            "Issue Final Review artifact validation requires --issue-number and --branch-name."
+          );
+        }
+        const parsed = JSON.parse(artifact.content);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return invalid(
+            options,
+            `Artifact must be a JSON object, got ${Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed}`
+          );
+        }
+        const result = validateIssueFinalReviewArtifact(parsed, options);
+        if (!result.ok) {
+          return invalid(options, result.reason, result.diagnostics);
+        }
+        return valid(options, [`verdict: ${result.verdict}`]);
+      }
       case "failure-resolution": {
         const parsed = parseRecoveryArtifact(
           artifact.content,
@@ -3294,8 +3605,8 @@ function validateAgentArtifact(options) {
   }
 }
 function runValidateArtifactCommand(options) {
-  const artifactPath = resolve(options.repoRoot, options.artifactPath);
-  const latestReviewArtifactPath = options.latestReviewArtifactPath ? resolve(options.repoRoot, options.latestReviewArtifactPath) : void 0;
+  const artifactPath = resolve2(options.repoRoot, options.artifactPath);
+  const latestReviewArtifactPath = options.latestReviewArtifactPath ? resolve2(options.repoRoot, options.latestReviewArtifactPath) : void 0;
   return validateAgentArtifact({
     ...options,
     artifactPath,
@@ -3304,9 +3615,9 @@ function runValidateArtifactCommand(options) {
   });
 }
 function runLocalValidateArtifactCommand(options) {
-  const resolvedPath = resolve(options.repoRoot, options.artifactPath);
+  const resolvedPath = resolve2(options.repoRoot, options.artifactPath);
   const resolvedExtra = (options.extraArgs ?? []).map(
-    (p) => isAbsolute(p) ? p : resolve(options.repoRoot, p)
+    (p) => isAbsolute2(p) ? p : resolve2(options.repoRoot, p)
   );
   let localResult;
   switch (options.kind) {
@@ -3353,7 +3664,7 @@ function runLocalValidateArtifactCommand(options) {
 }
 function readLocalArtifact(path9, failureCode) {
   try {
-    const raw = readFileSync6(path9, "utf-8");
+    const raw = readFileSync7(path9, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return {
@@ -4052,8 +4363,8 @@ function validateLocalTriage(prdPath, issuePaths) {
 }
 
 // commands/issue-run.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import { isAbsolute as isAbsolute3, join as join15 } from "path";
 
 // pr/templates.ts
 init_common();
@@ -4188,20 +4499,20 @@ function runEffectAndMapExit(program) {
 }
 
 // shared/attempt-log.ts
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
 var ATTEMPT_LOG_PATH = ".pourkit/attempt-log.jsonl";
 function writeAttemptLog(worktreePath, entry) {
-  const logPath = join7(worktreePath, ATTEMPT_LOG_PATH);
+  const logPath = join8(worktreePath, ATTEMPT_LOG_PATH);
   mkdirSync6(dirname3(logPath), { recursive: true });
   appendFileSync(logPath, JSON.stringify(entry) + "\n", "utf-8");
 }
 function readAttemptLog(worktreePath) {
-  const logPath = join7(worktreePath, ATTEMPT_LOG_PATH);
-  if (!existsSync7(logPath)) {
+  const logPath = join8(worktreePath, ATTEMPT_LOG_PATH);
+  if (!existsSync8(logPath)) {
     return [];
   }
-  const raw = readFileSync7(logPath, "utf-8");
+  const raw = readFileSync8(logPath, "utf-8");
   const lines = raw.split("\n").filter((l) => l.length > 0);
   const entries = [];
   for (const line of lines) {
@@ -4320,15 +4631,15 @@ async function runBaseRefreshAttempt(options) {
 }
 
 // commands/conflict-resolution.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join9 } from "path";
 init_common();
 var CONFLICT_MARKER_PATTERN2 = /<<<<<<<|=======|>>>>>>>/m;
 async function hasUnresolvedConflictMarkers(worktreePath, files) {
   for (const file of files) {
-    const filePath = join8(worktreePath, file);
+    const filePath = join9(worktreePath, file);
     try {
-      const content = readFileSync8(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       if (CONFLICT_MARKER_PATTERN2.test(content)) {
         return true;
       }
@@ -4608,7 +4919,7 @@ async function canReachMcp(url) {
       return true;
     } catch {
       if (attempt < 9) {
-        await new Promise((resolve2) => setTimeout(resolve2, 100));
+        await new Promise((resolve3) => setTimeout(resolve3, 100));
       }
     }
   }
@@ -4659,8 +4970,8 @@ async function prepareSerenaForTarget(options) {
 }
 
 // failure-resolution/failure-resolution-agent.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { join as join10 } from "path";
 
 // failure-resolution/recovery-policy.ts
 function isSecuritySensitiveFailure(failure) {
@@ -4736,7 +5047,7 @@ async function runFailureResolutionAgent(options) {
   } = options;
   const frConfig = target.strategy.failureResolution;
   const artifactPath = packet.artifactTarget;
-  const fullArtifactPath = join9(worktreePath, artifactPath);
+  const fullArtifactPath = join10(worktreePath, artifactPath);
   const fingerprint = computeFailureFingerprint(packet.stageName, failure._tag);
   const prompt = [
     `# Failure Resolution: ${packet.failureType}`,
@@ -4813,7 +5124,7 @@ async function runFailureResolutionAgent(options) {
   }
   let artifact;
   try {
-    const md = readFileSync9(fullArtifactPath, "utf-8");
+    const md = readFileSync10(fullArtifactPath, "utf-8");
     const validation2 = validateAgentArtifact({
       kind: "failure-resolution",
       artifactPath: fullArtifactPath,
@@ -4906,12 +5217,12 @@ async function writeRecoveryAttempt(worktreePath, outcome, fingerprint, summary,
 }
 
 // commands/pr-description-agent.ts
-import { join as join11 } from "path";
-import { readFileSync as readFileSync10 } from "fs";
+import { join as join12 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
 
 // pr/pr-description-context.ts
 init_common();
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { readFile } from "fs/promises";
 import { Effect as Effect5 } from "effect";
 function collectFinalizerContextEffect(options) {
@@ -4976,7 +5287,7 @@ function remoteTargetBase(targetBase) {
   return targetBase.includes("/") ? targetBase : `origin/${targetBase}`;
 }
 function buildFinalizerPrompt(context, promptTemplate) {
-  const artifactPathInWorktree = join10(
+  const artifactPathInWorktree = join11(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -5046,13 +5357,13 @@ function bridgeExecutionProvider2(ep) {
 }
 function runFinalizerAgent(options) {
   const { executionProvider } = options;
-  const artifactPathInWorktree = join11(
+  const artifactPathInWorktree = join12(
     ".pourkit",
     ".tmp",
     "finalizer",
     "agent-output.md"
   );
-  const artifactPath = join11(options.worktreePath, artifactPathInWorktree);
+  const artifactPath = join12(options.worktreePath, artifactPathInWorktree);
   const program = Effect6.gen(function* () {
     const fs = yield* FileSystem;
     const context = yield* collectFinalizerContextEffect({
@@ -5101,7 +5412,7 @@ function runFinalizerAgent(options) {
       ],
       logger: options.logger
     });
-    const output = readFileSync10(artifactPath, "utf-8");
+    const output = readFileSync11(artifactPath, "utf-8");
     yield* persistGeneratedArtifactEffect(options.worktreePath, output, fs);
     return result;
   });
@@ -5113,7 +5424,7 @@ function runFinalizerAgent(options) {
   );
 }
 function runPrDescriptionFinalizerCore(options) {
-  const artifactPath = join11(
+  const artifactPath = join12(
     options.worktreePath,
     options.artifactPathInWorktree
   );
@@ -5221,16 +5532,16 @@ function loadFinalizerPromptEffect(repoRoot2, promptTemplate, fs) {
 }
 function persistGeneratedArtifactEffect(worktreePath, output, fs) {
   return Effect6.gen(function* () {
-    const dir = join11(worktreePath, ".pourkit", ".tmp", "finalizer");
+    const dir = join12(worktreePath, ".pourkit", ".tmp", "finalizer");
     yield* fs.mkdir(dir).pipe(Effect6.catchAll(() => Effect6.void));
-    yield* fs.writeFile(join11(dir, "generated.md"), output).pipe(Effect6.catchAll(() => Effect6.void));
+    yield* fs.writeFile(join12(dir, "generated.md"), output).pipe(Effect6.catchAll(() => Effect6.void));
   });
 }
 
 // prd-run/local-merge-coordinator.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { join as join13 } from "path";
 
 // prd-run/local-branches.ts
 import { execFileSync, spawnSync as spawnSync2 } from "child_process";
@@ -5316,23 +5627,23 @@ function isProtectedBranch(name) {
 
 // prd-run/local-merge-coordinator.ts
 function getLocalStorePath(repoRoot2, prdId) {
-  return join12(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+  return join13(repoRoot2, ".pourkit", "local-prd-runs", prdId);
 }
 function getMergeReceiptPath(repoRoot2, prdId, issueId) {
-  return join12(
+  return join13(
     getLocalStorePath(repoRoot2, prdId),
     "merge-receipts",
     `${issueId}.json`
   );
 }
 function getIssueArtifactPath(repoRoot2, prdId, issueId) {
-  return join12(getLocalStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
+  return join13(getLocalStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
 }
 function readIssueBranchName(repoRoot2, prdId, issueId) {
   const issuePath = getIssueArtifactPath(repoRoot2, prdId, issueId);
-  if (!existsSync9(issuePath)) return null;
+  if (!existsSync10(issuePath)) return null;
   try {
-    const content = readFileSync11(issuePath, "utf-8");
+    const content = readFileSync12(issuePath, "utf-8");
     const parsed = JSON.parse(content);
     return typeof parsed.branchName === "string" && parsed.branchName ? parsed.branchName : null;
   } catch {
@@ -5342,9 +5653,9 @@ function readIssueBranchName(repoRoot2, prdId, issueId) {
 async function hasLocalIssueMergeReceipt(prdId, issueId, repoRoot2) {
   const root = repoRoot2 ?? process.cwd();
   const receiptPath = getMergeReceiptPath(root, prdId, issueId);
-  if (!existsSync9(receiptPath)) return null;
+  if (!existsSync10(receiptPath)) return null;
   try {
-    const content = readFileSync11(receiptPath, "utf-8");
+    const content = readFileSync12(receiptPath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed.prdId === "string" && typeof parsed.issueId === "string" && typeof parsed.stage === "string" && typeof parsed.sourceBranch === "string" && typeof parsed.localPrdBranch === "string" && typeof parsed.mergeCommit === "string" && typeof parsed.completedAt === "string") {
       return parsed;
@@ -5357,10 +5668,10 @@ async function hasLocalIssueMergeReceipt(prdId, issueId, repoRoot2) {
 async function squashMergeLocalIssue(prdId, issueId, input, repoRoot2) {
   const root = repoRoot2 ?? process.cwd();
   const receiptPath = getMergeReceiptPath(root, prdId, issueId);
-  if (existsSync9(receiptPath)) {
+  if (existsSync10(receiptPath)) {
     try {
       const existing = JSON.parse(
-        readFileSync11(receiptPath, "utf-8")
+        readFileSync12(receiptPath, "utf-8")
       );
       if (existing.prdId === prdId && existing.issueId === issueId && existing.mergeCommit) {
         return {
@@ -5472,7 +5783,7 @@ async function squashMergeLocalIssue(prdId, issueId, input, repoRoot2) {
       completedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      const receiptsDir = join12(
+      const receiptsDir = join13(
         root,
         ".pourkit",
         "local-prd-runs",
@@ -5768,6 +6079,129 @@ function runMergeCoordinator(options) {
   });
 }
 
+// commands/issue-final-review-agent.ts
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { join as join14 } from "path";
+var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join14(
+  ".pourkit",
+  ".tmp",
+  "issue-final-review",
+  "agent-output.json"
+);
+async function runIssueFinalReviewAgent(options) {
+  const {
+    executionProvider,
+    target,
+    issue,
+    parentPrdIssue,
+    builderBranch,
+    worktreePath,
+    repoRoot: repoRoot2,
+    logger
+  } = options;
+  const artifactPathInWorktree = ISSUE_FINAL_REVIEW_ARTIFACT_PATH;
+  const artifactPath = join14(worktreePath, artifactPathInWorktree);
+  const strategy = target.strategy;
+  const issueFinalReview = strategy.issueFinalReview;
+  const agent = issueFinalReview;
+  const prompt = loadIssueFinalReviewPrompt(repoRoot2, agent.promptTemplate);
+  const entry = await executeWithMissingOrEmptyArtifactRetry({
+    executionProvider,
+    missingOrEmptyRetries: resolveMissingOrEmptyOutputRetries(agent),
+    logger,
+    runningMessage: () => "Running Issue Final Review agent",
+    retryMessage: (attempt, total) => `Retrying Issue Final Review after empty output (${attempt}/${total})`,
+    executionOptions: {
+      stage: "issueFinalReview",
+      agent: agent.agent,
+      model: agent.model,
+      variant: agent.variant,
+      env: agent.env,
+      prompt,
+      target,
+      repoRoot: repoRoot2,
+      branchName: builderBranch,
+      sandbox: options.config.sandbox,
+      autoApprove: true,
+      artifactPath: artifactPathInWorktree,
+      worktreePath,
+      artifacts: [
+        buildRunContextArtifact({
+          issue,
+          parentPrdIssue,
+          target,
+          branchName: builderBranch,
+          repoRoot: repoRoot2,
+          reviewerCriteria: strategy.review.reviewer.criteria,
+          sections: STAGE_SECTIONS.issueFinalReview
+        })
+      ],
+      logger
+    }
+  });
+  const executionResult = entry.executionResult;
+  if (!executionResult.success) {
+    throw new Error(
+      `Issue Final Review agent execution failed: ${executionResult.error}`
+    );
+  }
+  let content;
+  if (entry.artifact._tag === "content") {
+    content = entry.artifact.value;
+  } else if (entry.artifact._tag === "empty") {
+    throw new Error(
+      `Issue Final Review agent produced empty output at ${artifactPath}`
+    );
+  } else {
+    throw new Error(
+      `Issue Final Review agent did not produce output at ${artifactPath}`
+    );
+  }
+  const validation = validateAgentArtifact({
+    kind: "issue-final-review",
+    artifactPath,
+    issueNumber: issue.number,
+    branchName: builderBranch
+  });
+  if (!validation.ok) {
+    throw new Error(
+      `Issue Final Review artifact validation failed: ${validation.reason}`
+    );
+  }
+  const parsed = JSON.parse(content);
+  const verdict = parsed.verdict;
+  if (verdict === "pass") {
+    return {
+      verdict: "pass",
+      artifactPath,
+      selfRetouched: parsed.selfRetouched === true,
+      changedPaths: parsed.changedPaths,
+      verificationPassed: parsed.verification?.passed === true
+    };
+  }
+  if (verdict === "needs_human_review") {
+    return {
+      verdict: "needs_human_review",
+      artifactPath,
+      needsHumanReason: parsed.needsHumanReason,
+      selfRetouched: parsed.selfRetouched === true,
+      changedPaths: parsed.changedPaths
+    };
+  }
+  throw new Error(
+    `Unknown Issue Final Review verdict: ${JSON.stringify(verdict)}`
+  );
+}
+function loadIssueFinalReviewPrompt(repoRoot2, promptTemplate) {
+  const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
+  const promptBody = existsSync11(promptPath) ? readFileSync13(promptPath, "utf-8") : promptTemplate;
+  return appendProtectedWorkGuidance(`${promptBody}
+
+## Shared Run Context
+
+Read the selected issue requirements, PRD context, comments, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}`);
+}
+
 // issues/issue-transitions.ts
 function createIssueTransitions(deps, labels) {
   return {
@@ -5939,19 +6373,95 @@ function resolveSerenaRuntimeConfig(config, target) {
     sandboxMcpUrl: config.serena.sandboxMcpUrl
   };
 }
-async function startIssueRun(options) {
+function assertIssueFinalReviewPassed(worktreeState) {
+  const ifr = worktreeState?.issueFinalReview;
+  if (!ifr || !ifr.completed || ifr.verdict !== "pass") {
+    throw new Error(
+      "Issue Final Review has not passed. Cannot proceed to finalizer, commit, or PR creation."
+    );
+  }
+}
+async function advanceIssueFinalReview(options) {
   const {
-    issueNumber,
-    targetName,
-    config,
-    issueProvider,
-    prProvider,
     executionProvider,
-    force,
-    logger
+    config,
+    target,
+    issue,
+    parentPrdIssue,
+    builderBranch,
+    worktreePath,
+    repoRoot: repoRoot2,
+    logger,
+    reviewArtifactPath,
+    worktreeState
+  } = options;
+  const ifrFromState = worktreeState?.issueFinalReview;
+  if (ifrFromState?.completed && ifrFromState.verdict === "pass") {
+    if (!ifrFromState.artifactPath) {
+      throw new Error(
+        "Issue Final Review state is incomplete: missing artifactPath"
+      );
+    }
+    const artifactPath = isAbsolute3(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join15(worktreePath, ifrFromState.artifactPath);
+    const validation = validateAgentArtifact({
+      kind: "issue-final-review",
+      artifactPath,
+      issueNumber: issue.number,
+      branchName: builderBranch
+    });
+    if (!validation.ok) {
+      throw new Error(
+        `Issue Final Review state artifact is invalid: ${validation.reason}`
+      );
+    }
+    return {
+      verdict: "pass",
+      artifactPath,
+      selfRetouched: ifrFromState.selfRetouched ?? false,
+      changedPaths: ifrFromState.changedPaths ?? [],
+      verificationPassed: ifrFromState.verificationPassed ?? false
+    };
+  }
+  const result = await runIssueFinalReviewAgent({
+    executionProvider,
+    config,
+    target,
+    issue,
+    parentPrdIssue,
+    builderBranch,
+    worktreePath,
+    repoRoot: repoRoot2,
+    logger,
+    reviewArtifactPath
+  });
+  if (result.verdict === "pass") {
+    updateWorktreeRunState(worktreePath, {
+      issueFinalReview: {
+        completed: true,
+        verdict: "pass",
+        artifactPath: result.artifactPath,
+        selfRetouched: result.selfRetouched,
+        changedPaths: result.changedPaths,
+        verificationPassed: result.verificationPassed
+      }
+    });
+  }
+  return result;
+}
+async function startIssueRun(options) {
+  const {
+    issueNumber,
+    targetName,
+    config,
+    issueProvider,
+    prProvider,
+    executionProvider,
+    force,
+    logger
   } = options;
   const ROOT = options.repoRoot;
   const issue = await issueProvider.fetchIssue(issueNumber);
+  const parentPrdIssue = await fetchParentPrdIssue(issue, issueProvider);
   const gateResult = checkIssueGates(issue, config, force);
   if (!gateResult.allowed) {
     throw new Error(`Issue gates failed: ${gateResult.reason}`);
@@ -6104,8 +6614,10 @@ async function startIssueRun(options) {
   }
   const runContextArtifact = buildRunContextArtifact({
     issue,
+    parentPrdIssue,
     target: effectiveTarget,
     branchName,
+    repoRoot: ROOT,
     reviewerCriteria: strategy.review.reviewer.criteria,
     sections: STAGE_SECTIONS.builder
   });
@@ -6166,6 +6678,7 @@ async function startIssueRun(options) {
   const finalWorktreeState = executionResult.worktreePath ? readWorktreeRunState(executionResult.worktreePath) : worktreeState;
   return {
     issue,
+    parentPrdIssue,
     target,
     effectiveTarget,
     branchName,
@@ -6174,6 +6687,18 @@ async function startIssueRun(options) {
     ...serenaExecutionContext ? { serena: serenaExecutionContext } : {}
   };
 }
+async function fetchParentPrdIssue(issue, issueProvider) {
+  const parentSection = issue.body.match(
+    /^## Parent\s*\n([\s\S]*?)(?=\n## |$)/im
+  )?.[1];
+  const parentNumber = parentSection?.match(/#(\d+)\b/)?.[1];
+  if (!parentNumber) return void 0;
+  try {
+    return await issueProvider.fetchIssue(Number(parentNumber));
+  } catch {
+    return void 0;
+  }
+}
 async function advanceIssueRunReview(options) {
   const accumulatedRefactorPaths = [];
   const reviewResult = await runEffectAndMapExit(
@@ -6225,6 +6750,8 @@ async function completeIssueRun(options) {
     checksCompletionTimeoutMs: config.checks.checksCompletionTimeoutSeconds * 1e3,
     pollIntervalMs: config.checks.pollIntervalSeconds * 1e3
   };
+  const ifrState = executionResult.worktreePath ? readWorktreeRunState(executionResult.worktreePath) ?? worktreeState : worktreeState;
+  assertIssueFinalReviewPassed(ifrState);
   let mergeCompleted = false;
   try {
     if (executionResult.worktreePath && !worktreeState?.finalCommit?.completed && !worktreeState?.pr?.created && !await hasWorktreeChanges(
@@ -6255,12 +6782,12 @@ async function completeIssueRun(options) {
           prTitle = finalizerFromState.title;
           prBody = finalizerFromState.body;
         } else if (finalizerFromState.artifactPath) {
-          if (!existsSync10(finalizerFromState.artifactPath)) {
+          if (!existsSync12(finalizerFromState.artifactPath)) {
             throw new FinalizerFailure({
               message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
             });
           }
-          const artifactContent = readFileSync12(
+          const artifactContent = readFileSync14(
             finalizerFromState.artifactPath,
             "utf-8"
           );
@@ -6413,7 +6940,7 @@ async function completeIssueRun(options) {
           failureCode: "already_merged",
           localPrdBranch: existingReceipt.localPrdBranch,
           mergeCommit: existingReceipt.mergeCommit,
-          receiptPath: join13(
+          receiptPath: join15(
             ROOT,
             ".pourkit",
             "local-prd-runs",
@@ -6478,7 +7005,7 @@ async function completeIssueRun(options) {
         mode: "local",
         localPrdBranch: getLocalPrdBranchName(prdId),
         mergeCommit: mergeResult.receipt.mergeCommit,
-        receiptPath: join13(
+        receiptPath: join15(
           ROOT,
           ".pourkit",
           "local-prd-runs",
@@ -6929,7 +7456,7 @@ async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   return { mode: "new", branchName, baseRef };
 }
 function issueWorktreePath(root, branchName) {
-  return join13(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
+  return join15(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
 }
 function resolveRegisteredIssueWorktreePath(worktreeListPorcelain, root, branchName) {
   const branchWorktreePath = parseWorktreeListPorcelain(
@@ -6957,12 +7484,12 @@ async function syncTargetBranch(root, baseBranch, logger) {
 }
 function loadBuilderPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync10(promptPath) ? readFileSync12(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync12(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
 
-Read the selected issue requirements, comments, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}`);
+Read the selected issue requirements, PRD context, comments, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}`);
 }
 async function handleRebaseConflict(failure, context) {
   const frConfig = context.target.strategy.failureResolution;
@@ -7228,6 +7755,7 @@ async function runIssueCommand(options) {
     const startResult = await startIssueRun(runOptions);
     const {
       issue,
+      parentPrdIssue,
       target,
       effectiveTarget,
       branchName,
@@ -7246,6 +7774,7 @@ async function runIssueCommand(options) {
         config,
         target: effectiveTarget,
         issue,
+        parentPrdIssue,
         builderBranch: branchName,
         worktreePath: executionResult.worktreePath,
         repoRoot: ROOT,
@@ -7276,6 +7805,54 @@ async function runIssueCommand(options) {
       }
       reviewArtifactPath = reviewResult.artifactPath;
     }
+    const finalReviewResult = await advanceIssueFinalReview({
+      executionProvider: runOptions.executionProvider,
+      config,
+      target: effectiveTarget,
+      issue,
+      parentPrdIssue,
+      builderBranch: branchName,
+      worktreePath: executionResult.worktreePath,
+      repoRoot: ROOT,
+      logger,
+      reviewArtifactPath,
+      worktreeState
+    });
+    if (finalReviewResult.verdict === "needs_human_review") {
+      const transitions = createIssueTransitions(
+        {
+          fetchIssue: issueProvider.fetchIssue.bind(issueProvider),
+          addLabels: issueProvider.addLabels.bind(issueProvider),
+          removeLabel: issueProvider.removeLabel.bind(issueProvider),
+          closeIssue: issueProvider.closeIssue.bind(issueProvider)
+        },
+        {
+          blocked: config.labels.blocked,
+          readyForAgent: config.labels.readyForAgent,
+          needsTriage: config.labels.needsTriage,
+          agentInProgress: config.labels.agentInProgress,
+          readyForHuman: config.labels.readyForHuman,
+          prOpenAwaitingMerge: config.labels.prOpenAwaitingMerge
+        }
+      );
+      await transitions.moveToReadyForHuman(issueNumber);
+      const comment = [
+        "Pourkit stopped the Issue Final Review because human review is needed.",
+        "",
+        finalReviewResult.needsHumanReason,
+        "",
+        "Artifacts:",
+        `- Issue Final Review: ${finalReviewResult.artifactPath}`
+      ].join("\n");
+      await issueProvider.commentIssue(issueNumber, comment);
+      logger.step(
+        "info",
+        `Issue Final Review requires human handoff for issue ${issueNumber}`
+      );
+      throw new HumanHandoffStop(
+        `Issue Final Review requires human handoff: ${finalReviewResult.needsHumanReason}`
+      );
+    }
     return await completeIssueRun({
       ...runOptions,
       startResult,
@@ -7400,29 +7977,29 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 // commands/prd-run.ts
 import {
   cpSync,
-  existsSync as existsSync14,
+  existsSync as existsSync16,
   lstatSync,
   mkdirSync as mkdirSync10,
   mkdtempSync,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync17,
   realpathSync,
   rmSync as rmSync3
 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { dirname as dirname4, join as join18, relative } from "path";
+import { dirname as dirname4, join as join20, relative as relative2 } from "path";
 import { tmpdir } from "os";
 import { Match, pipe } from "effect";
 
 // prd-run/state.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync4,
   writeFileSync as writeFileSync5
 } from "fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import { z as z2 } from "zod";
 var PRD_RUN_STATE_DIR = ".pourkit/prd-runs";
 var PrdRunRecordSchema = z2.object({
@@ -7512,16 +8089,16 @@ function normalizePrdRunRef(ref) {
 function readPrdRun(repoRoot2, prdRef) {
   const normalized = normalizePrdRunRef(prdRef);
   const recordPath = getRecordPath(repoRoot2, normalized);
-  if (!existsSync11(recordPath)) {
+  if (!existsSync13(recordPath)) {
     return { record: null, diagnostics: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync13(recordPath, "utf-8"));
+    const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
     const parsed = PrdRunRecordSchema.parse(raw);
     return { record: parsed, diagnostics: [] };
   } catch (error) {
     try {
-      const raw = JSON.parse(readFileSync13(recordPath, "utf-8"));
+      const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
       if (raw && typeof raw === "object" && raw.start && typeof raw.start === "object" && raw.start.startBaseBranch === void 0) {
         return {
           record: raw,
@@ -7542,20 +8119,20 @@ function readPrdRun(repoRoot2, prdRef) {
   }
 }
 function listPrdRuns(repoRoot2) {
-  const stateDir = join14(repoRoot2, PRD_RUN_STATE_DIR);
-  if (!existsSync11(stateDir)) {
+  const stateDir = join16(repoRoot2, PRD_RUN_STATE_DIR);
+  if (!existsSync13(stateDir)) {
     return { records: [], diagnostics: [] };
   }
   const records = [];
   const diagnostics = [];
-  for (const entry of readdirSync3(stateDir, { withFileTypes: true }).sort(
+  for (const entry of readdirSync4(stateDir, { withFileTypes: true }).sort(
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const recordPath = join14(stateDir, entry.name);
+    const recordPath = join16(stateDir, entry.name);
     try {
       const record = PrdRunRecordSchema.parse(
-        JSON.parse(readFileSync13(recordPath, "utf-8"))
+        JSON.parse(readFileSync15(recordPath, "utf-8"))
       );
       records.push(record);
     } catch (error) {
@@ -7568,7 +8145,7 @@ function listPrdRuns(repoRoot2) {
 }
 function writePrdRunRecord(repoRoot2, record) {
   const normalized = normalizePrdRunRef(record.prdRef);
-  const stateDir = join14(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join16(repoRoot2, PRD_RUN_STATE_DIR);
   const recordPath = getRecordPath(repoRoot2, normalized);
   mkdirSync8(stateDir, { recursive: true });
   writeFileSync5(
@@ -7577,7 +8154,6 @@ function writePrdRunRecord(repoRoot2, record) {
     "utf-8"
   );
 }
-var LOCAL_PRD_RUN_STATE_DIR = ".pourkit/local-prd-runs";
 var LocalPrdRunRecordSchema = z2.object({
   prdId: z2.string().regex(
     /^PRD-\d{4}$/,
@@ -7613,38 +8189,8 @@ var LocalPrdRunRecordSchema = z2.object({
   }).strict(),
   metadata: z2.record(z2.unknown())
 }).strict();
-function getLocalStorePath2(repoRoot2, prdId) {
-  return join14(
-    repoRoot2,
-    LOCAL_PRD_RUN_STATE_DIR,
-    `${normalizePrdRunRef(prdId)}.json`
-  );
-}
-async function readLocalPrdRun(repoRoot2, prdId) {
-  const normalized = normalizePrdRunRef(prdId);
-  const recordPath = getLocalStorePath2(repoRoot2, normalized);
-  if (!existsSync11(recordPath)) {
-    return null;
-  }
-  try {
-    const content = await readFile4(recordPath, "utf-8");
-    return LocalPrdRunRecordSchema.parse(JSON.parse(content));
-  } catch {
-    return null;
-  }
-}
-async function writeLocalPrdRunRecord(repoRoot2, prdId, record) {
-  const normalized = normalizePrdRunRef(prdId);
-  const storeDir = join14(repoRoot2, LOCAL_PRD_RUN_STATE_DIR);
-  await mkdir4(storeDir, { recursive: true });
-  await writeFile(
-    getLocalStorePath2(repoRoot2, normalized),
-    JSON.stringify({ ...record, prdId: normalized }, null, 2),
-    "utf-8"
-  );
-}
 function getRecordPath(repoRoot2, prdRef) {
-  return join14(
+  return join16(
     repoRoot2,
     PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef(prdRef)}.json`
@@ -7668,102 +8214,13 @@ var EvidencePacketSchema = z3.object({
   stage: StageSchema,
   stageReceipts: z3.record(z3.string(), z3.unknown())
 }).strict();
-function buildEvidencePacket(input) {
-  const requiredFields = [
-    "prdRef",
-    "prdBranch",
-    "mergeBase",
-    "planningManifestPath",
-    "stage"
-  ];
-  for (const field of requiredFields) {
-    const value = input[field];
-    if (typeof value !== "string" || value.trim().length === 0) {
-      throw new Error(
-        `Evidence Packet construction failed: "${field}" is required and must be a non-empty string.`
-      );
-    }
-  }
-  if (!input.planningManifestFacts || typeof input.planningManifestFacts.parentPrdIssueUrl !== "string" || input.planningManifestFacts.parentPrdIssueUrl.trim().length === 0) {
-    throw new Error(
-      'Evidence Packet construction failed: "planningManifestFacts.parentPrdIssueUrl" is required and must be a non-empty string.'
-    );
-  }
-  if (typeof input.planningManifestFacts.childIssueCount !== "number" || !Number.isInteger(input.planningManifestFacts.childIssueCount) || input.planningManifestFacts.childIssueCount < 0) {
-    throw new Error(
-      'Evidence Packet construction failed: "planningManifestFacts.childIssueCount" is required and must be a non-negative integer.'
-    );
-  }
-  if (!PRD_REF_REGEX2.test(input.prdRef.trim())) {
-    throw new Error(
-      `Evidence Packet construction failed: "prdRef" must match PRD-\\d{3,4} format, got "${input.prdRef}".`
-    );
-  }
-  const stageResult = StageSchema.safeParse(input.stage);
-  if (!stageResult.success) {
-    throw new Error(
-      `Evidence Packet construction failed: "stage" must be one of "prdFinalReview" or "prdReconciliation", got "${input.stage}".`
-    );
-  }
-  if (stageResult.data === "prdFinalReview") {
-    const hasMergeBaseReceipt = "mergeBase" in input.stageReceipts;
-    const hasFinalReviewRef = "finalReviewRef" in input.stageReceipts;
-    if (!hasMergeBaseReceipt && !hasFinalReviewRef) {
-      throw new Error(
-        "Evidence Packet construction failed: Final Review stage receipts must include at minimum a mergeBase or finalReviewRef receipt."
-      );
-    }
-  }
-  if (stageResult.data === "prdReconciliation") {
-    if (!("finalReviewReceipt" in input.stageReceipts)) {
-      throw new Error(
-        "Evidence Packet construction failed: Reconciliation stage receipts must include at minimum a finalReviewReceipt."
-      );
-    }
-  }
-  const mergeBase = input.mergeBase.trim();
-  if (mergeBase.length < 6) {
-    throw new Error(
-      `Evidence Packet construction failed: "mergeBase" must be a non-empty commit SHA with at least 6 characters, got "${mergeBase}".`
-    );
-  }
-  const packet = {
-    prdRef: input.prdRef.trim(),
-    prdBranch: input.prdBranch.trim(),
-    mergeBase,
-    planningManifestPath: input.planningManifestPath.trim(),
-    planningManifestFacts: {
-      parentPrdIssueUrl: input.planningManifestFacts.parentPrdIssueUrl.trim(),
-      childIssueCount: input.planningManifestFacts.childIssueCount
-    },
-    stage: stageResult.data,
-    stageReceipts: input.stageReceipts
-  };
-  return packet;
-}
-var TOKEN_LIKE_PATTERNS = [
-  /gh[ps]_[A-Za-z0-9]{20,}/g,
-  /token[=:_\s][A-Za-z0-9_-]{20,}/gi,
-  /secret[=:_\s][A-Za-z0-9_-]{20,}/gi,
-  /credential[=:_\s][A-Za-z0-9_-]{20,}/gi,
-  /key[=:_\s][A-Za-z0-9_-]{20,}/gi,
-  /-----BEGIN (RSA |EC )?PRIVATE KEY-----/g,
-  /xox[baprs]-[A-Za-z0-9_-]{10,}/g
-];
-function redactSensitiveValues(input) {
-  let redacted = input;
-  for (const pattern of TOKEN_LIKE_PATTERNS) {
-    redacted = redacted.replace(pattern, "[REDACTED]");
-  }
-  return redacted;
-}
 
 // commands/prd-run.ts
 init_common();
 
 // prd-run/local-artifacts.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join17 } from "path";
 var REQUIRED_PRD_FIELDS = [
   "schemaVersion",
   "kind",
@@ -7796,13 +8253,13 @@ var REQUIRED_ISSUE_FIELDS = [
   "githubProjection"
 ];
 function prdStorePath(repoRoot2, prdId) {
-  return join15(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+  return join17(repoRoot2, ".pourkit", "local-prd-runs", prdId);
 }
 function prdArtifactPath(repoRoot2, prdId) {
-  return join15(prdStorePath(repoRoot2, prdId), "prd.json");
+  return join17(prdStorePath(repoRoot2, prdId), "prd.json");
 }
 function issueArtifactPath(repoRoot2, prdId, issueId) {
-  return join15(prdStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
+  return join17(prdStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
 }
 function hasRequiredFields(data, requiredFields) {
   for (const field of requiredFields) {
@@ -7815,7 +8272,7 @@ function hasRequiredFields(data, requiredFields) {
 async function resolveLocalPrdArtifact(prdId, repoRoot2) {
   const root = repoRoot2 ?? process.cwd();
   const prdPath = prdArtifactPath(root, prdId);
-  if (!existsSync12(prdPath)) {
+  if (!existsSync14(prdPath)) {
     return {
       ok: false,
       failureCode: "missing_prd_artifact",
@@ -7860,7 +8317,7 @@ async function resolveLocalIssueArtifacts(prdId, repoRoot2) {
   const issues = [];
   for (const childId of childIssueIds) {
     const issuePath = issueArtifactPath(root, prdId, childId);
-    if (!existsSync12(issuePath)) {
+    if (!existsSync14(issuePath)) {
       return {
         ok: false,
         failureCode: "missing_child_issue",
@@ -7963,109 +8420,11 @@ async function getRunnableLocalIssues(prdId, repoRoot2) {
 // prd-run/local-final-review.ts
 import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join16 } from "path";
-async function squashFinalReviewRetouch(prdId, repoRoot2, title, body) {
-  const root = repoRoot2 ?? process.cwd();
-  const targetBranch = `local/${prdId}`;
-  const retouchBranch = `local-${prdId}-final-review-retouch`;
-  try {
-    execFileSync3(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${retouchBranch}`],
-      {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }
-    );
-  } catch {
-    return;
-  }
-  try {
-    execFileSync3(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
-      {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }
-    );
-  } catch {
-    return;
-  }
-  try {
-    execFileSync3("git", ["checkout", targetBranch], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    execFileSync3("git", ["merge", "--squash", retouchBranch], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    try {
-      execFileSync3("git", ["diff", "--cached", "--quiet"], {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      });
-      return;
-    } catch {
-    }
-    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",
-      stdio: "pipe"
-    }).trim();
-    const changedPathsResult = execFileSync3(
-      "git",
-      ["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"],
-      {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }
-    );
-    const changedPaths = changedPathsResult.split(/\r?\n/).filter(Boolean);
-    return {
-      mergeCommit,
-      changedPaths,
-      reviewedTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.toLowerCase().includes("conflict")) {
-      throw new Error(`Retouch squash merge conflict in ${targetBranch}`);
-    }
-    throw error;
-  }
-}
+import { join as join18 } from "path";
 
 // prd-run/local-queue-loop.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "fs";
+import { join as join19 } from "path";
 
 // prd-run/local-issue-run.ts
 import { execFileSync as execFileSync4 } from "child_process";
@@ -8152,8 +8511,30 @@ async function runLocalIssue(prdId, issueId, builder, repoRoot2) {
           failureCode: result.error ?? "Builder execution failed"
         };
       }
+      if (!result.issueFinalReviewPassedAt || !result.finalizerTitle || !result.finalizerBody) {
+        return {
+          ok: false,
+          issueId,
+          branch,
+          failureCode: "Local issue run did not produce Issue Final Review and finalizer receipts"
+        };
+      }
+      return {
+        ok: true,
+        issueId,
+        branch,
+        issueFinalReviewPassedAt: result.issueFinalReviewPassedAt,
+        finalizerTitle: result.finalizerTitle,
+        finalizerBody: result.finalizerBody,
+        finalizerArtifactPath: result.finalizerArtifactPath
+      };
     }
-    return { ok: true, issueId, branch };
+    return {
+      ok: false,
+      issueId,
+      branch,
+      failureCode: "Local issue runner requires Issue Final Review and finalizer lifecycle execution before merge"
+    };
   } catch (error) {
     return {
       ok: false,
@@ -8167,7 +8548,7 @@ async function runLocalIssue(prdId, issueId, builder, repoRoot2) {
 // prd-run/local-queue-loop.ts
 var CHILD_CLEANUP_LABELS = ["agent-in-progress", "pr-open-awaiting-merge"];
 function getIssueArtifactPath2(repoRoot2, prdId, issueId) {
-  return join17(
+  return join19(
     repoRoot2,
     ".pourkit",
     "local-prd-runs",
@@ -8178,7 +8559,7 @@ function getIssueArtifactPath2(repoRoot2, prdId, issueId) {
 }
 function readIssueArtifact(repoRoot2, prdId, issueId) {
   try {
-    const content = readFileSync14(
+    const content = readFileSync16(
       getIssueArtifactPath2(repoRoot2, prdId, issueId),
       "utf-8"
     );
@@ -8281,10 +8662,40 @@ async function runLocalQueueLoop(prdId, repoRoot2, issueProvider) {
         blockedGate: "queue"
       };
     }
+    if (!runResult.issueFinalReviewPassedAt || !runResult.finalizerTitle || !runResult.finalizerBody) {
+      return {
+        ok: false,
+        completedIssues,
+        blockedIssues,
+        failureCode: runResult.failureCode ?? "issue_final_review_not_passed",
+        repairGuidance: "Local issue run must complete Issue Final Review and finalizer before local squash merge.",
+        blockedGate: "queue"
+      };
+    }
+    const runArtifact = readIssueArtifact(root, prdId, issue.id);
+    if (!runArtifact) {
+      return {
+        ok: false,
+        completedIssues,
+        blockedIssues,
+        failureCode: "missing_issue_artifact",
+        repairGuidance: `Issue artifact not found for ${issue.id} under PRD ${prdId}. Ensure the issue exists before running the queue loop.`,
+        blockedGate: "queue"
+      };
+    }
+    runArtifact.issueFinalReviewPassedAt = runResult.issueFinalReviewPassedAt;
+    runArtifact.receipts.reviewedAt = runResult.issueFinalReviewPassedAt;
+    runArtifact.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeIssueArtifact(root, prdId, runArtifact);
     const mergeResult = await squashMergeLocalIssue(
       prdId,
       issue.id,
-      void 0,
+      {
+        finalizerTitle: runResult.finalizerTitle,
+        finalizerBody: runResult.finalizerBody,
+        finalizerArtifactPath: runResult.finalizerArtifactPath ?? "",
+        sourceBranch: runResult.branch
+      },
       root
     );
     if (!mergeResult.ok) {
@@ -8415,24 +8826,16 @@ function selectIssue(candidates, options = {}) {
 }
 
 // issues/blocked-issue.ts
-function parseBlockedBy(body) {
-  if (!body) return [];
-  const bm = body.match(/## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i);
-  if (!bm) return [];
-  const refs = [];
-  const re = /#(\d+)/g;
-  let m;
-  while ((m = re.exec(bm[1])) !== null) {
-    refs.push(Number(m[1]));
-  }
-  return refs;
-}
 async function reconcileBlockedIssue(issue, deps) {
-  const blockers = parseBlockedBy(issue.body);
-  if (blockers.length === 0) {
+  const parsedBlockers = parseBlockedByRefs(issue.body);
+  if (!parsedBlockers.hasSection) {
     await deps.transitions.moveToNeedsTriage(issue.number);
     return "needs-triage";
   }
+  const blockers = await resolveBlockedRefs(parsedBlockers.refs, issue, deps);
+  if (blockers.length === 0) {
+    return "still-blocked";
+  }
   const stillBlocked = await anyBlockerStillOpen(blockers, deps.getIssueState);
   if (stillBlocked) {
     return "still-blocked";
@@ -8450,6 +8853,37 @@ async function reconcileBlockedIssue(issue, deps) {
   await deps.transitions.moveToNeedsTriage(issue.number);
   return "needs-triage";
 }
+function parseBlockedByRefs(body) {
+  if (!body) return { hasSection: false, refs: [] };
+  const bm = body.match(/## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i);
+  if (!bm) return { hasSection: false, refs: [] };
+  const refs = [];
+  const re = /#(\d+)|\bI-\d+\b/gi;
+  let m;
+  while ((m = re.exec(bm[1])) !== null) {
+    refs.push((m[1] ? `#${m[1]}` : m[0]).toUpperCase());
+  }
+  return { hasSection: true, refs: Array.from(new Set(refs)) };
+}
+async function resolveBlockedRefs(refs, issue, deps) {
+  const resolved = [];
+  for (const ref of refs) {
+    const issueNumber = parseGitHubIssueRef(ref);
+    if (issueNumber !== null) {
+      resolved.push(issueNumber);
+      continue;
+    }
+    const siblingNumber = deps.resolveIssueRef ? await deps.resolveIssueRef(ref, issue) : null;
+    if (siblingNumber !== null) {
+      resolved.push(siblingNumber);
+    }
+  }
+  return Array.from(new Set(resolved));
+}
+function parseGitHubIssueRef(ref) {
+  const match = ref.match(/^#?(\d+)$/);
+  return match ? Number(match[1]) : null;
+}
 async function reconcileBlockedIssues(issues, deps) {
   const results = [];
   for (const issue of issues) {
@@ -8598,6 +9032,16 @@ function makeReconcileDeps(options) {
       const issue = await options.issueProvider.fetchIssue(issueNumber);
       return issue.state === "closed" ? "CLOSED" : "OPEN";
     },
+    resolveIssueRef: async (ref, issue) => {
+      const parentRef = options.prdRef ?? parseStackedIssue(issue.title ?? "", issue.body).parentRef;
+      if (!parentRef) return null;
+      const related = await options.issueProvider.listRelatedIssues(parentRef);
+      const expectedPrefix = `${parentRef} / ${ref.toUpperCase()}:`;
+      const match = related.find(
+        (candidate) => candidate.title.toUpperCase().startsWith(expectedPrefix)
+      );
+      return match?.number ?? null;
+    },
     transitions,
     typeLabels: TYPE_LABELS,
     readyLabel: options.config.labels.readyForAgent
@@ -8675,6 +9119,11 @@ function runOneQueueIssueEffect(options) {
         ...prdRunMode ? { prdRunMode } : {}
       }),
       catch: (e) => {
+        if (e instanceof Error && e.name === "HumanHandoffStop") {
+          return new QueueProviderError(
+            `Issue Final Review requires human handoff: ${e.message}`
+          );
+        }
         if (e instanceof Error) return e;
         throw e;
       }
@@ -8691,1964 +9140,178 @@ function runOneQueueIssueEffect(options) {
       logger.raw(`  PR Title: ${runResult.prTitle}`);
       logger.raw(`  PR Number: ${runResult.prNumber}`);
       logger.raw(`  PR URL: ${runResult.prUrl}`);
-    }
-    logger.raw(`  Target: ${runResult.target.name}`);
-    return { selected, runResult };
-  });
-}
-function runQueue(options) {
-  return runOneQueueIssueEffect(options);
-}
-function runQueueLoopEffect(options, results) {
-  return Effect8.gen(function* () {
-    yield* reconcileBlockedEffect(options);
-    const outcome = yield* runOneQueueIssueEffect(options);
-    if (outcome.selected === null) {
-      return {
-        drained: true,
-        processedCount: results.length,
-        results,
-        selected: null,
-        reason: "Queue drained.",
-        code: "drained"
-      };
-    }
-    const newResults = [...results, outcome];
-    const processedIssue = yield* Effect8.tryPromise({
-      try: () => options.issueProvider.fetchIssue(outcome.selected.number),
-      catch: (e) => {
-        if (e instanceof Error) {
-          return new QueueProviderError(e.message);
-        }
-        throw e;
-      }
-    });
-    if (processedIssue.state === "closed") {
-      yield* reconcileBlockedEffect(options);
-    }
-    return yield* runQueueLoopEffect(options, newResults);
-  });
-}
-function runQueueLoop(options) {
-  return runQueueLoopEffect(options, []);
-}
-
-// commands/queue-run.ts
-async function runQueueCommand(options) {
-  initializeEffectRuntime();
-  const queueOptions = {
-    targetName: options.targetName,
-    config: options.config,
-    issueProvider: options.issueProvider,
-    prProvider: options.prProvider,
-    executionProvider: options.executionProvider,
-    force: options.force,
-    logger: options.logger,
-    repoRoot: options.repoRoot,
-    prdRef: options.prdRef,
-    queueRunContext: options.queueRunContext,
-    prdRunMode: options.queueRunContext?.prdRunMode
-  };
-  if (!options.loop) {
-    return runEffectAndMapExit(runQueue(queueOptions));
-  }
-  return runEffectAndMapExit(runQueueLoop(queueOptions));
-}
-
-// commands/prd-run.ts
-function planLaunchResume(record) {
-  if (!record) return { attempted: [], skipped: [], resumed: [] };
-  return pipe(
-    record,
-    Match.value,
-    Match.when({ status: "waiting_for_integration" }, () => ({
-      attempted: [],
-      skipped: ["start", "queue", "final-review"],
-      resumed: []
-    })),
-    Match.when({ status: "completed_local_branch" }, () => ({
-      attempted: [],
-      skipped: ["start", "queue", "final-review"],
-      resumed: []
-    })),
-    Match.when({ status: "complete" }, () => ({
-      attempted: [],
-      skipped: ["start", "queue", "final-review"],
-      resumed: []
-    })),
-    Match.when({ status: "drained" }, () => ({
-      attempted: [],
-      skipped: ["start", "queue"],
-      resumed: ["final-review"]
-    })),
-    Match.when({ status: "final_reviewed" }, () => ({
-      attempted: [],
-      skipped: ["start", "queue", "final-review"],
-      resumed: []
-    })),
-    Match.when(
-      (value) => value.status === "blocked" && value.blockedGate === "final-review" && canRetryFinalReviewBlock(value),
-      () => ({
-        attempted: [],
-        skipped: [],
-        resumed: ["start"]
-      })
-    ),
-    Match.when(
-      (value) => value.status === "starting" || value.status === "running" || value.status === "blocked" && (value.blockedGate === "queue" || value.blockedGate === "branch-state"),
-      (value) => value.start ? {
-        attempted: [],
-        skipped: [],
-        resumed: ["start"]
-      } : {
-        attempted: [],
-        skipped: ["start", "queue", "final-review"],
-        resumed: [],
-        blocked: "missing-start-receipt"
-      }
-    ),
-    Match.orElse(() => ({
-      attempted: [],
-      skipped: [],
-      resumed: []
-    }))
-  );
-}
-async function validateFinalReviewChildCompleteness(prdRef, record, issueProvider) {
-  const scopeChangeMap = /* @__PURE__ */ new Map();
-  for (const sc of record.scopeChanges ?? []) {
-    scopeChangeMap.set(sc.issueNumber, sc);
-  }
-  let childIssues;
-  try {
-    const listed = await issueProvider.listRelatedIssues(prdRef);
-    if (!Array.isArray(listed)) {
-      return {
-        ok: true,
-        diagnostics: [
-          `IssueProvider.listRelatedIssues("${prdRef}") did not return child issue data; skipping child completeness validation.`
-        ]
-      };
-    }
-    childIssues = listed;
-  } catch (error) {
-    return {
-      ok: false,
-      gate: "final-review",
-      reason: `Final Review blocked: failed to list child issues for ${prdRef}.`,
-      diagnostics: [error instanceof Error ? error.message : String(error)],
-      offendingPaths: []
-    };
-  }
-  if (childIssues.length === 0) {
-    return {
-      ok: false,
-      gate: "final-review",
-      reason: `Final Review blocked: no child issues found for ${prdRef}.`,
-      diagnostics: [
-        `IssueProvider.listRelatedIssues("${prdRef}") returned no child issues.`
-      ],
-      offendingPaths: []
-    };
-  }
-  const incompleteChildren = [];
-  const scopeChangeDiagnostics = [];
-  for (const child of childIssues) {
-    if (!child.number || child.number <= 0) {
-      incompleteChildren.push(`Issue has invalid number ${child.number}`);
-      continue;
-    }
-    let issueData = null;
-    try {
-      issueData = await issueProvider.fetchIssue(child.number);
-    } catch {
-      incompleteChildren.push(`#${child.number}: failed to fetch issue state`);
-      continue;
-    }
-    if (!issueData || typeof issueData.state !== "string") {
-      incompleteChildren.push(`#${child.number}: failed to fetch issue state`);
-      continue;
-    }
-    if (issueData.state === "closed") {
-      continue;
-    }
-    const scopeChange = scopeChangeMap.get(child.number);
-    const skipLabels = ["wontfix", "skipped"];
-    const hasSkipLabel = child.labels.some(
-      (label) => skipLabels.includes(label)
-    );
-    if (hasSkipLabel && scopeChange && scopeChange.decision === "accepted_scope_change" && scopeChange.reason && scopeChange.acceptedBy && scopeChange.acceptedAt) {
-      scopeChangeDiagnostics.push(
-        `#${child.number}: skipped/wontfix with accepted scope-change evidence`
-      );
-      continue;
-    }
-    if (scopeChange && scopeChange.decision === "accepted_scope_change" && scopeChange.reason && scopeChange.acceptedBy && scopeChange.acceptedAt) {
-      scopeChangeDiagnostics.push(
-        `#${child.number}: open but accepted scope-change evidence`
-      );
-      continue;
-    }
-    incompleteChildren.push(
-      `#${child.number}: ${issueData.state} without accepted scope-change evidence`
-    );
-  }
-  if (incompleteChildren.length > 0) {
-    return {
-      ok: false,
-      gate: "final-review",
-      reason: "Final Review blocked: one or more child issues are incomplete without accepted scope-change evidence.",
-      diagnostics: [
-        "Incomplete child issues:",
-        ...incompleteChildren.map((ic) => `  - ${ic}`)
-      ],
-      offendingPaths: []
-    };
-  }
-  const diagnostics = [];
-  if (scopeChangeDiagnostics.length > 0) {
-    diagnostics.push(
-      "Scope-change evidence accepted for:",
-      ...scopeChangeDiagnostics.map((d) => `  - ${d}`)
-    );
-  }
-  return { ok: true, diagnostics };
-}
-function validateLocalStartStore(repoRoot2, prdRef) {
-  const localStoreDir = join18(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
-  let localStoreReady = false;
-  if (existsSync14(localStoreDir)) {
-    const localStorePath = join18(localStoreDir, "prd.json");
-    try {
-      const content = JSON.parse(readFileSync15(localStorePath, "utf8"));
-      localStoreReady = content?.id === prdRef && content?.kind === "prd";
-    } catch {
-      localStoreReady = false;
-    }
-  }
-  if (existsSync14(localStoreDir) && !localStoreReady) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Local PRD Run Store not ready for ${prdRef}. Expected valid prd.json at .pourkit/local-prd-runs/${prdRef}/prd.json with matching PRD ID. Ensure Local PRD Run Store is initialized before starting.`,
-      diagnostics: [
-        `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
-        `Expected PRD ID: ${prdRef}`
-      ],
-      offendingPaths: []
-    };
-  }
-  return { ok: true };
-}
-function buildStartReceipt(options) {
-  return {
-    status: options.status,
-    targetName: options.targetName,
-    prdBranch: options.prdBranch,
-    startBaseBranch: options.startBaseBranch,
-    startBaseCommit: options.startBaseCommit,
-    branchAction: options.branchAction,
-    startedAt: options.startedAt,
-    refreshReceipts: []
-  };
-}
-function canRetryFinalReviewBlock(record) {
-  if (record.status !== "blocked" || record.blockedGate !== "final-review") {
-    return false;
-  }
-  if (record.start?.queueDrainedAt || record.finalReview) {
-    return true;
-  }
-  return Boolean(
-    record.start && !record.blockedReason?.includes("not drained")
-  );
-}
-function loadFinalReviewPrompt(repoRoot2, promptTemplate) {
-  const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  return existsSync14(promptPath) ? readFileSync15(promptPath, "utf-8") : promptTemplate;
-}
-function buildFinalReviewPrompt(options) {
-  return [
-    "# Active PRD Final Review Context",
-    "",
-    `Worktree checkout base: ${options.evidencePacket.prdBranch}`,
-    `Review only this range: ${options.evidencePacket.mergeBase}..HEAD`,
-    "Do not compare against current target branch HEAD; the merge base is the review baseline.",
-    `Before handoff, run: pourkit validate-artifact final-review .pourkit/final-review-artifact.json --prd-ref ${options.evidencePacket.prdRef} --checkout-base ${options.evidencePacket.prdBranch} --review-base ${options.evidencePacket.mergeBase}`,
-    "Fix any validation failures before handing off.",
-    "",
-    "## Verification",
-    "",
-    `Run this command before handoff when retouch changes are made: pourkit run-verification --target ${options.targetName}`,
-    "",
-    "Evidence Packet (do not infer PRD context from local state files):",
-    JSON.stringify(options.evidencePacket, null, 2),
-    "",
-    loadFinalReviewPrompt(options.repoRoot, options.promptTemplate)
-  ].join("\n");
-}
-function buildRetouchBranchName(prdRef) {
-  return `prd-run/${prdRef}-final-review-retouch`;
-}
-function buildFinalReviewBranchName(prdRef) {
-  return `pourkit/${normalizePrdRunRef(prdRef).toLowerCase()}-final-review`;
-}
-function finalReviewWorktreePath(repoRoot2, branchName) {
-  return join18(
-    repoRoot2,
-    ".sandcastle",
-    "worktrees",
-    branchName.replace(/\//g, "-")
-  );
-}
-function collectSpawnDiagnostics(result, fallback) {
-  const diagnostics = [];
-  const stderr = result.stderr?.toString?.().trim();
-  const stdout = result.stdout?.toString?.().trim();
-  if (stderr) diagnostics.push(stderr);
-  if (stdout) diagnostics.push(stdout);
-  return diagnostics.length > 0 ? diagnostics : [fallback];
-}
-function listFinalReviewChangedPaths(worktreePath, mergeBase) {
-  const paths = /* @__PURE__ */ new Set();
-  const addPath = (path9) => {
-    if (path9 === ".pourkit/final-review-artifact.json" || path9 === ".pourkit/final-review-pr-artifact.json" || path9 === ".pourkit/.tmp/finalizer/agent-output.md") {
-      return;
-    }
-    paths.add(path9);
-  };
-  const diffResult = spawnSync3(
-    "git",
-    ["diff", "--name-only", mergeBase, "--", "."],
-    {
-      cwd: worktreePath,
-      encoding: "utf8"
-    }
-  );
-  for (const path9 of diffResult.stdout.split(/\r?\n/).filter(Boolean)) {
-    addPath(path9);
-  }
-  const statusResult = spawnSync3(
-    "git",
-    ["status", "--porcelain", "--untracked-files=all"],
-    {
-      cwd: worktreePath,
-      encoding: "utf8"
-    }
-  );
-  if (statusResult.status === 0) {
-    for (const line of statusResult.stdout.split(/\r?\n/)) {
-      const parsed = parseGitStatusLine(line);
-      if (parsed) addPath(parsed.path);
-    }
-  }
-  return [...paths];
-}
-function buildFinalReviewFinalizerPrompt(options) {
-  const promptPath = resolvePromptTemplatePath(
-    options.repoRoot,
-    options.promptTemplate
-  );
-  const promptBody = existsSync14(promptPath) ? readFileSync15(promptPath, "utf-8") : options.promptTemplate;
-  return [
-    "# Final Review Retouch PR Finalizer",
-    "",
-    "Write a human-facing retouch PR title and body for this Final Review result.",
-    "Write the artifact using the standard finalizer protocol:",
-    "",
-    "## PR Title",
-    "",
-    "<one conventional PR title>",
-    "",
-    "## PR Body",
-    "",
-    "<PR body>",
-    "Do not edit implementation files.",
-    "",
-    `PRD ref: ${options.prdRef}`,
-    `PRD branch: ${options.prdBranch}`,
-    `Review base: ${options.mergeBase}`,
-    "",
-    "Final Review summary:",
-    options.summary,
-    "",
-    "Changed paths:",
-    ...options.changedPaths.map((p) => `- ${p}`),
-    "",
-    promptBody
-  ].join("\n");
-}
-async function runFinalReviewPrFinalizer(options) {
-  const finalizer = options.target.strategy.finalize.prDescriptionAgent;
-  const artifactPathInWorktree = join18(
-    ".pourkit",
-    ".tmp",
-    "finalizer",
-    "agent-output.md"
-  );
-  try {
-    const result = await runEffectAndMapExit(
-      runPrDescriptionFinalizerCore({
-        executionProvider: options.executionProvider,
-        config: options.config,
-        target: options.target,
-        finalizer,
-        maxAttempts: options.target.strategy.finalize.maxAttempts,
-        prompt: buildFinalReviewFinalizerPrompt({
-          repoRoot: options.repoRoot,
-          promptTemplate: finalizer.promptTemplate,
-          prdRef: options.prdRef,
-          prdBranch: options.prdBranch,
-          mergeBase: options.mergeBase,
-          summary: options.summary,
-          changedPaths: options.changedPaths
-        }),
-        branchName: options.branchName,
-        repoRoot: options.repoRoot,
-        worktreePath: options.worktreePath,
-        artifactPathInWorktree,
-        commitSummaries: "",
-        baseRef: options.prdBranch,
-        checkoutBase: options.prdBranch,
-        reviewBase: options.mergeBase,
-        logger: options.logger
-      })
-    );
-    return { ok: true, ...result };
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    return { ok: false, reason, diagnostics: [reason] };
-  }
-}
-async function lookupMergedPr(prProvider, pr) {
-  const byBranch = await prProvider.getPr(pr.headRefName);
-  if (byBranch?.state === "MERGED" && byBranch.mergeCommitSha) {
-    return byBranch;
-  }
-  const byNumber = await getPrByNumberIfAvailable(prProvider, pr.number);
-  if (byNumber?.state === "MERGED" && byNumber.mergeCommitSha) {
-    return byNumber;
-  }
-  return byBranch ?? byNumber;
-}
-async function getPrByNumberIfAvailable(prProvider, prNumber) {
-  if (!prProvider.getPrByNumber) return null;
-  return await prProvider.getPrByNumber(prNumber);
-}
-function ensureFinalReviewWorktree(options) {
-  const worktreePath = finalReviewWorktreePath(
-    options.repoRoot,
-    options.branchName
-  );
-  const listResult = spawnSync3("git", ["worktree", "list", "--porcelain"], {
-    cwd: options.repoRoot,
-    encoding: "utf8"
-  });
-  if (listResult.status !== 0) {
-    return {
-      ok: false,
-      reason: "Final Review failed to list git worktrees.",
-      diagnostics: collectSpawnDiagnostics(
-        listResult,
-        "git worktree list failed"
-      )
-    };
-  }
-  const registeredPath = parseWorktreeListPorcelain(
-    listResult.stdout?.toString?.() ?? "",
-    options.branchName
-  );
-  if (registeredPath) {
-    if (registeredPath !== worktreePath) {
-      return {
-        ok: false,
-        reason: `Final Review branch ${options.branchName} already has a registered worktree outside .sandcastle/worktrees.`,
-        diagnostics: [`registered worktree: ${registeredPath}`]
-      };
-    }
-    return { ok: true, worktreePath: registeredPath };
-  }
-  if (existsSync14(worktreePath)) {
-    return {
-      ok: false,
-      reason: "Final Review worktree path exists but is not registered with git.",
-      diagnostics: [`stale worktree path: ${worktreePath}`]
-    };
-  }
-  mkdirSync10(dirname4(worktreePath), { recursive: true });
-  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",
-    ["worktree", "add", worktreePath, options.branchName],
-    { cwd: options.repoRoot, encoding: "utf8" }
-  );
-  if (addResult.status !== 0) {
-    return {
-      ok: false,
-      reason: `Final Review failed to create worktree for ${options.branchName}.`,
-      diagnostics: collectSpawnDiagnostics(
-        addResult,
-        "git worktree add failed"
-      )
-    };
-  }
-  return { ok: true, worktreePath };
-}
-function buildRetouchPrTitle(prdRef) {
-  return `chore: ${prdRef} Final Review retouch`;
-}
-function buildRetouchPrBody(options) {
-  return [
-    `# ${options.prdRef}: Final Review Retouch`,
-    "",
-    `Retouch PR for ${options.prdRef} Final Review.`,
-    "",
-    "## Summary",
-    "",
-    options.summary,
-    "",
-    "## Changed paths",
-    "",
-    ...options.changedPaths.map((p) => `- ${p}`)
-  ].join("\n");
-}
-async function createOrReuseFinalReviewRetouchPr(options) {
-  const prdRef = normalizePrdRunRef(options.prdRef);
-  const branchName = buildRetouchBranchName(options.prdRef);
-  const existingPr = await options.prProvider.getPr(branchName);
-  if (existingPr && existingPr.state === "OPEN") {
-    return existingPr;
-  }
-  const worktreePath = mkdtempSync(join18(tmpdir(), "pourkit-retouch-"));
-  try {
-    runGitOrThrow(
-      options.repoRoot,
-      ["fetch", "origin", prdRef],
-      `fetch origin/${prdRef}`
-    );
-    runGitOrThrow(
-      options.repoRoot,
-      ["worktree", "add", "--detach", worktreePath, `origin/${prdRef}`],
-      "create retouch worktree from PRD branch"
-    );
-    runGitOrThrow(
-      worktreePath,
-      ["checkout", "-B", branchName],
-      "create retouch branch"
-    );
-    for (const changedFile of options.changedPaths) {
-      const sourcePath = join18(options.sourceWorktreePath, changedFile);
-      const targetPath = join18(worktreePath, changedFile);
-      mkdirSync10(dirname4(targetPath), { recursive: true });
-      cpSync(sourcePath, targetPath, { recursive: true });
-    }
-    runGitOrThrow(
-      worktreePath,
-      ["add", "--", ...options.changedPaths],
-      "stage retouch diff"
-    );
-    runGitOrThrow(
-      worktreePath,
-      ["commit", "-m", `${branchName}: final review retouch`],
-      "commit retouch diff"
-    );
-  } finally {
-    spawnSync3("git", ["worktree", "remove", "--force", worktreePath], {
-      cwd: options.repoRoot,
-      encoding: "utf8"
-    });
-    rmSync3(worktreePath, { recursive: true, force: true });
-  }
-  const pushResult = spawnSync3(
-    "git",
-    ["push", "--force", "origin", `${branchName}:refs/heads/${branchName}`],
-    {
-      cwd: options.repoRoot,
-      encoding: "utf8"
-    }
-  );
-  if (pushResult.status !== 0) {
-    throw new Error(
-      `Failed to publish retouch branch ${branchName}: ${[
-        pushResult.error instanceof Error ? pushResult.error.message : void 0,
-        pushResult.stderr?.toString?.() ?? String(pushResult.stderr ?? ""),
-        pushResult.stdout?.toString?.() ?? String(pushResult.stdout ?? "")
-      ].filter((value) => Boolean(value && value.trim())).join(" ")}`
-    );
-  }
-  return options.prProvider.createPr({
-    base: prdRef,
-    head: branchName,
-    title: options.title ?? buildRetouchPrTitle(prdRef),
-    body: options.body ?? buildRetouchPrBody({
-      prdRef,
-      summary: options.summary,
-      changedPaths: options.changedPaths
-    })
-  });
-}
-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: normalizePrdRunRef(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 runPrdRunFinalReviewCommand(options) {
-  const prdRef = normalizePrdRunRef(options.prdRef);
-  const targetName = options.targetName.trim();
-  if (!targetName) {
-    throw new Error(
-      `Invalid target name "${options.targetName}". Expected a non-empty target name.`
-    );
-  }
-  const { record, diagnostics: readDiagnostics } = readPrdRun(
-    options.repoRoot,
-    prdRef
-  );
-  if (readDiagnostics.length > 0 && !record) {
-    const reason = `PRD Run ${prdRef} has a malformed record and cannot proceed to Final Review.`;
-    writePrdRunRecord(options.repoRoot, {
-      prdRef,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: readDiagnostics,
-      targetName,
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: readDiagnostics,
-      offendingPaths: []
-    };
-  }
-  if (!record) {
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: `PRD Run ${prdRef} does not exist. Run prd-run prepare/start/launch first.`,
-      diagnostics: [`No PRD Run record found for ${prdRef}`],
-      offendingPaths: []
-    };
-  }
-  if (record.status !== "drained" && !canRetryFinalReviewBlock(record)) {
-    const reason = `PRD Run ${prdRef} is not drained. Final Review requires status "drained", got "${record.status}".`;
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [`Current status: ${record.status}`],
-      targetName,
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [`Current status: ${record.status}`],
-      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 (record.mode !== "local" && !options.issueProvider) {
-    const reason = "Missing IssueProvider. Cannot validate child completeness.";
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: ["IssueProvider not provided."],
-      targetName,
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: ["IssueProvider not provided."],
-      offendingPaths: []
-    };
-  }
-  const completenessResult = record.mode === "local" ? {
-    ok: true,
-    diagnostics: []
-  } : await validateFinalReviewChildCompleteness(
-    prdRef,
-    record,
-    options.issueProvider
-  );
-  if (!completenessResult.ok) {
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: completenessResult.reason,
-      diagnostics: completenessResult.diagnostics,
-      targetName,
-      offendingPaths: completenessResult.offendingPaths
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: completenessResult.reason,
-      diagnostics: completenessResult.diagnostics,
-      offendingPaths: completenessResult.offendingPaths
-    };
-  }
-  const targetConfig = options.config ? resolveTarget(options.config, targetName) : null;
-  if (!options.executionProvider || !options.config || !options.logger) {
-    const reason = targetConfig?.strategy.prdRun?.finalReview ? `Missing ExecutionProvider, config, or logger for Final Review.` : "Final Review requires config with prdRun.finalReview, ExecutionProvider, and logger.";
-    const diagnostics = targetConfig?.strategy.prdRun?.finalReview ? ["ExecutionProvider, config, or logger not provided."] : [
-      "No prdRun.finalReview configured in target strategy or missing execution provider."
-    ];
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics,
-      targetName,
-      finalReview: {
-        status: "blocked",
-        targetName,
-        prdBranch: record.prdBranch ?? prdRef,
-        diagnostics,
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics,
-      offendingPaths: []
-    };
-  }
-  const finalReviewConfig = targetConfig.strategy.prdRun?.finalReview;
-  if (!finalReviewConfig) {
-    const reason = `Target "${targetName}" does not have prdRun.finalReview configured.`;
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      targetName,
-      finalReview: {
-        status: "blocked",
-        targetName,
-        prdBranch: record.prdBranch ?? prdRef,
-        diagnostics: [reason],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      offendingPaths: []
-    };
-  }
-  const isLocalMode = record.mode === "local";
-  let mergeBaseResult;
-  let prdBranch;
-  if (isLocalMode) {
-    prdBranch = getLocalPrdBranchName(prdRef);
-    mergeBaseResult = computeLocalFinalReviewMergeBase(
-      options.repoRoot,
-      prdBranch
-    );
-  } else {
-    prdBranch = record.prdBranch ?? prdRef;
-    const startBaseBranch = record.start?.startBaseBranch;
-    if (!startBaseBranch) {
-      const reason = `PRD Run ${prdRef} has a start receipt without startBaseBranch. This record predates target-owned PRD Run base branches and cannot proceed to Final Review.`;
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        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: []
-      };
-    }
-    mergeBaseResult = computeFinalReviewMergeBase(
-      options.repoRoot,
-      prdRef,
-      startBaseBranch
-    );
-  }
-  if (!mergeBaseResult.ok) {
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: mergeBaseResult.reason,
-      diagnostics: mergeBaseResult.diagnostics,
-      targetName,
-      finalReview: {
-        status: "blocked",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        diagnostics: mergeBaseResult.diagnostics,
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: mergeBaseResult.reason,
-      diagnostics: mergeBaseResult.diagnostics,
-      offendingPaths: []
-    };
-  }
-  let relatedIssues = [];
-  if (!isLocalMode && options.issueProvider) {
-    try {
-      const listed = await options.issueProvider.listRelatedIssues(prdRef);
-      relatedIssues = Array.isArray(listed) ? listed : [];
-    } catch {
-      relatedIssues = [];
-    }
-  }
-  const evidencePacket = buildEvidencePacket({
-    prdRef,
-    prdBranch,
-    mergeBase: mergeBaseResult.mergeBase,
-    planningManifestPath: `runtime:${prdRef}`,
-    planningManifestFacts: {
-      parentPrdIssueUrl: prdRef,
-      childIssueCount: relatedIssues.length
-    },
-    stage: "prdFinalReview",
-    stageReceipts: {
-      mergeBase: mergeBaseResult.mergeBase,
-      startBaseBranch: record.start?.startBaseBranch
-    }
-  });
-  const startReceipt = {
-    status: "started",
-    targetName,
-    prdBranch,
-    mergeBase: mergeBaseResult.mergeBase,
-    diagnostics: [],
-    reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writePrdRunRecord(options.repoRoot, {
-    ...record,
-    status: "running",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    targetName,
-    start: record.start,
-    finalReview: startReceipt
-  });
-  const finalReviewBranchName = isLocalMode ? `${prdBranch.replace(/\//g, "-")}-final-review-retouch` : buildFinalReviewBranchName(prdBranch);
-  const worktreeResult = ensureFinalReviewWorktree({
-    repoRoot: options.repoRoot,
-    branchName: finalReviewBranchName,
-    checkoutBase: prdBranch,
-    isLocal: isLocalMode
-  });
-  if (!worktreeResult.ok) {
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: worktreeResult.reason,
-      diagnostics: worktreeResult.diagnostics,
-      targetName,
-      start: record.start,
-      finalReview: {
-        ...startReceipt,
-        status: "blocked",
-        diagnostics: worktreeResult.diagnostics
-      }
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: worktreeResult.reason,
-      diagnostics: worktreeResult.diagnostics,
-      offendingPaths: []
-    };
-  }
-  const retryResult = await executeWithMissingOrEmptyArtifactRetry({
-    executionProvider: options.executionProvider,
-    missingOrEmptyRetries: resolveMissingOrEmptyOutputRetries(finalReviewConfig),
-    executionOptions: {
-      stage: "prdFinalReview",
-      agent: finalReviewConfig.agent,
-      model: finalReviewConfig.model,
-      variant: finalReviewConfig.variant,
-      env: finalReviewConfig.env,
-      prompt: buildFinalReviewPrompt({
-        repoRoot: options.repoRoot,
-        promptTemplate: finalReviewConfig.promptTemplate,
-        targetName,
-        evidencePacket
-      }),
-      target: targetConfig,
-      repoRoot: options.repoRoot,
-      branchName: finalReviewBranchName,
-      baseRef: prdBranch,
-      checkoutBase: prdBranch,
-      reviewBase: mergeBaseResult.mergeBase,
-      worktreePath: worktreeResult.worktreePath,
-      sandbox: options.config.sandbox,
-      artifactPath: ".pourkit/final-review-artifact.json",
-      logger: options.logger
-    }
-  });
-  const executionResult = retryResult.executionResult;
-  if (!executionResult.success) {
-    const reason = executionResult.error ?? "Final Review execution failed.";
-    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,
-        diagnostics: [reason],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      offendingPaths: []
-    };
-  }
-  if (retryResult.artifact._tag !== "content") {
-    const reason = retryResult.artifact._tag === "empty" ? "Final Review artifact is empty." : "Final Review artifact was not produced.";
-    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,
-        diagnostics: [reason],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      offendingPaths: []
-    };
-  }
-  const resolvedWorktreePath = executionResult.worktreePath;
-  const artifactPath = join18(
-    resolvedWorktreePath,
-    ".pourkit/final-review-artifact.json"
-  );
-  const artifactResult = parseFinalReviewArtifact(artifactPath);
-  if (!artifactResult.ok) {
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: artifactResult.reason,
-      diagnostics: artifactResult.diagnostics,
-      targetName,
-      finalReview: {
-        status: "blocked",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        diagnostics: artifactResult.diagnostics,
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: artifactResult.reason,
-      diagnostics: artifactResult.diagnostics,
-      offendingPaths: []
-    };
-  }
-  const semanticResult = validateFinalReviewArtifactSemanticIds(
-    artifactResult,
-    { prdRef, prdBranch, mergeBase: mergeBaseResult.mergeBase }
-  );
-  if (!semanticResult.ok) {
-    const diagnostics = semanticResult.errors.map(redactSensitiveValues);
-    const reason = "Final Review artifact has mismatched semantic IDs.";
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics,
-      targetName,
-      finalReview: {
-        status: "blocked",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        diagnostics,
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics,
-      offendingPaths: []
-    };
-  }
-  const { verdict, summary, diagnostics: artifactDiagnostics } = artifactResult;
-  if (verdict === "pass_no_changes") {
-    const reviewedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const receipt = {
-      status: "succeeded",
-      targetName,
-      prdBranch,
-      mergeBase: mergeBaseResult.mergeBase,
-      verdict: "pass_no_changes",
-      artifactPath: ".pourkit/final-review-artifact.json",
-      diagnostics: [],
-      reviewedAt
-    };
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "final_reviewed",
-      updatedAt: reviewedAt,
-      targetName,
-      start: record.start,
-      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",
-      finalReview: receipt,
-      diagnostics: []
-    };
-  }
-  if (verdict === "pass_with_retouch") {
-    if (!options.prProvider && !isLocalMode) {
-      const reason = "Missing PRProvider. Cannot create retouch PR without a PR provider.";
-      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: []
-      };
-    }
-    const autoMerge = options.autoMerge ?? true;
-    const existingRetouchPrNumber = !isLocalMode ? record.finalReview?.retouchPrNumber : void 0;
-    if (existingRetouchPrNumber && autoMerge) {
-      const existingPr = await getPrByNumberIfAvailable(
-        options.prProvider,
-        existingRetouchPrNumber
-      );
-      if (existingPr?.state === "MERGED" && existingPr.mergeCommitSha) {
-        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(),
-          retouchPrNumber: existingRetouchPrNumber,
-          retouchPrUrl: existingPr.url,
-          retouchMergeCommit: existingPr.mergeCommitSha,
-          autoMerge,
-          changedPaths: record.finalReview?.changedPaths ?? []
-        };
-        writePrdRunRecord(options.repoRoot, {
-          ...record,
-          status: "final_reviewed",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          targetName,
-          start: record.start,
-          finalReview: receipt2
-        });
-        return {
-          prdRef,
-          status: "final_reviewed",
-          finalReview: receipt2,
-          diagnostics: []
-        };
-      }
-    }
-    const changedPathsFromArtifact = artifactResult.changedPaths;
-    let resolvedChangedPaths = changedPathsFromArtifact && changedPathsFromArtifact.length > 0 ? changedPathsFromArtifact : listFinalReviewChangedPaths(
-      resolvedWorktreePath,
-      mergeBaseResult.mergeBase
-    );
-    const scopeResult = validateFinalReviewRetouchScope(resolvedChangedPaths);
-    if (!scopeResult.ok) {
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        blockedGate: "final-review",
-        blockedReason: scopeResult.reason,
-        diagnostics: scopeResult.diagnostics,
-        targetName,
-        finalReview: {
-          status: "blocked",
-          targetName,
-          prdBranch,
-          mergeBase: mergeBaseResult.mergeBase,
-          verdict: "pass_with_retouch",
-          diagnostics: scopeResult.diagnostics,
-          reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        offendingPaths: scopeResult.offendingPaths
-      });
-      return {
-        prdRef,
-        status: "blocked",
-        blockedGate: "final-review",
-        blockedReason: scopeResult.reason,
-        diagnostics: scopeResult.diagnostics,
-        offendingPaths: scopeResult.offendingPaths
-      };
-    }
-    const finalizerResult = await runFinalReviewPrFinalizer({
-      executionProvider: options.executionProvider,
-      config: options.config,
-      target: targetConfig,
-      repoRoot: options.repoRoot,
-      worktreePath: resolvedWorktreePath,
-      branchName: finalReviewBranchName,
-      prdRef,
-      prdBranch,
-      mergeBase: mergeBaseResult.mergeBase,
-      summary,
-      changedPaths: scopeResult.changedPaths,
-      logger: options.logger
-    });
-    if (!finalizerResult.ok) {
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        blockedGate: "final-review",
-        blockedReason: finalizerResult.reason,
-        diagnostics: finalizerResult.diagnostics,
-        targetName,
-        finalReview: {
-          status: "blocked",
-          targetName,
-          prdBranch,
-          mergeBase: mergeBaseResult.mergeBase,
-          verdict: "pass_with_retouch",
-          diagnostics: finalizerResult.diagnostics,
-          reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "blocked",
-        blockedGate: "final-review",
-        blockedReason: finalizerResult.reason,
-        diagnostics: finalizerResult.diagnostics,
-        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,
-        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({
-        repoRoot: options.repoRoot,
-        sourceWorktreePath: resolvedWorktreePath,
-        prdRef,
-        changedPaths: scopeResult.changedPaths,
-        summary,
-        title: finalizerResult.title,
-        body: finalizerResult.body,
-        prProvider: options.prProvider
-      });
-    } 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: `Failed to create retouch PR: ${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: `Failed to create retouch PR: ${msg}`,
-        diagnostics: [msg],
-        offendingPaths: []
-      };
-    }
-    if (!autoMerge) {
-      const receipt2 = {
-        status: "needs_human_review",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        verdict: "pass_with_retouch",
-        artifactPath: ".pourkit/final-review-artifact.json",
-        diagnostics: [],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        retouchPrNumber: retouchPr.number,
-        retouchPrUrl: retouchPr.url,
-        autoMerge: false,
-        changedPaths: scopeResult.changedPaths
-      };
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} created but auto-merge disabled. PRD Final Review will not advance until the PR is merged.`,
-        diagnostics: [
-          `Retouch PR #${retouchPr.number}: ${retouchPr.url}`,
-          "Auto-merge disabled. Merge the PR manually or rerun with auto-merge enabled."
-        ],
-        targetName,
-        finalReview: receipt2,
-        offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "needs_human_review",
-        finalReview: receipt2,
-        diagnostics: [
-          `Retouch PR #${retouchPr.number}: ${retouchPr.url}`,
-          "Auto-merge disabled. Merge the PR manually or rerun with auto-merge enabled."
-        ]
-      };
-    }
-    try {
-      await options.prProvider.waitForPrChecks(retouchPr.number);
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      const receipt2 = {
-        status: "started",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        verdict: "pass_with_retouch",
-        artifactPath: ".pourkit/final-review-artifact.json",
-        diagnostics: [msg],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        retouchPrNumber: retouchPr.number,
-        retouchPrUrl: retouchPr.url,
-        autoMerge: true,
-        changedPaths: scopeResult.changedPaths
-      };
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} checks failed: ${msg}`,
-        diagnostics: [msg],
-        targetName,
-        finalReview: receipt2,
-        offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "blocked",
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} checks failed: ${msg}`,
-        diagnostics: [msg],
-        offendingPaths: []
-      };
-    }
-    try {
-      await options.prProvider.mergePr(retouchPr.number, {
-        method: "squash"
-      });
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      const receipt2 = {
-        status: "started",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        verdict: "pass_with_retouch",
-        artifactPath: ".pourkit/final-review-artifact.json",
-        diagnostics: [msg],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        retouchPrNumber: retouchPr.number,
-        retouchPrUrl: retouchPr.url,
-        autoMerge: true,
-        changedPaths: scopeResult.changedPaths
-      };
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} merge failed: ${msg}`,
-        diagnostics: [msg],
-        targetName,
-        finalReview: receipt2,
-        offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "blocked",
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} merge failed: ${msg}`,
-        diagnostics: [msg],
-        offendingPaths: []
-      };
-    }
-    let mergedPr = null;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-      try {
-        const candidate = await lookupMergedPr(options.prProvider, retouchPr);
-        if (candidate?.state === "MERGED" && candidate.mergeCommitSha) {
-          mergedPr = candidate;
-          break;
-        }
-      } catch {
-      }
-      if (attempt < 2) {
-        await sleep(1e3);
-      }
-    }
-    const mergeCommitSha = mergedPr?.mergeCommitSha;
-    if (!mergeCommitSha) {
-      const receipt2 = {
-        status: "started",
-        targetName,
-        prdBranch,
-        mergeBase: mergeBaseResult.mergeBase,
-        verdict: "pass_with_retouch",
-        artifactPath: ".pourkit/final-review-artifact.json",
-        diagnostics: [
-          `Retouch PR #${retouchPr.number} merged but merge commit SHA not available.`
-        ],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        retouchPrNumber: retouchPr.number,
-        retouchPrUrl: retouchPr.url,
-        autoMerge: true,
-        changedPaths: scopeResult.changedPaths
-      };
-      writePrdRunRecord(options.repoRoot, {
-        ...record,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} merged without exposing a merge commit SHA.`,
-        diagnostics: [
-          `Retouch PR #${retouchPr.number} merged but merge commit SHA not available.`
-        ],
-        targetName,
-        finalReview: receipt2,
-        offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "blocked",
-        blockedGate: "final-review",
-        blockedReason: `Retouch PR #${retouchPr.number} merged without exposing a merge commit SHA.`,
-        diagnostics: [
-          `Retouch PR #${retouchPr.number} merged but merge commit SHA not available.`
-        ],
-        offendingPaths: []
-      };
-    }
-    const receipt = {
-      status: "final_reviewed",
-      targetName,
-      prdBranch,
-      mergeBase: mergeBaseResult.mergeBase,
-      verdict: "pass_with_retouch",
-      artifactPath: ".pourkit/final-review-artifact.json",
-      diagnostics: [],
-      reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      retouchPrNumber: retouchPr.number,
-      retouchPrUrl: retouchPr.url,
-      retouchMergeCommit: mergeCommitSha,
-      autoMerge: true,
-      changedPaths: scopeResult.changedPaths
-    };
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "final_reviewed",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetName,
-      start: record.start,
-      finalReview: receipt
-    });
-    return {
-      prdRef,
-      status: "final_reviewed",
-      finalReview: receipt,
-      diagnostics: []
-    };
-  }
-  if (verdict === "needs_human_review") {
-    const reason = summary || "Final Review requires human review.";
-    const receipt = {
-      status: "needs_human_review",
-      targetName,
-      prdBranch,
-      mergeBase: mergeBaseResult.mergeBase,
-      verdict: "needs_human_review",
-      artifactPath: ".pourkit/final-review-artifact.json",
-      diagnostics: artifactDiagnostics.length > 0 ? artifactDiagnostics : [reason],
-      reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      targetName,
-      finalReview: receipt,
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "needs_human_review",
-      finalReview: receipt,
-      diagnostics: [reason]
-    };
-  }
-  if (verdict === "blocked") {
-    const reason = summary || "Final Review blocked.";
-    const receipt = {
-      status: "blocked",
-      targetName,
-      prdBranch,
-      mergeBase: mergeBaseResult.mergeBase,
-      verdict: "blocked",
-      artifactPath: ".pourkit/final-review-artifact.json",
-      diagnostics: artifactDiagnostics.length > 0 ? artifactDiagnostics : [reason],
-      reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writePrdRunRecord(options.repoRoot, {
-      ...record,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      targetName,
-      finalReview: receipt,
-      offendingPaths: []
-    });
-    return {
-      prdRef,
-      status: "blocked",
-      blockedGate: "final-review",
-      blockedReason: reason,
-      diagnostics: [reason],
-      offendingPaths: []
-    };
-  }
-  const unsupportedReason = `Final Review returned unsupported verdict "${verdict}".`;
-  writePrdRunRecord(options.repoRoot, {
-    ...record,
-    status: "blocked",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    blockedGate: "final-review",
-    blockedReason: unsupportedReason,
-    diagnostics: [unsupportedReason],
-    targetName,
-    finalReview: {
-      status: "blocked",
-      targetName,
-      prdBranch,
-      mergeBase: mergeBaseResult.mergeBase,
-      diagnostics: [unsupportedReason],
-      reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    offendingPaths: []
+    }
+    logger.raw(`  Target: ${runResult.target.name}`);
+    return { selected, runResult };
   });
-  return {
-    prdRef,
-    status: "blocked",
-    blockedGate: "final-review",
-    blockedReason: unsupportedReason,
-    diagnostics: [unsupportedReason],
-    offendingPaths: []
-  };
 }
-function computeFinalReviewMergeBase(repoRoot2, prdRef, baseBranch) {
-  const normalized = normalizePrdRunRef(prdRef);
-  const fetchResult = spawnSync3(
-    "git",
-    ["fetch", "origin", baseBranch, normalized],
-    {
-      cwd: repoRoot2,
-      encoding: "utf8"
+function runQueue(options) {
+  return runOneQueueIssueEffect(options);
+}
+function runQueueLoopEffect(options, results) {
+  return Effect8.gen(function* () {
+    yield* reconcileBlockedEffect(options);
+    const outcome = yield* runOneQueueIssueEffect(options);
+    if (outcome.selected === null) {
+      return {
+        drained: true,
+        processedCount: results.length,
+        results,
+        selected: null,
+        reason: "Queue drained.",
+        code: "drained"
+      };
     }
-  );
-  const fetchDiagnostics = [];
-  if (fetchResult.status !== 0) {
-    const stderr = fetchResult.stderr?.toString?.() ?? "";
-    const stdout = fetchResult.stdout?.toString?.() ?? "";
-    if (stderr.trim()) fetchDiagnostics.push(stderr.trim());
-    if (stdout.trim()) fetchDiagnostics.push(stdout.trim());
-    return {
-      ok: false,
-      gate: "final-review",
-      reason: `Final Review failed to fetch origin/${baseBranch} and origin/${normalized}.`,
-      diagnostics: fetchDiagnostics.length > 0 ? fetchDiagnostics : ["git fetch failed"]
-    };
-  }
-  if (fetchResult.stderr?.toString?.()?.trim()) {
-    fetchDiagnostics.push(fetchResult.stderr.toString().trim());
-  }
-  const mergeBaseResult = spawnSync3(
-    "git",
-    ["merge-base", `origin/${baseBranch}`, `origin/${normalized}`],
-    {
-      cwd: repoRoot2,
-      encoding: "utf8"
+    const newResults = [...results, outcome];
+    const processedIssue = yield* Effect8.tryPromise({
+      try: () => options.issueProvider.fetchIssue(outcome.selected.number),
+      catch: (e) => {
+        if (e instanceof Error) {
+          return new QueueProviderError(e.message);
+        }
+        throw e;
+      }
+    });
+    if (processedIssue.state === "closed") {
+      yield* reconcileBlockedEffect(options);
     }
+    return yield* runQueueLoopEffect(options, newResults);
+  });
+}
+function runQueueLoop(options) {
+  return runQueueLoopEffect(options, []);
+}
+
+// commands/queue-run.ts
+async function runQueueCommand(options) {
+  initializeEffectRuntime();
+  const queueOptions = {
+    targetName: options.targetName,
+    config: options.config,
+    issueProvider: options.issueProvider,
+    prProvider: options.prProvider,
+    executionProvider: options.executionProvider,
+    force: options.force,
+    logger: options.logger,
+    repoRoot: options.repoRoot,
+    prdRef: options.prdRef,
+    queueRunContext: options.queueRunContext,
+    prdRunMode: options.queueRunContext?.prdRunMode
+  };
+  if (!options.loop) {
+    return runEffectAndMapExit(runQueue(queueOptions));
+  }
+  return runEffectAndMapExit(runQueueLoop(queueOptions));
+}
+
+// commands/prd-run.ts
+function planLaunchResume(record) {
+  if (!record) return { attempted: [], skipped: [], resumed: [] };
+  return pipe(
+    record,
+    Match.value,
+    Match.when({ status: "waiting_for_integration" }, () => ({
+      attempted: [],
+      skipped: ["start", "queue"],
+      resumed: []
+    })),
+    Match.when({ status: "completed_local_branch" }, () => ({
+      attempted: [],
+      skipped: ["start", "queue"],
+      resumed: []
+    })),
+    Match.when({ status: "complete" }, () => ({
+      attempted: [],
+      skipped: ["start", "queue"],
+      resumed: []
+    })),
+    Match.when({ status: "drained" }, () => ({
+      attempted: [],
+      skipped: ["start", "queue"],
+      resumed: []
+    })),
+    Match.when({ status: "final_reviewed" }, () => ({
+      attempted: [],
+      skipped: ["start", "queue"],
+      resumed: [],
+      blocked: "final_reviewed-incompatible"
+    })),
+    Match.when(
+      (value) => value.status === "blocked" && value.blockedGate === "final-review" && canRetryFinalReviewBlock(value),
+      () => ({
+        attempted: [],
+        skipped: ["start", "queue"],
+        resumed: []
+      })
+    ),
+    Match.when(
+      (value) => value.status === "starting" || value.status === "running" || value.status === "blocked" && (value.blockedGate === "queue" || value.blockedGate === "branch-state"),
+      (value) => value.start ? {
+        attempted: [],
+        skipped: [],
+        resumed: ["start"]
+      } : {
+        attempted: [],
+        skipped: ["start", "queue"],
+        resumed: [],
+        blocked: "missing-start-receipt"
+      }
+    ),
+    Match.orElse(() => ({
+      attempted: [],
+      skipped: [],
+      resumed: []
+    }))
   );
-  const mergeBaseDiagnostics = [];
-  if (mergeBaseResult.status !== 0) {
-    if (mergeBaseResult.stderr?.toString?.()?.trim()) {
-      mergeBaseDiagnostics.push(mergeBaseResult.stderr.toString().trim());
-    }
-    if (mergeBaseResult.stdout?.toString?.()?.trim()) {
-      mergeBaseDiagnostics.push(mergeBaseResult.stdout.toString().trim());
+}
+function validateLocalStartStore(repoRoot2, prdRef) {
+  const localStoreDir = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  let localStoreReady = false;
+  if (existsSync16(localStoreDir)) {
+    const localStorePath = join20(localStoreDir, "prd.json");
+    try {
+      const content = JSON.parse(readFileSync17(localStorePath, "utf8"));
+      localStoreReady = content?.id === prdRef && content?.kind === "prd";
+    } catch {
+      localStoreReady = false;
     }
-    return {
-      ok: false,
-      gate: "final-review",
-      reason: `Final Review merge-base computation failed for origin/${baseBranch} and origin/${normalized}.`,
-      diagnostics: mergeBaseDiagnostics.length > 0 ? mergeBaseDiagnostics : ["git merge-base returned non-zero exit status"]
-    };
   }
-  const mergeBase = mergeBaseResult.stdout?.toString?.()?.trim();
-  if (!mergeBase) {
+  if (existsSync16(localStoreDir) && !localStoreReady) {
     return {
       ok: false,
-      gate: "final-review",
-      reason: `Final Review merge-base returned empty result for origin/${baseBranch} and origin/${normalized}.`,
+      gate: "branch-state",
+      reason: `Local PRD Run Store not ready for ${prdRef}. Expected valid prd.json at .pourkit/local-prd-runs/${prdRef}/prd.json with matching PRD ID. Ensure Local PRD Run Store is initialized before starting.`,
       diagnostics: [
-        `merge-base stdout was empty for origin/${baseBranch}..origin/${normalized}`
-      ]
+        `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
+        `Expected PRD ID: ${prdRef}`
+      ],
+      offendingPaths: []
     };
   }
-  return { ok: true, mergeBase, diagnostics: fetchDiagnostics };
+  return { ok: true };
 }
-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"]
-    };
+function buildStartReceipt(options) {
+  return {
+    status: options.status,
+    targetName: options.targetName,
+    prdBranch: options.prdBranch,
+    startBaseBranch: options.startBaseBranch,
+    startBaseCommit: options.startBaseCommit,
+    branchAction: options.branchAction,
+    startedAt: options.startedAt,
+    refreshReceipts: []
+  };
+}
+function canRetryFinalReviewBlock(record) {
+  if (record.status !== "blocked" || record.blockedGate !== "final-review") {
+    return false;
   }
-  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}`]
-    };
+  if (record.start?.queueDrainedAt || record.finalReview) {
+    return true;
   }
-  return { ok: true, mergeBase, diagnostics: [] };
+  return Boolean(
+    record.start && !record.blockedReason?.includes("not drained")
+  );
 }
 async function runPrdRunLaunchCommand(options) {
   const prdRef = normalizePrdRunRef(options.prdRef);
@@ -10670,7 +9333,7 @@ async function runPrdRunLaunchCommand(options) {
       prdRef,
       status: "blocked",
       attempted: [],
-      skipped: ["start", "queue", "final-review"],
+      skipped: ["start", "queue"],
       resumed: [],
       diagnostics: [
         `Recorded mode: ${existingRecord.record.mode}`,
@@ -10699,6 +9362,21 @@ async function runPrdRunLaunchCommand(options) {
       offendingPaths: []
     };
   }
+  if (plan.blocked === "final_reviewed-incompatible") {
+    return {
+      prdRef,
+      status: "blocked",
+      attempted: [],
+      skipped: [],
+      resumed: [],
+      diagnostics: [
+        `PRD Run ${prdRef} has obsolete status "final_reviewed". PRD-wide Final Review has been removed from the launch lifecycle.`
+      ],
+      blockedGate: "final-review",
+      blockedReason: `PRD Run ${prdRef} has status "final_reviewed", which is no longer a valid launch status. PRD-wide Final Review has been removed from the launch lifecycle. Update the PRD Run state to "drained" and rerun launch, or start a new PRD Run.`,
+      offendingPaths: []
+    };
+  }
   if (existingRecord.record?.status === "waiting_for_integration" || existingRecord.record?.status === "complete" || existingRecord.record?.status === "completed_local_branch") {
     return {
       prdRef,
@@ -10727,10 +9405,7 @@ async function runPrdRunLaunchCommand(options) {
       adoptExistingBranch: options.adoptExistingBranch,
       baseBranchOverride: options.baseBranchOverride
     });
-    const skippedAfterStart = [
-      "queue",
-      "final-review"
-    ];
+    const skippedAfterStart = ["queue"];
     if (startResult.status === "blocked") {
       return {
         prdRef,
@@ -10759,92 +9434,14 @@ async function runPrdRunLaunchCommand(options) {
     diagnostics.push(...startResult.diagnostics);
     attempted.push("queue");
   }
-  let finalReviewResult;
-  if (!skipped.includes("final-review")) {
-    attempted.push("final-review");
-    if (existingRecord.record?.mode === "local") {
-      const runnableIssues = await getRunnableLocalIssues(
-        prdRef,
-        options.repoRoot
-      );
-      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: ["start", "queue"],
-          resumed,
-          diagnostics: [reason],
-          blockedGate: "final-review",
-          blockedReason: reason,
-          offendingPaths: [],
-          start: startResult,
-          finalReview: {
-            prdRef,
-            status: "blocked",
-            blockedGate: "final-review",
-            blockedReason: reason,
-            diagnostics: [reason],
-            offendingPaths: []
-          }
-        };
-      }
-    }
-    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("start") ? ["queue"] : []
-    ];
-    if (finalReviewResult.status === "blocked") {
-      return {
-        prdRef,
-        status: "blocked",
-        attempted,
-        skipped: skippedAfterFr,
-        resumed,
-        diagnostics: finalReviewResult.diagnostics,
-        blockedGate: "final-review",
-        blockedReason: finalReviewResult.blockedReason,
-        offendingPaths: finalReviewResult.offendingPaths,
-        start: startResult,
-        finalReview: finalReviewResult
-      };
-    }
-    if (finalReviewResult.status === "needs_human_review") {
-      return {
-        prdRef,
-        status: "blocked",
-        attempted,
-        skipped: skippedAfterFr,
-        resumed,
-        diagnostics: finalReviewResult.diagnostics,
-        blockedGate: "final-review",
-        blockedReason: finalReviewResult.finalReview.verdict ?? "needs_human_review",
-        offendingPaths: [],
-        start: startResult,
-        finalReview: finalReviewResult
-      };
-    }
-    diagnostics.push(...finalReviewResult.diagnostics);
-  }
   const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
-  const localStorePath = join18(
+  const localStorePath = join20(
     options.repoRoot,
     ".pourkit",
     "local-prd-runs",
     prdRef
   );
-  if (existsSync14(localStorePath)) {
+  if (existsSync16(localStorePath)) {
     writePrdRunRecord(options.repoRoot, {
       prdRef,
       status: "completed_local_branch",
@@ -10853,7 +9450,6 @@ async function runPrdRunLaunchCommand(options) {
       targetName: currentRecord?.targetName ?? options.targetName,
       prdBranch: currentRecord?.prdBranch ?? `local/${prdRef}`,
       start: currentRecord?.start,
-      finalReview: currentRecord?.finalReview,
       scopeChanges: currentRecord?.scopeChanges
     });
     return {
@@ -10866,8 +9462,7 @@ async function runPrdRunLaunchCommand(options) {
       diagnostics: [
         `Local PRD Run ${prdRef} completed. Branch: local/${prdRef}.`
       ],
-      start: startResult,
-      finalReview: finalReviewResult
+      start: startResult
     };
   }
   writePrdRunRecord(options.repoRoot, {
@@ -10877,7 +9472,6 @@ async function runPrdRunLaunchCommand(options) {
     targetName: currentRecord?.targetName ?? options.targetName,
     prdBranch: currentRecord?.prdBranch,
     start: currentRecord?.start,
-    finalReview: currentRecord?.finalReview,
     scopeChanges: currentRecord?.scopeChanges
   });
   return {
@@ -10889,8 +9483,7 @@ async function runPrdRunLaunchCommand(options) {
     diagnostics: [
       `Integration Gate is not implemented. PRD Run is waiting for manual integration back to ${currentRecord?.start?.startBaseBranch ?? "(missing startBaseBranch)"}.`
     ],
-    start: startResult,
-    finalReview: finalReviewResult
+    start: startResult
   };
 }
 async function runPrdRunStartCommand(options) {
@@ -11358,8 +9951,8 @@ async function processStartResult(startResult, options) {
     start,
     mode: modeForRecord
   });
-  const localStorePath = join18(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
-  if (existsSync14(localStorePath)) {
+  const localStorePath = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  if (existsSync16(localStorePath)) {
     const queueResult = await runLocalQueueLoop(
       prdRef,
       repoRoot2,
@@ -11787,18 +10380,6 @@ async function ensurePrdBranchPublished(repoRoot2, prdRef, startBaseCommit) {
     );
   }
 }
-function runGitOrThrow(cwd, args, label) {
-  const result = spawnSync3("git", args, { cwd, encoding: "utf8" });
-  if (result.status !== 0) {
-    throw new Error(
-      `Failed to ${label}: ${[
-        result.error instanceof Error ? result.error.message : void 0,
-        result.stderr?.toString?.() ?? String(result.stderr ?? ""),
-        result.stdout?.toString?.() ?? String(result.stdout ?? "")
-      ].filter((value) => Boolean(value && value.trim())).join(" ")}`
-    );
-  }
-}
 function runPrdRunStatusCommand(options) {
   const prdRef = normalizePrdRunRef(options.prdRef);
   const { record, diagnostics } = readPrdRun(options.repoRoot, prdRef);
@@ -11847,13 +10428,6 @@ function buildBlockedStartResult(prdRef, failure, manifestPath) {
     offendingPaths: failure.offendingPaths.length > 0 ? failure.offendingPaths : manifestPath ? [manifestPath] : []
   };
 }
-function parseGitStatusLine(line) {
-  if (!line.trim()) return null;
-  const status = line.slice(0, 2);
-  const rawPath = line.slice(3).trim();
-  const path9 = rawPath.includes(" -> ") ? rawPath.split(" -> ").pop() : rawPath;
-  return { status, path: path9.replace(/^"|"$/g, "") };
-}
 
 // commands/pr-create.ts
 init_common();
@@ -12256,7 +10830,7 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
 }
 
 // commands/init.ts
-import { existsSync as existsSync15, statSync } from "fs";
+import { existsSync as existsSync17, statSync } from "fs";
 import {
   copyFile,
   mkdir as mkdir5,
@@ -12759,7 +11333,7 @@ async function computeFileChecksum(filePath) {
   return createHash3("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
-  return existsSync15(path5.join(root, name));
+  return existsSync17(path5.join(root, name));
 }
 function detectPackageManager(root) {
   if (lockfileExists(root, "pnpm-lock.yaml")) return "pnpm";
@@ -12803,7 +11377,7 @@ async function discoverLocalSource(sourcePath) {
 async function discoverReadme(root) {
   for (const name of ["README.md", "readme.md"]) {
     const p = path5.join(root, name);
-    if (existsSync15(p)) {
+    if (existsSync17(p)) {
       return p;
     }
   }
@@ -12813,7 +11387,7 @@ async function discoverAgentFiles(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md"]) {
     const p = path5.join(root, name);
-    if (existsSync15(p)) {
+    if (existsSync17(p)) {
       files.push(p);
     }
   }
@@ -12821,7 +11395,7 @@ async function discoverAgentFiles(root) {
 }
 async function discoverMerlleState(root) {
   const p = path5.join(root, ".pourkit", "state.json");
-  return existsSync15(p) ? p : null;
+  return existsSync17(p) ? p : null;
 }
 async function discoverAgentSkills(root) {
   const dirs = [
@@ -12830,7 +11404,7 @@ async function discoverAgentSkills(root) {
   ];
   const found = [];
   for (const d of dirs) {
-    if (existsSync15(d)) {
+    if (existsSync17(d)) {
       found.push(d);
     }
   }
@@ -12840,12 +11414,12 @@ async function discoverRootDomainDocs(root) {
   const docs = [];
   for (const name of ["CONTEXT.md", "CONTEXT-MAP.md"]) {
     const p = path5.join(root, name);
-    if (existsSync15(p)) {
+    if (existsSync17(p)) {
       docs.push(p);
     }
   }
   const adrDir = path5.join(root, "docs", "adr");
-  if (existsSync15(adrDir)) {
+  if (existsSync17(adrDir)) {
     const entries = await readdir(adrDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -12988,7 +11562,7 @@ async function planInit(options) {
       for (const file of skillFiles) {
         const relPath = path5.relative(s, file);
         const destPath = path5.join(targetRoot, ".agents", "skills", relPath);
-        if (!existsSync15(destPath)) {
+        if (!existsSync17(destPath)) {
           operations.push({
             kind: "copy",
             sourcePath: file,
@@ -13051,7 +11625,7 @@ async function planInit(options) {
     });
   }
   if (sourceRoot) {
-    if (!existsSync15(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
+    if (!existsSync17(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
       warnings.push(
         `--from-local path does not exist or is not a directory: ${sourceRoot}`
       );
@@ -13170,7 +11744,7 @@ async function planInit(options) {
             requiresConfirmation: false,
             destructive: false
           });
-        } else if (existsSync15(destPath)) {
+        } else if (existsSync17(destPath)) {
           operations.push({
             kind: "skip",
             path: destPath,
@@ -13228,7 +11802,7 @@ async function planInit(options) {
         }
       }
       const contextPath = path5.join(targetRoot, ".pourkit", "CONTEXT.md");
-      if (!existsSync15(contextPath) && !merleDestPaths.has(contextPath)) {
+      if (!existsSync17(contextPath) && !merleDestPaths.has(contextPath)) {
         operations.push({
           kind: "create",
           path: contextPath,
@@ -13246,7 +11820,7 @@ async function planInit(options) {
         "adr",
         ".gitkeep"
       );
-      if (!existsSync15(adrGitkeep)) {
+      if (!existsSync17(adrGitkeep)) {
         operations.push({
           kind: "create",
           path: adrGitkeep,
@@ -13258,7 +11832,7 @@ async function planInit(options) {
       }
       const srcDocAgents = path5.join(sourceRoot, ".pourkit", "docs", "agents");
       const tgtDocAgents = path5.join(targetRoot, ".pourkit", "docs", "agents");
-      if (existsSync15(srcDocAgents) && !existsSync15(tgtDocAgents)) {
+      if (existsSync17(srcDocAgents) && !existsSync17(tgtDocAgents)) {
         const docFiles = await walkDir(srcDocAgents);
         for (const file of docFiles) {
           const relPath = path5.relative(srcDocAgents, file);
@@ -13291,7 +11865,7 @@ async function planInit(options) {
       }
       const srcPrompts = path5.join(sourceRoot, ".pourkit", "prompts");
       const tgtPrompts = path5.join(targetRoot, ".pourkit", "prompts");
-      if (existsSync15(srcPrompts) && !existsSync15(tgtPrompts)) {
+      if (existsSync17(srcPrompts) && !existsSync17(tgtPrompts)) {
         const promptFiles = await walkDir(srcPrompts);
         for (const file of promptFiles) {
           const relPath = path5.relative(srcPrompts, file);
@@ -13318,7 +11892,7 @@ async function planInit(options) {
         ".sandcastle",
         "Dockerfile"
       );
-      if (existsSync15(tgtSandboxDockerfile)) {
+      if (existsSync17(tgtSandboxDockerfile)) {
         operations.push({
           kind: "skip",
           path: tgtSandboxDockerfile,
@@ -13327,7 +11901,7 @@ async function planInit(options) {
           requiresConfirmation: false,
           destructive: false
         });
-      } else if (existsSync15(srcSandboxDockerfile)) {
+      } else if (existsSync17(srcSandboxDockerfile)) {
         const checksum = await computeFileChecksum(srcSandboxDockerfile);
         operations.push({
           kind: "copy",
@@ -13341,7 +11915,7 @@ async function planInit(options) {
         });
       }
       const configTsPath = path5.join(targetRoot, "pourkit.config.ts");
-      if (!existsSync15(configTsPath)) {
+      if (!existsSync17(configTsPath)) {
         const verifyCommands = inferVerificationCommands(
           packageScripts,
           pm || "npm"
@@ -13378,7 +11952,7 @@ async function planInit(options) {
       const hasExistingAgents = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("AGENTS.md")
       );
-      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync15(path5.join(targetRoot, "AGENTS.md"))) {
+      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync17(path5.join(targetRoot, "AGENTS.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "AGENTS.md"),
@@ -13394,7 +11968,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       const hasExistingClaude = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("CLAUDE.md")
       );
-      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync15(path5.join(targetRoot, "CLAUDE.md"))) {
+      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync17(path5.join(targetRoot, "CLAUDE.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "CLAUDE.md"),
@@ -13409,7 +11983,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       }
       const gitignoreTarget = path5.join(targetRoot, ".gitignore");
       const gitignoreContent = generateGitignoreBlock();
-      if (!existsSync15(gitignoreTarget)) {
+      if (!existsSync17(gitignoreTarget)) {
         operations.push({
           kind: "create",
           path: gitignoreTarget,
@@ -13433,7 +12007,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         });
       }
       const openCodePath = path5.join(targetRoot, "opencode.json");
-      if (!existsSync15(openCodePath)) {
+      if (!existsSync17(openCodePath)) {
         operations.push({
           kind: "create",
           path: openCodePath,
@@ -13490,7 +12064,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         }
       }
       const manifestPath = path5.join(targetRoot, ".pourkit", "manifest.json");
-      if (existsSync15(manifestPath)) {
+      if (existsSync17(manifestPath)) {
         operations.push({
           kind: "skip",
           path: manifestPath,
@@ -13809,7 +12383,7 @@ async function updateManagedBlock(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync15(filePath)) {
+  if (!existsSync17(filePath)) {
     const dir = path5.dirname(filePath);
     await mkdir5(dir, { recursive: true });
     await writeFileAtomic(filePath, blockContent);
@@ -13838,7 +12412,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     if (op.requiresConfirmation) continue;
     const relPath = path5.relative(plan.targetRoot, op.path);
     if (relPath === ".pourkit/manifest.json") continue;
-    if (existsSync15(op.path)) {
+    if (existsSync17(op.path)) {
       const sha256 = await computeFileChecksum(op.path);
       assets[relPath] = {
         ownership: op.ownership || "managed",
@@ -13883,7 +12457,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync15(op.path) && !op.destructive) {
+          if (existsSync17(op.path) && !op.destructive) {
             skipped++;
             continue;
           }
@@ -13898,7 +12472,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync15(op.path)) {
+          if (existsSync17(op.path)) {
             skipped++;
             continue;
           }
@@ -13927,7 +12501,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync15(op.path)) {
+          if (existsSync17(op.path)) {
             skipped++;
             continue;
           }
@@ -14067,7 +12641,7 @@ async function applyInitFromSource(options) {
     if (!manifestSkipped) {
       const agentFiles = [];
       for (const name of ["AGENTS.md", "CLAUDE.md"]) {
-        if (existsSync15(path5.join(targetRoot, name))) {
+        if (existsSync17(path5.join(targetRoot, name))) {
           agentFiles.push(path5.join(targetRoot, name));
         }
       }
@@ -14499,6 +13073,7 @@ var GitHubIssueProvider = class {
     );
     return data.filter((issue) => !issue.pull_request).map((issue) => ({
       number: issue.number,
+      title: issue.title,
       body: issue.body ?? null,
       labels: issue.labels.map((l) => ({
         name: typeof l === "string" ? l : l.name ?? ""
@@ -14887,7 +13462,7 @@ init_common();
 
 // execution/sandcastle-execution.ts
 import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync8 } from "fs";
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
@@ -14896,10 +13471,10 @@ init_common();
 import { mkdtempSync as mkdtempSync2 } from "fs";
 import { writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname5, join as join19 } from "path";
+import { dirname as dirname5, join as join21 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join19(worktreePath, artifact.path);
+    const filePath = join21(worktreePath, artifact.path);
     await ensureDir(dirname5(filePath));
     await writeFile3(filePath, artifact.content, "utf-8");
   }
@@ -14911,17 +13486,17 @@ import path7 from "path";
 
 // execution/sandbox-image.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync18 } from "fs";
 import path6 from "path";
 function sandboxImageName(repoRoot2) {
   const dirName = path6.basename(repoRoot2.replace(/[\\/]+$/, "")) || "local";
   const sanitized = dirName.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
   const baseName = sanitized || "local";
   const dockerfilePath = path6.join(repoRoot2, ".sandcastle", "Dockerfile");
-  if (!existsSync16(dockerfilePath)) {
+  if (!existsSync18(dockerfilePath)) {
     return `sandcastle:${baseName}`;
   }
-  const fingerprint = createHash4("sha256").update(readFileSync16(dockerfilePath)).digest("hex").slice(0, 8);
+  const fingerprint = createHash4("sha256").update(readFileSync18(dockerfilePath)).digest("hex").slice(0, 8);
   return `sandcastle:${baseName}-${fingerprint}`;
 }
 
@@ -15217,12 +13792,12 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join20(repoRoot2, ".pourkit", ".tmp", "prompts");
+  const promptsDir = join22(repoRoot2, ".pourkit", ".tmp", "prompts");
   mkdirSync11(promptsDir, { recursive: true });
   const timestamp2 = Date.now();
   const iterationSuffix = iteration !== void 0 ? `-iteration-${iteration}` : "";
   const filename = `${stage}${iterationSuffix}-${timestamp2}.md`;
-  const filePath = join20(promptsDir, filename);
+  const filePath = join22(promptsDir, filename);
   writeFileSync8(filePath, prompt, "utf-8");
 }
 
@@ -15323,7 +13898,7 @@ function createCliProgram(version) {
   });
   program.command("validate-artifact").description("Validate an agent handoff artifact").argument(
     "<kind>",
-    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, final-review, failure-resolution, local-prd, local-issue, or local-triage"
+    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, final-review (retained for Issue Final Review validation), failure-resolution, local-prd, local-issue, local-triage, or issue-final-review"
   ).argument("<artifactPath>", "artifact path to validate").argument("[extraPaths...]", "additional artifact paths (for local-triage)").option("--iteration <number>", "review/refactor iteration", (value) => {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed < 1) {
@@ -15362,6 +13937,23 @@ function createCliProgram(version) {
   ).option(
     "--review-base <ref>",
     "review merge base for final-review artifacts"
+  ).option(
+    "--issue-number <number>",
+    "issue number for issue-final-review artifacts",
+    (value) => {
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new CommanderError(
+          1,
+          "ERR_INVALID_ARG_VALUE",
+          "--issue-number must be a positive integer"
+        );
+      }
+      return parsed;
+    }
+  ).option(
+    "--branch-name <name>",
+    "branch name for issue-final-review artifacts"
   ).option("--no-check-conflict-markers", "skip conflict marker scan").option("--cwd <path>", "target repository directory").action(
     (kind, artifactPath, extraPaths, options) => {
       const allowedKinds = /* @__PURE__ */ new Set([
@@ -15373,7 +13965,8 @@ function createCliProgram(version) {
         "failure-resolution",
         "local-prd",
         "local-issue",
-        "local-triage"
+        "local-triage",
+        "issue-final-review"
       ]);
       if (!allowedKinds.has(kind)) {
         throw new CommanderError(
@@ -15405,6 +13998,8 @@ function createCliProgram(version) {
         prdRef: options.prdRef,
         checkoutBase: options.checkoutBase,
         reviewBase: options.reviewBase,
+        issueNumber: options.issueNumber,
+        branchName: options.branchName,
         checkConflictMarkers: options.checkConflictMarkers
       });
       console.log(JSON.stringify(result, null, 2));
@@ -15886,11 +14481,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260613012953")) {
-    return "0.0.0-next-20260613012953";
+  if (isPackageVersion("0.0.0-next-20260613201753")) {
+    return "0.0.0-next-20260613201753";
   }
-  if (isReleaseVersion("0.0.0-next-20260613012953")) {
-    return "0.0.0-next-20260613012953";
+  if (isReleaseVersion("0.0.0-next-20260613201753")) {
+    return "0.0.0-next-20260613201753";
   }
   try {
     const root = repoRoot();