@pourkit/cli 0.0.0-next-20260614201555 → 0.0.0-next-20260615001408

package/dist/cli.js

@@ -3186,6 +3186,11 @@ function parseConflictResolutionArtifact(output) {
 
 // commands/artifact-validation.ts
 var CONFLICT_MARKER_PATTERN = /<<<<<<<|=======|>>>>>>>/m;
+var ISSUE_FINAL_REVIEW_SCOPE_VERDICTS = [
+  "in-scope",
+  "incidental",
+  "out-of-scope"
+];
 function invalid(options, reason, diagnostics = []) {
   return {
     ok: false,
@@ -3203,6 +3208,20 @@ function valid(options, diagnostics = []) {
     diagnostics
   };
 }
+function validateRepoRelativePathField(pathValue, fieldName) {
+  if (typeof pathValue !== "string") {
+    return { ok: false, reason: `${fieldName} must be a string` };
+  }
+  const normalized = pathValue.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  if (normalized.trim() === "" || normalized === "." || normalized === ".." || isAbsolute3(pathValue) || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+    return {
+      ok: false,
+      reason: `${fieldName} must not contain absolute paths or path traversal: ${pathValue}`
+    };
+  }
+  return { ok: true };
+}
 function readArtifact(options) {
   if (!existsSync7(options.artifactPath)) {
     return {
@@ -3271,27 +3290,142 @@ function validateIssueFinalReviewArtifact(parsed, options) {
     };
   }
   diagnostics.push("summary: present");
-  if (!Array.isArray(parsed.changedPaths) || !parsed.changedPaths.every((p) => typeof p === "string")) {
+  if (!Array.isArray(parsed.changedFiles)) {
+    return {
+      ok: false,
+      reason: "changedFiles must be an array",
+      diagnostics
+    };
+  }
+  const outOfScopeChangedFiles = [];
+  for (const [index, changedFile] of parsed.changedFiles.entries()) {
+    if (!changedFile || typeof changedFile !== "object") {
+      return {
+        ok: false,
+        reason: `changedFiles[${index}] must be an object`,
+        diagnostics
+      };
+    }
+    const file = changedFile;
+    const pathValidation = validateRepoRelativePathField(
+      file.path,
+      `changedFiles[${index}].path`
+    );
+    if (!pathValidation.ok) {
+      return { ok: false, reason: pathValidation.reason, diagnostics };
+    }
+    if (typeof file.change !== "string" || file.change.trim() === "") {
+      return {
+        ok: false,
+        reason: `changedFiles[${index}].change must be a non-empty string`,
+        diagnostics
+      };
+    }
+    if (!ISSUE_FINAL_REVIEW_SCOPE_VERDICTS.includes(file.scopeVerdict)) {
+      return {
+        ok: false,
+        reason: `changedFiles[${index}].scopeVerdict must be "in-scope", "incidental", or "out-of-scope"`,
+        diagnostics
+      };
+    }
+    if (typeof file.revertFlag !== "boolean") {
+      return {
+        ok: false,
+        reason: `changedFiles[${index}].revertFlag must be a boolean`,
+        diagnostics
+      };
+    }
+    if (file.scopeVerdict === "out-of-scope") {
+      outOfScopeChangedFiles.push(file.path);
+    }
+  }
+  diagnostics.push(
+    `changedFiles: ${parsed.changedFiles.length} files`
+  );
+  if (!Array.isArray(parsed.outOfScopeFiles) || !parsed.outOfScopeFiles.every((p) => typeof p === "string")) {
     return {
       ok: false,
-      reason: "changedPaths must be an array of strings",
+      reason: "outOfScopeFiles 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 === ".." || isAbsolute3(p) || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+  for (const p of parsed.outOfScopeFiles) {
+    const pathValidation = validateRepoRelativePathField(p, "outOfScopeFiles");
+    if (!pathValidation.ok) {
+      return { ok: false, reason: pathValidation.reason, diagnostics };
+    }
+  }
+  for (const p of outOfScopeChangedFiles) {
+    if (!parsed.outOfScopeFiles.includes(p)) {
       return {
         ok: false,
-        reason: `changedPaths must not contain absolute paths or path traversal: ${p}`,
+        reason: `outOfScopeFiles must include changedFiles path marked out-of-scope: ${p}`,
         diagnostics
       };
     }
   }
   diagnostics.push(
-    `changedPaths: ${parsed.changedPaths.length} paths`
+    `outOfScopeFiles: ${parsed.outOfScopeFiles.length} paths`
   );
+  if (!Array.isArray(parsed.badReverts)) {
+    return {
+      ok: false,
+      reason: "badReverts must be an array",
+      diagnostics
+    };
+  }
+  for (const [index, badRevert] of parsed.badReverts.entries()) {
+    if (typeof badRevert === "string") {
+      if (badRevert.trim() === "") {
+        return {
+          ok: false,
+          reason: `badReverts[${index}] must not be empty`,
+          diagnostics
+        };
+      }
+      continue;
+    }
+    if (!badRevert || typeof badRevert !== "object") {
+      return {
+        ok: false,
+        reason: `badReverts[${index}] must be a string or object`,
+        diagnostics
+      };
+    }
+    const entry = badRevert;
+    const pathValidation = validateRepoRelativePathField(
+      entry.path,
+      `badReverts[${index}].path`
+    );
+    if (!pathValidation.ok) {
+      return { ok: false, reason: pathValidation.reason, diagnostics };
+    }
+    const description = entry.hunk ?? entry.description;
+    if (typeof description !== "string" || description.trim() === "") {
+      return {
+        ok: false,
+        reason: `badReverts[${index}] must include a non-empty hunk or description`,
+        diagnostics
+      };
+    }
+  }
+  diagnostics.push(`badReverts: ${parsed.badReverts.length}`);
+  if (parsed.verdict === "pass") {
+    if (parsed.outOfScopeFiles.length > 0) {
+      return {
+        ok: false,
+        reason: "pass verdict requires outOfScopeFiles to be empty",
+        diagnostics
+      };
+    }
+    if (parsed.badReverts.length > 0) {
+      return {
+        ok: false,
+        reason: "pass verdict requires badReverts to be empty",
+        diagnostics
+      };
+    }
+  }
   if (typeof parsed.selfRetouched !== "boolean") {
     return {
       ok: false,
@@ -6054,7 +6188,7 @@ async function runIssueFinalReviewAgent(options) {
       verdict: "pass",
       artifactPath,
       selfRetouched: parsed.selfRetouched === true,
-      changedPaths: parsed.changedPaths,
+      changedPaths: extractChangedPaths(parsed),
       verificationPassed: parsed.verification?.passed === true
     };
   }
@@ -6064,13 +6198,18 @@ async function runIssueFinalReviewAgent(options) {
       artifactPath,
       needsHumanReason: parsed.needsHumanReason,
       selfRetouched: parsed.selfRetouched === true,
-      changedPaths: parsed.changedPaths
+      changedPaths: extractChangedPaths(parsed)
     };
   }
   throw new Error(
     `Unknown Issue Final Review verdict: ${JSON.stringify(verdict)}`
   );
 }
+function extractChangedPaths(parsed) {
+  return Array.isArray(parsed.changedFiles) ? parsed.changedFiles.map(
+    (file) => file && typeof file === "object" ? file.path : void 0
+  ).filter((path9) => typeof path9 === "string") : [];
+}
 function loadIssueFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
   const promptBody = existsSync11(promptPath) ? readFileSync13(promptPath, "utf-8") : promptTemplate;
@@ -6971,6 +7110,25 @@ async function completeIssueRun(options) {
           });
         }
       }
+      if (executionResult.worktreePath && !worktreeState?.pr?.issueFinalReviewSummaryCommented) {
+        const summary = readIssueFinalReviewSummary(
+          ifrState,
+          executionResult.worktreePath
+        );
+        if (summary) {
+          await prProvider.commentPr?.(
+            pr.number,
+            buildIssueFinalReviewPrComment(summary)
+          );
+          if (prProvider.commentPr) {
+            updateWorktreeRunState(executionResult.worktreePath, {
+              pr: {
+                issueFinalReviewSummaryCommented: true
+              }
+            });
+          }
+        }
+      }
       if (target.autoMerge === false) {
         await prProvider.waitForPrChecks(pr.number, checkWaitOptions);
         const transitions = makeIssueTransitions(issueProvider, config);
@@ -7124,6 +7282,19 @@ function extractHumanHandoffSummary(artifactContent) {
   }
   return summaryLines.join("\n").trim() || "(No Human Handoff Summary provided)";
 }
+function readIssueFinalReviewSummary(worktreeState, worktreePath) {
+  const configuredPath = worktreeState?.issueFinalReview?.artifactPath;
+  if (!configuredPath) {
+    return null;
+  }
+  const artifactPath = isAbsolute4(configuredPath) ? configuredPath : join15(worktreePath, configuredPath);
+  if (!existsSync12(artifactPath)) return null;
+  const parsed = JSON.parse(readFileSync14(artifactPath, "utf-8"));
+  return typeof parsed.summary === "string" && parsed.summary.trim() !== "" ? parsed.summary.trim() : null;
+}
+function buildIssueFinalReviewPrComment(summary) {
+  return ["## Issue Final Review", "", summary].join("\n");
+}
 function getRefactorArtifactDir(artifactPath) {
   return artifactPath.replace(/\/reviewers\//, "/refactors/").replace(/\/[^/]+$/, "");
 }
@@ -7900,10 +8071,8 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 }
 
 // commands/prd-run.ts
-import { existsSync as existsSync16, lstatSync, readFileSync as readFileSync18, realpathSync } from "fs";
-import { spawnSync as spawnSync3 } from "child_process";
-import { join as join19, relative as relative2 } from "path";
-import { Match, pipe } from "effect";
+import { lstatSync, realpathSync } from "fs";
+import { join as join20 } from "path";
 
 // prd-run/state.ts
 import {
@@ -8123,6 +8292,12 @@ function getRecordPath(repoRoot2, prdRef) {
   );
 }
 
+// prd-run/coordinator.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
+import { join as join19 } from "path";
+import { Match, pipe } from "effect";
+
 // prd-run/local-queue-loop.ts
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
 import { join as join18 } from "path";
@@ -8981,7 +9156,7 @@ function makeReconcileDeps(options) {
 }
 function reconcileBlockedEffect(options) {
   return Effect8.gen(function* () {
-    const blocked = yield* Effect8.tryPromise({
+    const blocked2 = yield* Effect8.tryPromise({
       try: () => options.issueProvider.listBlockedIssues(),
       catch: (e) => {
         if (e instanceof Error) {
@@ -8990,13 +9165,13 @@ function reconcileBlockedEffect(options) {
         throw e;
       }
     });
-    if (blocked.length > 0) {
+    if (blocked2.length > 0) {
       options.logger.step(
         "info",
-        `Reconciling ${blocked.length} blocked issue(s)`
+        `Reconciling ${blocked2.length} blocked issue(s)`
       );
       yield* Effect8.tryPromise({
-        try: () => reconcileBlockedIssues(blocked, makeReconcileDeps(options)),
+        try: () => reconcileBlockedIssues(blocked2, makeReconcileDeps(options)),
         catch: (e) => {
           if (e instanceof Error) {
             return new QueueProviderError(e.message);
@@ -9136,11 +9311,19 @@ async function runQueueCommand(options) {
   return runEffectAndMapExit(runQueueLoop(queueOptions));
 }
 
-// prd-run/final-review-validation.ts
-import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
-
-// commands/prd-run.ts
-function planLaunchResume(record) {
+// prd-run/coordinator.ts
+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 planPrdRunLaunchResume(record) {
   if (!record) return { attempted: [], skipped: [], resumed: [] };
   return pipe(
     record,
@@ -9167,7 +9350,7 @@ function planLaunchResume(record) {
     })),
     Match.when({ status: "final_reviewed" }, () => ({
       attempted: [],
-      skipped: ["start", "queue"],
+      skipped: [],
       resumed: [],
       blocked: "final_reviewed-incompatible"
     })),
@@ -9180,7 +9363,7 @@ function planLaunchResume(record) {
       })
     ),
     Match.when(
-      (value) => value.status === "starting" || value.status === "running" || value.status === "blocked" && (value.blockedGate === "queue" || value.blockedGate === "branch-state"),
+      (value) => value.status === "starting" || value.status === "running",
       (value) => value.start ? {
         attempted: [],
         skipped: [],
@@ -9192,6 +9375,27 @@ function planLaunchResume(record) {
         blocked: "missing-start-receipt"
       }
     ),
+    Match.when(
+      (value) => value.status === "blocked" && value.blockedGate === "branch-state",
+      () => ({
+        attempted: [],
+        skipped: [],
+        resumed: ["start"]
+      })
+    ),
+    Match.when(
+      (value) => value.status === "blocked" && value.blockedGate === "queue",
+      (value) => value.start ? {
+        attempted: [],
+        skipped: ["start"],
+        resumed: ["queue"]
+      } : {
+        attempted: [],
+        skipped: ["start", "queue"],
+        resumed: [],
+        blocked: "missing-start-receipt"
+      }
+    ),
     Match.orElse(() => ({
       attempted: [],
       skipped: [],
@@ -9199,19 +9403,109 @@ function planLaunchResume(record) {
     }))
   );
 }
+function resolvePrdRunBaseBranch(options) {
+  const raw = options.baseBranchOverride ?? options.targetBaseBranch;
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: value is empty after trimming.`,
+      diagnostics: [`Provided branch value: "${raw}"`],
+      offendingPaths: []
+    };
+  }
+  if (trimmed.startsWith("origin/")) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: "${trimmed}" must not include "origin/" prefix. Use just the branch lane name (e.g. "dev" instead of "origin/dev").`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  if (/^(refs\/|heads\/|remotes\/|tags\/)/.test(trimmed)) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: "${trimmed}" must be a simple branch lane name, not a ref specification.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  if (/^[0-9a-f]{7,40}$/i.test(trimmed)) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: value looks like a commit SHA rather than a branch lane name.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  const segments = trimmed.split("/");
+  for (const segment of segments) {
+    if (segment === "." || segment === ".." || segment === "") {
+      return {
+        ok: false,
+        gate: "branch-state",
+        reason: `Invalid PRD Run base branch: "${trimmed}" must not contain ".", "..", or empty segments.`,
+        diagnostics: [`Provided branch value: "${trimmed}"`],
+        offendingPaths: []
+      };
+    }
+  }
+  if (/[~^:?*\[\\]/.test(trimmed)) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: "${trimmed}" contains invalid characters (~ ^ : ? * [ \\).`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  if (/[\x00-\x1f\x7f]/.test(trimmed)) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: value contains control characters.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  if (trimmed.endsWith("/")) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with a trailing slash.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  if (trimmed.endsWith(".lock")) {
+    return {
+      ok: false,
+      gate: "branch-state",
+      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with ".lock" suffix.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
+  }
+  const source = options.baseBranchOverride !== void 0 ? "override" : "target";
+  return { ok: true, baseBranch: trimmed, source };
+}
 function validateLocalStartStore(repoRoot2, prdRef) {
   const localStoreDir = join19(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  const localStorePath = join19(localStoreDir, "prd.json");
   let localStoreReady = false;
-  if (existsSync16(localStoreDir)) {
-    const localStorePath = join19(localStoreDir, "prd.json");
+  if (existsSync15(localStorePath)) {
     try {
-      const content = JSON.parse(readFileSync18(localStorePath, "utf8"));
+      const content = JSON.parse(readFileSync17(localStorePath, "utf8"));
       localStoreReady = content?.id === prdRef && content?.kind === "prd";
     } catch {
       localStoreReady = false;
     }
   }
-  if (existsSync16(localStoreDir) && !localStoreReady) {
+  if (!localStoreReady) {
     return {
       ok: false,
       gate: "branch-state",
@@ -9225,213 +9519,178 @@ function validateLocalStartStore(repoRoot2, prdRef) {
   }
   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;
+function fetchOriginBranch(repoRoot2, baseBranch) {
+  const fetchResult = spawnSync3("git", ["fetch", "origin", baseBranch], {
+    cwd: repoRoot2,
+    encoding: "utf8"
+  });
+  if (fetchResult.status !== 0) {
+    return {
+      ok: false,
+      gate: "git",
+      reason: `PRD Run start failed while fetching origin/${baseBranch}.`,
+      diagnostics: [
+        fetchResult.error instanceof Error ? fetchResult.error.message : void 0,
+        fetchResult.stderr?.toString?.() ?? String(fetchResult.stderr ?? ""),
+        fetchResult.stdout?.toString?.() ?? String(fetchResult.stdout ?? "")
+      ].filter((value) => Boolean(value && value.trim())),
+      offendingPaths: []
+    };
   }
-  return Boolean(
-    record.start && !record.blockedReason?.includes("not drained")
-  );
-}
-async function runPrdRunLaunchCommand(options) {
-  const prdRef = normalizePrdRunRef(options.prdRef);
-  const attempted = [];
-  const skipped = [];
-  const resumed = [];
-  const diagnostics = [];
-  const existingRecord = readPrdRun(options.repoRoot, prdRef);
-  const resolvedLaunchMode = options.config ? (() => {
-    try {
-      const target = resolveTarget(options.config, options.targetName);
-      return resolvePrdRunMode(target).mode;
-    } catch {
-      return void 0;
+  const revParseResult = spawnSync3(
+    "git",
+    ["rev-parse", `origin/${baseBranch}`],
+    {
+      cwd: repoRoot2,
+      encoding: "utf8"
     }
-  })() : void 0;
-  if (resolvedLaunchMode && existingRecord.record?.mode && existingRecord.record.mode !== resolvedLaunchMode) {
+  );
+  if (revParseResult.status !== 0) {
     return {
-      prdRef,
-      status: "blocked",
-      attempted: [],
-      skipped: ["start", "queue"],
-      resumed: [],
+      ok: false,
+      gate: "git",
+      reason: `PRD Run start failed while resolving origin/${baseBranch}.`,
       diagnostics: [
-        `Recorded mode: ${existingRecord.record.mode}`,
-        `Resolved mode: ${resolvedLaunchMode}`
-      ],
-      blockedGate: "branch-state",
-      blockedReason: `PRD Run ${prdRef} mode mismatch: recorded "${existingRecord.record.mode}" but resolved "${resolvedLaunchMode}". Resolve by using the correct target.`,
+        revParseResult.error instanceof Error ? revParseResult.error.message : void 0,
+        revParseResult.stderr?.toString?.() ?? String(revParseResult.stderr ?? ""),
+        revParseResult.stdout?.toString?.() ?? String(revParseResult.stdout ?? "")
+      ].filter((value) => Boolean(value && value.trim())),
       offendingPaths: []
     };
   }
-  const plan = planLaunchResume(existingRecord.record);
-  skipped.push(...plan.skipped);
-  resumed.push(...plan.resumed);
-  if (plan.blocked === "missing-start-receipt") {
+  return { ok: true, startBaseCommit: revParseResult.stdout.trim() };
+}
+function inspectRemotePrdBranch(repoRoot2, prdRef) {
+  const result = spawnSync3("git", ["ls-remote", "--heads", "origin", prdRef], {
+    cwd: repoRoot2,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
     return {
-      prdRef,
-      status: "blocked",
-      attempted: [],
-      skipped,
-      resumed,
+      ok: false,
+      gate: "git",
+      reason: `PRD Run start failed while inspecting remote branch ${prdRef}.`,
       diagnostics: [
-        `PRD Run ${prdRef} is in status "${existingRecord.record?.status}" but has no start receipt.`
-      ],
-      blockedGate: "branch-state",
-      blockedReason: `PRD Run ${prdRef} is missing branch/start state. Run prd-run start or rerun prd-run launch.`,
+        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())),
       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: []
-    };
+  const headSha = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0]?.split(/\s+/)[0];
+  if (!headSha) {
+    return { ok: true, exists: false };
   }
-  if (existingRecord.record?.status === "completed_prd_branch" || existingRecord.record?.status === "complete" || existingRecord.record?.status === "completed_local_branch") {
+  return { ok: true, exists: true, headSha };
+}
+function fetchPrdBranch(repoRoot2, prdRef) {
+  const result = spawnSync3("git", ["fetch", "origin", prdRef], {
+    cwd: repoRoot2,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
     return {
-      prdRef,
-      status: existingRecord.record.status,
-      attempted,
-      skipped,
-      resumed,
+      ok: false,
+      gate: "git",
+      reason: `PRD Run start failed while fetching origin/${prdRef}.`,
       diagnostics: [
-        `PRD Run ${prdRef} is already in status "${existingRecord.record.status}".`,
-        ...existingRecord.record.status === "completed_prd_branch" ? [
-          buildCompletedPrdBranchHint(
-            existingRecord.record.prdBranch ?? prdRef
-          )
-        ] : []
-      ],
-      prdBranch: existingRecord.record.prdBranch
+        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())),
+      offendingPaths: []
     };
   }
-  let startResult;
-  if (!skipped.includes("start")) {
-    attempted.push("start");
-    startResult = await runPrdRunStartCommand({
-      repoRoot: options.repoRoot,
-      prdRef,
-      targetName: options.targetName,
-      config: options.config,
-      issueProvider: options.issueProvider,
-      prProvider: options.prProvider,
-      executionProvider: options.executionProvider,
-      logger: options.logger,
-      adoptExistingBranch: options.adoptExistingBranch,
-      baseBranchOverride: options.baseBranchOverride
-    });
-    const skippedAfterStart = ["queue"];
-    if (startResult.status === "blocked") {
-      return {
-        prdRef,
-        status: "blocked",
-        attempted,
-        skipped: skippedAfterStart,
-        resumed,
-        diagnostics: startResult.diagnostics,
-        blockedGate: startResult.blockedGate,
-        blockedReason: startResult.blockedReason,
-        offendingPaths: startResult.offendingPaths,
-        start: startResult
-      };
-    }
-    if (startResult.status === "starting") {
-      return {
-        prdRef,
-        status: "starting",
-        attempted,
-        skipped: skippedAfterStart,
-        resumed,
-        diagnostics: startResult.diagnostics,
-        start: startResult
-      };
+  return { ok: true };
+}
+async function ensurePrdBranchPublished(repoRoot2, prdRef, startBaseCommit) {
+  const pushResult = spawnSync3(
+    "git",
+    ["push", "origin", `${startBaseCommit}:refs/heads/${prdRef}`],
+    {
+      cwd: repoRoot2,
+      encoding: "utf8"
     }
-    diagnostics.push(...startResult.diagnostics);
-    attempted.push("queue");
-  }
-  const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
-  const localStorePath = join19(
-    options.repoRoot,
-    ".pourkit",
-    "local-prd-runs",
-    prdRef
   );
-  if (existsSync16(localStorePath)) {
-    writePrdRunRecord(options.repoRoot, {
-      prdRef,
-      status: "completed_local_branch",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      mode: "local",
-      targetName: currentRecord?.targetName ?? options.targetName,
-      prdBranch: currentRecord?.prdBranch ?? `local/${prdRef}`,
-      start: currentRecord?.start,
-      scopeChanges: currentRecord?.scopeChanges
-    });
-    return {
-      prdRef,
-      status: "completed_local_branch",
-      prdBranch: currentRecord?.prdBranch ?? `local/${prdRef}`,
-      attempted,
-      skipped,
-      resumed,
-      diagnostics: [
-        `Local PRD Run ${prdRef} completed. Branch: local/${prdRef}.`
-      ],
-      start: startResult
-    };
+  if (pushResult.status !== 0) {
+    throw new Error(
+      `Failed to create PRD Branch ${prdRef} from ${startBaseCommit}: ${[
+        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(" ")}`
+    );
   }
-  writePrdRunRecord(options.repoRoot, {
+}
+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 buildBlockedOutcome(repoRoot2, prdRef, guidance, targetName) {
+  writePrdRunRecord(repoRoot2, {
     prdRef,
-    status: "completed_prd_branch",
+    status: "blocked",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    targetName: currentRecord?.targetName ?? options.targetName,
-    prdBranch: currentRecord?.prdBranch,
-    start: currentRecord?.start,
-    scopeChanges: currentRecord?.scopeChanges
+    blockedGate: guidance.blockedGate,
+    blockedReason: guidance.reason,
+    diagnostics: [...guidance.diagnostics ?? []],
+    offendingPaths: [...guidance.offendingPaths ?? []],
+    targetName
   });
-  return {
+  return { kind: "blocked", prdRef, guidance };
+}
+function persistStartingPrdRunRecord(repoRoot2, prdRef, existingRecord, start, context) {
+  const {
+    blockedGate: _blockedGate,
+    blockedReason: _blockedReason,
+    diagnostics: _diagnostics,
+    offendingPaths: _offendingPaths,
+    prdBranch: _prdBranch,
+    start: _start,
+    ...cleanRecord
+  } = existingRecord.record ?? { prdRef };
+  writePrdRunRecord(repoRoot2, {
+    ...cleanRecord,
     prdRef,
-    status: "completed_prd_branch",
-    attempted,
-    skipped,
-    resumed,
-    diagnostics: [
-      buildCompletedPrdBranchHint(currentRecord?.prdBranch ?? prdRef)
-    ],
-    start: startResult,
-    prdBranch: currentRecord?.prdBranch ?? prdRef
-  };
+    status: "starting",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    targetName: context.targetName,
+    start,
+    mode: context.mode
+  });
 }
-async function runPrdRunStartCommand(options) {
+function blocked(repoRoot2, prdRef, gate, failureCode, reason, diagnostics, targetName) {
+  return buildBlockedOutcome(
+    repoRoot2,
+    prdRef,
+    {
+      blockedGate: gate,
+      failureCode,
+      reason,
+      diagnostics: diagnostics ? [...diagnostics] : [],
+      repairability: "operator-action"
+    },
+    targetName
+  );
+}
+async function startPrdRun(options) {
   const prdRef = normalizePrdRunRef(options.prdRef);
   const targetName = options.targetName.trim();
   if (!targetName) {
-    throw new Error(
+    return blocked(
+      options.repoRoot,
+      prdRef,
+      "branch-state",
+      "invalid_target_name",
       `Invalid target name "${options.targetName}". Expected a non-empty target name.`
     );
   }
@@ -9445,20 +9704,18 @@ async function runPrdRunStartCommand(options) {
     }
   })() : void 0;
   if (resolvedMode && existingRecord.record?.mode && existingRecord.record.mode !== resolvedMode) {
-    const failure = {
-      ok: false,
-      gate: "branch-state",
-      reason: `PRD Run ${prdRef} mode mismatch: recorded "${existingRecord.record.mode}" but resolved "${resolvedMode}". Resolve by using the correct target or --local-override.`,
-      diagnostics: [
+    return blocked(
+      options.repoRoot,
+      prdRef,
+      "branch-state",
+      "mode_mismatch",
+      `PRD Run ${prdRef} mode mismatch: recorded "${existingRecord.record.mode}" but resolved "${resolvedMode}". Resolve by using the correct target.`,
+      [
         `Recorded mode: ${existingRecord.record.mode}`,
         `Resolved mode: ${resolvedMode}`
       ],
-      offendingPaths: []
-    };
-    persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
       targetName
-    });
-    return buildBlockedStartResult(prdRef, failure);
+    );
   }
   const resolvedTarget = options.config ? resolveTarget(options.config, targetName) : null;
   const targetBaseBranch = resolvedTarget?.baseBranch ?? "main";
@@ -9467,57 +9724,75 @@ async function runPrdRunStartCommand(options) {
     baseBranchOverride: options.baseBranchOverride
   });
   if (!baseResolution.ok) {
-    persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, baseResolution, {
+    return blocked(
+      options.repoRoot,
+      prdRef,
+      baseResolution.gate,
+      "base_resolution_failed",
+      baseResolution.reason,
+      baseResolution.diagnostics,
       targetName
-    });
-    return buildBlockedStartResult(prdRef, baseResolution);
+    );
   }
   if (existingRecord.record?.start) {
     const recordedBaseBranch = existingRecord.record.start.startBaseBranch;
     if (!recordedBaseBranch) {
-      const failure = {
-        ok: false,
-        gate: "branch-state",
-        reason: `PRD Run ${prdRef} has a start receipt without startBaseBranch. Run prd-run start to create a fresh start receipt.`,
-        diagnostics: [
-          `Recorded start: ${JSON.stringify(existingRecord.record.start)}`
-        ],
-        offendingPaths: []
-      };
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        "branch-state",
+        "missing_start_base_branch",
+        `PRD Run ${prdRef} has a start receipt without startBaseBranch. Run prd-run start to create a fresh start receipt.`,
+        [`Recorded start: ${JSON.stringify(existingRecord.record.start)}`],
         targetName
-      });
-      return buildBlockedStartResult(prdRef, failure);
+      );
     }
     if (recordedBaseBranch !== baseResolution.baseBranch) {
-      const failure = {
-        ok: false,
-        gate: "branch-state",
-        reason: `PRD Run ${prdRef} start receipt records startBaseBranch "${recordedBaseBranch}" but current base resolution resolves to "${baseResolution.baseBranch}". Use --base with the matching value or create a fresh start receipt.`,
-        diagnostics: [
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        "branch-state",
+        "base_mismatch",
+        `PRD Run ${prdRef} start receipt records startBaseBranch "${recordedBaseBranch}" but current base resolution resolves to "${baseResolution.baseBranch}". Use --base with the matching value or create a fresh start receipt.`,
+        [
           `Recorded startBaseBranch: ${recordedBaseBranch}`,
           `Current base resolution: ${baseResolution.baseBranch} (source: ${baseResolution.source})`
         ],
-        offendingPaths: []
-      };
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
         targetName
-      });
-      return buildBlockedStartResult(prdRef, failure);
+      );
+    }
+    const currentStatus = existingRecord.record.status;
+    if (currentStatus === "running" || currentStatus === "drained" || currentStatus === "completed_prd_branch" || currentStatus === "completed_local_branch" || currentStatus === "complete") {
+      return {
+        kind: "started",
+        prdRef,
+        mode: resolvedMode,
+        start: existingRecord.record.start,
+        diagnostics: [],
+        preservedStatus: currentStatus
+      };
     }
     const fetchResult2 = fetchOriginBranch(options.repoRoot, recordedBaseBranch);
     if (!fetchResult2.ok) {
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, fetchResult2, {
-        targetName
-      });
-      return buildBlockedStartResult(prdRef, fetchResult2);
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        fetchResult2.gate,
+        "fetch_failed",
+        fetchResult2.reason,
+        fetchResult2.diagnostics
+      );
     }
     const branchResult2 = inspectRemotePrdBranch(options.repoRoot, prdRef);
     if (!branchResult2.ok) {
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, branchResult2, {
-        targetName
-      });
-      return buildBlockedStartResult(prdRef, branchResult2);
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        branchResult2.gate,
+        "branch_inspection_failed",
+        branchResult2.reason,
+        branchResult2.diagnostics
+      );
     }
     if (branchResult2.exists) {
       const matchingStart = existingRecord.record.start;
@@ -9531,53 +9806,42 @@ async function runPrdRunStartCommand(options) {
           options.repoRoot,
           prdRef,
           existingRecord,
-          {
-            ...reusedStart
-          },
-          {
-            targetName,
-            mode: resolvedMode
-          }
-        );
-        return await processStartResult(
-          {
-            prdRef,
-            status: "starting",
-            start: reusedStart,
-            diagnostics: []
-          },
-          options
+          reusedStart,
+          { targetName, mode: resolvedMode }
         );
+        return {
+          kind: "started",
+          prdRef,
+          mode: resolvedMode,
+          start: reusedStart,
+          diagnostics: []
+        };
       }
       if (!options.adoptExistingBranch) {
-        const failure = {
-          ok: false,
-          gate: "branch-state",
-          reason: `PRD Branch ${prdRef} already exists remotely but PRD Run state does not record the same branch and start base commit. Use --adopt-existing-branch to adopt it.`,
-          diagnostics: [
-            `Existing remote branch: ${prdRef}`,
-            `Recorded start branch: ${existingRecord.record.start.prdBranch}`,
-            `Recorded start base commit: ${existingRecord.record.start.startBaseCommit}`,
+        return blocked(
+          options.repoRoot,
+          prdRef,
+          "branch-state",
+          "unrecorded_branch_exists",
+          `PRD Branch ${prdRef} already exists remotely but PRD Run state does not record the same branch and start base commit. Use --adopt-existing-branch to adopt it.`,
+          [
+            `Existing remote branch: ${prdRef}`,
+            `Recorded start branch: ${matchingStart.prdBranch}`,
+            `Recorded start base commit: ${matchingStart.startBaseCommit}`,
             `Current origin/${recordedBaseBranch} head: ${fetchResult2.startBaseCommit}`
-          ],
-          offendingPaths: []
-        };
-        persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
-          targetName
-        });
-        return buildBlockedStartResult(prdRef, failure);
+          ]
+        );
       }
       const fetchPrdResult = fetchPrdBranch(options.repoRoot, prdRef);
       if (!fetchPrdResult.ok) {
-        persistBlockedPrdRunStartRecord(
+        return blocked(
           options.repoRoot,
           prdRef,
-          fetchPrdResult,
-          {
-            targetName
-          }
+          fetchPrdResult.gate,
+          "fetch_prd_branch_failed",
+          fetchPrdResult.reason,
+          fetchPrdResult.diagnostics
         );
-        return buildBlockedStartResult(prdRef, fetchPrdResult);
       }
       const ancestryResult = spawnSync3(
         "git",
@@ -9590,20 +9854,17 @@ async function runPrdRunStartCommand(options) {
         { cwd: options.repoRoot, encoding: "utf8" }
       );
       if (ancestryResult.status !== 0) {
-        const failure = {
-          ok: false,
-          gate: "branch-state",
-          reason: `PRD Branch ${prdRef} base ancestry check failed: origin/${recordedBaseBranch} is not an ancestor of origin/${prdRef}. Cannot adopt.`,
-          diagnostics: [
+        return blocked(
+          options.repoRoot,
+          prdRef,
+          "branch-state",
+          "ancestry_check_failed",
+          `PRD Branch ${prdRef} base ancestry check failed: origin/${recordedBaseBranch} is not an ancestor of origin/${prdRef}. Cannot adopt.`,
+          [
             `Base branch: origin/${recordedBaseBranch}`,
             `PRD branch: origin/${prdRef}`
-          ],
-          offendingPaths: []
-        };
-        persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
-          targetName
-        });
-        return buildBlockedStartResult(prdRef, failure);
+          ]
+        );
       }
       const adoptedStart = buildStartReceipt({
         status: "adopted",
@@ -9618,23 +9879,16 @@ async function runPrdRunStartCommand(options) {
         options.repoRoot,
         prdRef,
         existingRecord,
-        {
-          ...adoptedStart
-        },
-        {
-          targetName,
-          mode: resolvedMode
-        }
-      );
-      return await processStartResult(
-        {
-          prdRef,
-          status: "starting",
-          start: adoptedStart,
-          diagnostics: []
-        },
-        options
+        adoptedStart,
+        { targetName, mode: resolvedMode }
       );
+      return {
+        kind: "started",
+        prdRef,
+        mode: resolvedMode,
+        start: adoptedStart,
+        diagnostics: []
+      };
     }
   }
   const fetchResult = fetchOriginBranch(
@@ -9642,12 +9896,27 @@ async function runPrdRunStartCommand(options) {
     baseResolution.baseBranch
   );
   if (!fetchResult.ok) {
-    persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, fetchResult, {
-      targetName
-    });
-    return buildBlockedStartResult(prdRef, fetchResult);
+    return blocked(
+      options.repoRoot,
+      prdRef,
+      fetchResult.gate,
+      "fetch_failed",
+      fetchResult.reason,
+      fetchResult.diagnostics
+    );
   }
   if (resolvedMode === "local") {
+    const localStoreResult = validateLocalStartStore(options.repoRoot, prdRef);
+    if (!localStoreResult.ok) {
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        localStoreResult.gate,
+        "local_store_invalid",
+        localStoreResult.reason,
+        localStoreResult.diagnostics
+      );
+    }
     const localBranchName = getLocalPrdBranchName(prdRef);
     const localBranchResult = materializeLocalPrdBranch(
       prdRef,
@@ -9655,29 +9924,14 @@ async function runPrdRunStartCommand(options) {
       options.repoRoot
     );
     if (!localBranchResult.ok) {
-      const failure = {
-        ok: false,
-        gate: "branch-state",
-        reason: localBranchResult.message,
-        diagnostics: [localBranchResult.message],
-        offendingPaths: []
-      };
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
-        targetName
-      });
-      return buildBlockedStartResult(prdRef, failure);
-    }
-    const localStoreResult = validateLocalStartStore(options.repoRoot, prdRef);
-    if (!localStoreResult.ok) {
-      persistBlockedPrdRunStartRecord(
+      return blocked(
         options.repoRoot,
         prdRef,
-        localStoreResult,
-        {
-          targetName
-        }
+        "branch-state",
+        "local_branch_failed",
+        localBranchResult.message,
+        [localBranchResult.message]
       );
-      return buildBlockedStartResult(prdRef, localStoreResult);
     }
     const updatedAt2 = (/* @__PURE__ */ new Date()).toISOString();
     const start2 = buildStartReceipt({
@@ -9694,58 +9948,53 @@ async function runPrdRunStartCommand(options) {
       prdRef,
       existingRecord,
       start2,
-      {
-        targetName,
-        mode: resolvedMode
-      }
-    );
-    return await processStartResult(
-      {
-        prdRef,
-        status: "starting",
-        start: start2,
-        diagnostics: []
-      },
-      options
+      { targetName, mode: resolvedMode }
     );
+    return {
+      kind: "started",
+      prdRef,
+      mode: resolvedMode,
+      start: start2,
+      diagnostics: []
+    };
   }
   const branchResult = inspectRemotePrdBranch(options.repoRoot, prdRef);
   if (!branchResult.ok) {
-    persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, branchResult, {
-      targetName
-    });
-    return buildBlockedStartResult(prdRef, branchResult);
+    return blocked(
+      options.repoRoot,
+      prdRef,
+      branchResult.gate,
+      "branch_inspection_failed",
+      branchResult.reason,
+      branchResult.diagnostics
+    );
   }
   if (branchResult.exists) {
     if (!options.adoptExistingBranch) {
-      const failure = {
-        ok: false,
-        gate: "branch-state",
-        reason: `PRD Branch ${prdRef} already exists remotely but PRD Run state does not record the same branch and start base commit. Use --adopt-existing-branch to adopt it.`,
-        diagnostics: [
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        "branch-state",
+        "unrecorded_branch_exists",
+        `PRD Branch ${prdRef} already exists remotely but PRD Run state does not record the same branch and start base commit. Use --adopt-existing-branch to adopt it.`,
+        [
           `Existing remote branch: ${prdRef}`,
           `Recorded start branch: ${existingRecord.record?.start?.prdBranch ?? "(missing)"}`,
           `Recorded start base commit: ${existingRecord.record?.start?.startBaseCommit ?? "(missing)"}`,
           `Current origin/${baseResolution.baseBranch} head: ${fetchResult.startBaseCommit}`
-        ],
-        offendingPaths: []
-      };
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
-        targetName
-      });
-      return buildBlockedStartResult(prdRef, failure);
+        ]
+      );
     }
     const fetchPrdResult = fetchPrdBranch(options.repoRoot, prdRef);
     if (!fetchPrdResult.ok) {
-      persistBlockedPrdRunStartRecord(
+      return blocked(
         options.repoRoot,
         prdRef,
-        fetchPrdResult,
-        {
-          targetName
-        }
+        fetchPrdResult.gate,
+        "fetch_prd_branch_failed",
+        fetchPrdResult.reason,
+        fetchPrdResult.diagnostics
       );
-      return buildBlockedStartResult(prdRef, fetchPrdResult);
     }
     const ancestryResult = spawnSync3(
       "git",
@@ -9758,227 +10007,811 @@ async function runPrdRunStartCommand(options) {
       { cwd: options.repoRoot, encoding: "utf8" }
     );
     if (ancestryResult.status !== 0) {
-      const failure = {
-        ok: false,
-        gate: "branch-state",
-        reason: `PRD Branch ${prdRef} base ancestry check failed: origin/${baseResolution.baseBranch} is not an ancestor of origin/${prdRef}. Cannot adopt.`,
-        diagnostics: [
+      return blocked(
+        options.repoRoot,
+        prdRef,
+        "branch-state",
+        "ancestry_check_failed",
+        `PRD Branch ${prdRef} base ancestry check failed: origin/${baseResolution.baseBranch} is not an ancestor of origin/${prdRef}. Cannot adopt.`,
+        [
           `Base branch: origin/${baseResolution.baseBranch}`,
           `PRD branch: origin/${prdRef}`
+        ]
+      );
+    }
+    const adoptedStart = buildStartReceipt({
+      status: "adopted",
+      targetName,
+      prdBranch: prdRef,
+      startBaseBranch: baseResolution.baseBranch,
+      startBaseCommit: fetchResult.startBaseCommit,
+      branchAction: "adopted",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    persistStartingPrdRunRecord(
+      options.repoRoot,
+      prdRef,
+      existingRecord,
+      adoptedStart,
+      { targetName, mode: resolvedMode }
+    );
+    return {
+      kind: "started",
+      prdRef,
+      mode: resolvedMode,
+      start: adoptedStart,
+      diagnostics: []
+    };
+  }
+  try {
+    await ensurePrdBranchPublished(
+      options.repoRoot,
+      prdRef,
+      fetchResult.startBaseCommit
+    );
+  } catch (error) {
+    return blocked(
+      options.repoRoot,
+      prdRef,
+      "git",
+      "branch_creation_failed",
+      `Failed to create PRD Branch ${prdRef} from ${fetchResult.startBaseCommit}.`,
+      [error instanceof Error ? error.message : String(error)].filter(
+        (v) => Boolean(v && v.trim())
+      )
+    );
+  }
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const start = buildStartReceipt({
+    status: "started",
+    targetName,
+    prdBranch: prdRef,
+    startBaseBranch: baseResolution.baseBranch,
+    startBaseCommit: fetchResult.startBaseCommit,
+    branchAction: "created",
+    startedAt: updatedAt
+  });
+  persistStartingPrdRunRecord(options.repoRoot, prdRef, existingRecord, start, {
+    targetName,
+    mode: resolvedMode
+  });
+  return {
+    kind: "started",
+    prdRef,
+    mode: resolvedMode,
+    start,
+    diagnostics: []
+  };
+}
+function buildLaunchBlockedOutcome(prdRef, guidance, resume, start) {
+  return {
+    kind: "blocked",
+    prdRef,
+    guidance,
+    start,
+    resume
+  };
+}
+function writeDrainedRecord(repoRoot2, prdRef, startReceipt, targetName, mode) {
+  writePrdRunRecord(repoRoot2, {
+    prdRef,
+    status: "drained",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    targetName,
+    start: startReceipt,
+    mode
+  });
+}
+function writeTerminalRecord(repoRoot2, prdRef, status, targetName, startReceipt, prdBranch, mode) {
+  writePrdRunRecord(repoRoot2, {
+    prdRef,
+    status,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    targetName,
+    prdBranch,
+    start: startReceipt,
+    mode
+  });
+}
+function validatePrdRunStartEvidence(record, context) {
+  if (!record.start) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "branch-state",
+        failureCode: "missing_start_evidence",
+        reason: `PRD Run ${context.prdRef} has no start receipt.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (!record.start.startBaseBranch) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "branch-state",
+        failureCode: "missing_start_base_branch",
+        reason: `PRD Run ${context.prdRef} start receipt missing startBaseBranch.`,
+        repairability: "operator-action",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (record.start.startBaseBranch !== context.baseBranch) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "branch-state",
+        failureCode: "base_mismatch",
+        reason: `PRD Run ${context.prdRef} startBaseBranch "${record.start.startBaseBranch}" does not match expected "${context.baseBranch}".`,
+        repairability: "operator-action",
+        diagnostics: [
+          `Recorded startBaseBranch: ${record.start.startBaseBranch}`,
+          `Expected baseBranch: ${context.baseBranch}`
+        ],
+        offendingPaths: []
+      }
+    };
+  }
+  if (!record.start.prdBranch) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "branch-state",
+        failureCode: "missing_prd_branch",
+        reason: `PRD Run ${context.prdRef} start receipt missing prdBranch.`,
+        repairability: "operator-action",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (record.mode && record.mode !== context.mode) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "branch-state",
+        failureCode: "mode_mismatch",
+        reason: `PRD Run ${context.prdRef} mode mismatch: recorded "${record.mode}" but expected "${context.mode}".`,
+        repairability: "operator-action",
+        diagnostics: [
+          `Recorded mode: ${record.mode}`,
+          `Expected mode: ${context.mode}`
+        ],
+        offendingPaths: []
+      }
+    };
+  }
+  if (record.prdRef !== context.prdRef) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "branch-state",
+        failureCode: "prd_ref_mismatch",
+        reason: `PRD Run prdRef mismatch: "${record.prdRef}" does not match expected "${context.prdRef}".`,
+        repairability: "operator-action",
+        diagnostics: [
+          `Recorded prdRef: ${record.prdRef}`,
+          `Expected prdRef: ${context.prdRef}`
+        ],
+        offendingPaths: []
+      }
+    };
+  }
+  return { ok: true };
+}
+function validatePrdRunDrainEvidence(record, context) {
+  const start = record.start;
+  if (!start) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "missing_drain_evidence",
+        reason: `PRD Run ${context.prdRef} has no start receipt for drain validation.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (!start.queueStartedAt) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "missing_queue_started_at",
+        reason: `PRD Run ${context.prdRef} drain evidence missing queueStartedAt.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (start.queueCommand !== "queue-run") {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "missing_queue_command",
+        reason: `PRD Run ${context.prdRef} drain evidence missing queue-run command.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (!start.queueDrainedAt) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "missing_queue_drained_at",
+        reason: `PRD Run ${context.prdRef} drain evidence missing queueDrainedAt.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (typeof start.queueProcessedCount !== "number") {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "missing_queue_processed_count",
+        reason: `PRD Run ${context.prdRef} drain evidence missing queueProcessedCount.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      }
+    };
+  }
+  if (start.queueProcessedCount <= 0) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "zero_processed",
+        reason: `PRD Run ${context.prdRef} queue drain processed zero issues.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [`queueProcessedCount: ${start.queueProcessedCount}`],
+        offendingPaths: []
+      }
+    };
+  }
+  if (start.prdBranch !== context.prdBranch) {
+    return {
+      ok: false,
+      guidance: {
+        blockedGate: "queue",
+        failureCode: "prd_branch_mismatch",
+        reason: `PRD Run ${context.prdRef} prdBranch "${start.prdBranch}" does not match expected "${context.prdBranch}".`,
+        repairability: "operator-action",
+        diagnostics: [
+          `Recorded prdBranch: ${start.prdBranch}`,
+          `Expected prdBranch: ${context.prdBranch}`
+        ],
+        offendingPaths: []
+      }
+    };
+  }
+  return { ok: true };
+}
+async function launchPrdRun(options) {
+  const prdRef = normalizePrdRunRef(options.prdRef);
+  const existingRecord = readPrdRun(options.repoRoot, prdRef);
+  const resolvedLaunchMode = options.config ? (() => {
+    try {
+      const target = resolveTarget(options.config, options.targetName);
+      return resolvePrdRunMode(target).mode;
+    } catch {
+      return void 0;
+    }
+  })() : void 0;
+  if (resolvedLaunchMode && existingRecord.record?.mode && existingRecord.record.mode !== resolvedLaunchMode) {
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "branch-state",
+        failureCode: "mode_mismatch",
+        reason: `PRD Run ${prdRef} mode mismatch: recorded "${existingRecord.record.mode}" but resolved "${resolvedLaunchMode}". Resolve by using the correct target.`,
+        repairability: "operator-action",
+        diagnostics: [
+          `Recorded mode: ${existingRecord.record.mode}`,
+          `Resolved mode: ${resolvedLaunchMode}`
+        ],
+        offendingPaths: []
+      },
+      { attempted: [], skipped: ["start", "queue"], resumed: [] }
+    );
+  }
+  const plan = planPrdRunLaunchResume(existingRecord.record);
+  if (plan.blocked === "final_reviewed-incompatible") {
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "final-review",
+        failureCode: "final_reviewed_incompatible",
+        reason: `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.`,
+        repairability: "unsupported-state",
+        diagnostics: [
+          `PRD Run ${prdRef} has obsolete status "final_reviewed". PRD-wide Final Review has been removed from the launch lifecycle.`
+        ],
+        offendingPaths: []
+      },
+      plan
+    );
+  }
+  if (existingRecord.record?.status === "completed_prd_branch" || existingRecord.record?.status === "complete" || existingRecord.record?.status === "completed_local_branch") {
+    return {
+      kind: "already-terminal",
+      prdRef,
+      status: existingRecord.record.status === "complete" ? "complete" : existingRecord.record.status,
+      prdBranch: existingRecord.record.prdBranch,
+      diagnostics: [
+        `PRD Run ${prdRef} is already in status "${existingRecord.record.status}".`
+      ],
+      resume: plan
+    };
+  }
+  if (existingRecord.record?.status === "drained") {
+    const record = existingRecord.record;
+    if (!record.start) {
+      return buildLaunchBlockedOutcome(
+        prdRef,
+        {
+          blockedGate: "queue",
+          failureCode: "missing_drain_evidence",
+          reason: `PRD Run ${prdRef} is drained but missing start receipt.`,
+          repairability: "automatic-retry-safe",
+          diagnostics: [],
+          offendingPaths: []
+        },
+        plan
+      );
+    }
+    const drainMode = resolvedLaunchMode ?? record.mode ?? "github";
+    const resolvedTarget = options.config ? resolveTarget(options.config, options.targetName) : null;
+    const targetBaseBranch = resolvedTarget?.baseBranch ?? "main";
+    const baseResolution = resolvePrdRunBaseBranch({
+      targetBaseBranch,
+      baseBranchOverride: options.baseBranchOverride
+    });
+    if (!baseResolution.ok) {
+      return buildLaunchBlockedOutcome(
+        prdRef,
+        {
+          blockedGate: baseResolution.gate,
+          failureCode: "base_resolution_failed",
+          reason: baseResolution.reason,
+          repairability: "operator-action",
+          diagnostics: [...baseResolution.diagnostics],
+          offendingPaths: [...baseResolution.offendingPaths]
+        },
+        plan
+      );
+    }
+    const drainContext = {
+      prdRef,
+      mode: drainMode,
+      baseBranch: baseResolution.baseBranch,
+      prdBranch: record.start.prdBranch
+    };
+    const startEvidence = validatePrdRunStartEvidence(record, drainContext);
+    if (!startEvidence.ok) {
+      return buildLaunchBlockedOutcome(prdRef, startEvidence.guidance, plan);
+    }
+    const drainEvidence = validatePrdRunDrainEvidence(record, drainContext);
+    if (!drainEvidence.ok) {
+      return buildLaunchBlockedOutcome(prdRef, drainEvidence.guidance, plan);
+    }
+    const terminalStatus = drainMode === "local" ? "completed_local_branch" : "completed_prd_branch";
+    writeTerminalRecord(
+      options.repoRoot,
+      prdRef,
+      terminalStatus,
+      record.targetName ?? options.targetName,
+      record.start,
+      record.start.prdBranch,
+      drainMode
+    );
+    return {
+      kind: "completed",
+      prdRef,
+      status: terminalStatus,
+      prdBranch: record.start.prdBranch,
+      diagnostics: [
+        `PRD Run ${prdRef} completed from drained state. Branch: ${record.start.prdBranch}.`
+      ],
+      resume: plan
+    };
+  }
+  if (plan.blocked === "missing-start-receipt") {
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "branch-state",
+        failureCode: "missing_start_receipt",
+        reason: `PRD Run ${prdRef} is missing branch/start state. Run prd-run start or rerun prd-run launch.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [
+          `PRD Run ${prdRef} is in status "${existingRecord.record?.status}" but has no start receipt.`
         ],
         offendingPaths: []
+      },
+      plan
+    );
+  }
+  let startOutcome;
+  if (!plan.skipped.includes("start")) {
+    startOutcome = await startPrdRun({
+      repoRoot: options.repoRoot,
+      prdRef,
+      targetName: options.targetName,
+      config: options.config,
+      issueProvider: options.issueProvider,
+      prProvider: options.prProvider,
+      executionProvider: options.executionProvider,
+      logger: options.logger,
+      adoptExistingBranch: options.adoptExistingBranch,
+      baseBranchOverride: options.baseBranchOverride
+    });
+    if (startOutcome.kind === "blocked") {
+      return {
+        kind: "blocked",
+        prdRef,
+        guidance: startOutcome.guidance,
+        start: startOutcome,
+        resume: plan
       };
-      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
-        targetName
-      });
-      return buildBlockedStartResult(prdRef, failure);
     }
-    const adoptedStart = buildStartReceipt({
-      status: "adopted",
+  }
+  const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
+  const startReceipt = currentRecord?.start;
+  const targetName = currentRecord?.targetName ?? options.targetName;
+  const explicitMode = resolvedLaunchMode ?? currentRecord?.mode;
+  if (startReceipt) {
+    startReceipt.queueStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+    startReceipt.queueCommand = "queue-run";
+  }
+  writePrdRunRecord(options.repoRoot, {
+    prdRef,
+    status: "running",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    targetName,
+    start: startReceipt,
+    mode: explicitMode
+  });
+  if (explicitMode === "local") {
+    return await launchLocalQueueDrain(
+      options,
+      prdRef,
+      startReceipt,
+      targetName,
+      explicitMode,
+      plan,
+      startOutcome
+    );
+  }
+  return await launchGithubQueueDrain(
+    options,
+    prdRef,
+    startReceipt,
+    targetName,
+    explicitMode,
+    plan,
+    startOutcome
+  );
+}
+async function launchLocalQueueDrain(options, prdRef, startReceipt, targetName, mode, plan, startOutcome) {
+  if (!startReceipt) {
+    writePrdRunRecord(options.repoRoot, {
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      blockedGate: "branch-state",
+      blockedReason: `PRD Run ${prdRef} is missing start receipt before local queue drain.`,
+      diagnostics: [],
+      offendingPaths: []
+    });
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "branch-state",
+        failureCode: "missing_start_receipt",
+        reason: `PRD Run ${prdRef} is missing start receipt before local queue drain.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
+        offendingPaths: []
+      },
+      plan,
+      startOutcome
+    );
+  }
+  const localStoreDir = join19(
+    options.repoRoot,
+    ".pourkit",
+    "local-prd-runs",
+    prdRef
+  );
+  let localStoreReady = false;
+  if (existsSync15(localStoreDir)) {
+    const localStorePath = join19(localStoreDir, "prd.json");
+    try {
+      const content = JSON.parse(readFileSync17(localStorePath, "utf8"));
+      localStoreReady = content?.id === prdRef && content?.kind === "prd";
+    } catch {
+      localStoreReady = false;
+    }
+  }
+  if (!localStoreReady) {
+    const 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.`;
+    writePrdRunRecord(options.repoRoot, {
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      start: startReceipt,
+      mode,
+      blockedGate: "branch-state",
+      blockedReason: reason,
+      diagnostics: [
+        `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
+        `Expected PRD ID: ${prdRef}`
+      ],
+      offendingPaths: []
+    });
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "branch-state",
+        failureCode: "local_store_invalid",
+        reason,
+        repairability: "operator-action",
+        diagnostics: [
+          `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
+          `Expected PRD ID: ${prdRef}`
+        ],
+        offendingPaths: []
+      },
+      plan,
+      startOutcome
+    );
+  }
+  const queueResult = await runLocalQueueLoop(
+    prdRef,
+    options.repoRoot,
+    options.issueProvider
+  );
+  if (!queueResult.ok) {
+    const failureCode = queueResult.failureCode ?? "queue_error";
+    const reason = queueResult.repairGuidance ?? `Local queue loop blocked: ${failureCode}`;
+    const diagnostics = [
+      `Local queue loop failed with failureCode "${failureCode}".`,
+      ...queueResult.repairGuidance ? [`Repair guidance: ${queueResult.repairGuidance}`] : []
+    ];
+    writePrdRunRecord(options.repoRoot, {
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName,
-      prdBranch: prdRef,
-      startBaseBranch: baseResolution.baseBranch,
-      startBaseCommit: fetchResult.startBaseCommit,
-      branchAction: "adopted",
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      start: startReceipt,
+      mode,
+      blockedGate: "queue",
+      blockedReason: reason,
+      diagnostics,
+      offendingPaths: []
     });
-    persistStartingPrdRunRecord(
-      options.repoRoot,
+    return buildLaunchBlockedOutcome(
       prdRef,
-      existingRecord,
       {
-        ...adoptedStart
+        blockedGate: "queue",
+        failureCode,
+        reason,
+        repairability: "automatic-retry-safe",
+        diagnostics,
+        offendingPaths: []
       },
-      {
-        targetName,
-        mode: resolvedMode
-      }
+      plan,
+      startOutcome
     );
-    return await processStartResult(
+  }
+  if (queueResult.blockedIssues.length > 0) {
+    const reason = `Queue processed complete but ${queueResult.blockedIssues.length} blocked child issue(s) remain.`;
+    const diagnostics = [
+      reason,
+      `Blocked issues: ${queueResult.blockedIssues.join(", ")}`,
+      "Resolve blocked children before parent close."
+    ];
+    writePrdRunRecord(options.repoRoot, {
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      start: startReceipt,
+      mode,
+      blockedGate: "queue",
+      blockedReason: reason,
+      diagnostics,
+      offendingPaths: []
+    });
+    return buildLaunchBlockedOutcome(
+      prdRef,
       {
-        prdRef,
-        status: "starting",
-        start: adoptedStart,
-        diagnostics: []
+        blockedGate: "queue",
+        failureCode: "blocked_child_issues",
+        reason,
+        repairability: "operator-action",
+        diagnostics,
+        offendingPaths: []
       },
-      options
+      plan,
+      startOutcome
     );
   }
-  try {
-    await ensurePrdBranchPublished(
-      options.repoRoot,
+  startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
+  startReceipt.queueProcessedCount = queueResult.completedIssues.length + queueResult.blockedIssues.length;
+  const prdBranch = startReceipt.prdBranch ?? `local/${prdRef}`;
+  writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName, mode);
+  const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
+  if (drainRecord) {
+    const drainContext = {
       prdRef,
-      fetchResult.startBaseCommit
-    );
-  } catch (error) {
-    const failure = {
-      ok: false,
-      gate: "git",
-      reason: `Failed to create PRD Branch ${prdRef} from ${fetchResult.startBaseCommit}.`,
-      diagnostics: [
-        error instanceof Error ? error.message : String(error)
-      ].filter((value) => Boolean(value && value.trim())),
-      offendingPaths: []
+      mode,
+      baseBranch: startReceipt.startBaseBranch,
+      prdBranch
     };
-    persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
-      targetName
-    });
-    return buildBlockedStartResult(prdRef, failure);
+    const startEvidence = validatePrdRunStartEvidence(
+      drainRecord,
+      drainContext
+    );
+    if (!startEvidence.ok) {
+      return buildLaunchBlockedOutcome(
+        prdRef,
+        startEvidence.guidance,
+        plan,
+        startOutcome
+      );
+    }
+    const drainEvidence = validatePrdRunDrainEvidence(
+      drainRecord,
+      drainContext
+    );
+    if (!drainEvidence.ok) {
+      return buildLaunchBlockedOutcome(
+        prdRef,
+        drainEvidence.guidance,
+        plan,
+        startOutcome
+      );
+    }
   }
-  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const start = buildStartReceipt({
-    status: "started",
-    targetName,
-    prdBranch: prdRef,
-    startBaseBranch: baseResolution.baseBranch,
-    startBaseCommit: fetchResult.startBaseCommit,
-    branchAction: "created",
-    startedAt: updatedAt
-  });
-  const {
-    blockedGate: _blockedGate,
-    blockedReason: _blockedReason,
-    diagnostics: _diagnostics,
-    offendingPaths: _offendingPaths,
-    prdBranch: _prdBranch,
-    start: _start,
-    ...cleanRecord
-  } = existingRecord.record ?? { prdRef };
-  writePrdRunRecord(options.repoRoot, {
-    ...cleanRecord,
+  writeTerminalRecord(
+    options.repoRoot,
     prdRef,
-    status: "starting",
-    updatedAt,
+    "completed_local_branch",
     targetName,
-    start,
-    mode: resolvedMode
-  });
-  return await processStartResult(
-    {
-      prdRef,
-      status: "starting",
-      start,
-      diagnostics: []
-    },
-    options
+    startReceipt,
+    prdBranch,
+    mode
   );
-}
-async function processStartResult(startResult, options) {
-  if (!options.config) {
-    return startResult;
-  }
-  const prdRef = startResult.prdRef;
-  const start = startResult.start;
-  const repoRoot2 = options.repoRoot;
-  start.queueStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-  start.queueCommand = "queue-run";
-  const existingRecord = readPrdRun(repoRoot2, prdRef);
-  let resolvedMode;
-  try {
-    const target = options.config ? resolveTarget(options.config, start.targetName) : null;
-    resolvedMode = target?.strategy ? resolvePrdRunMode(target) : void 0;
-  } catch {
-    resolvedMode = void 0;
-  }
-  const modeForRecord = resolvedMode?.mode;
-  if (modeForRecord !== "local" && (!options.issueProvider || !options.prProvider || !options.executionProvider || !options.logger)) {
-    return startResult;
-  }
-  writePrdRunRecord(repoRoot2, {
+  return {
+    kind: "completed",
     prdRef,
-    status: "running",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    targetName: start.targetName,
-    start,
-    mode: modeForRecord
-  });
-  const localStorePath = join19(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
-  if (existsSync16(localStorePath)) {
-    const queueResult = await runLocalQueueLoop(
+    status: "completed_local_branch",
+    prdBranch,
+    diagnostics: [`Local PRD Run ${prdRef} completed. Branch: ${prdBranch}.`],
+    start: startOutcome,
+    resume: plan
+  };
+}
+async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName, mode, plan, startOutcome) {
+  if (!options.issueProvider || !options.prProvider || !options.executionProvider || !options.logger) {
+    const reason = `PRD Run ${prdRef} requires issueProvider, prProvider, executionProvider, and logger for GitHub-backed queue drain.`;
+    writePrdRunRecord(options.repoRoot, {
       prdRef,
-      repoRoot2,
-      options.issueProvider
-    );
-    if (!queueResult.ok) {
-      const failureCode = queueResult.failureCode ?? "queue_error";
-      const reason = queueResult.repairGuidance ?? `Local queue loop blocked: ${failureCode}`;
-      const diagnostics = [
-        `Local queue loop failed with failureCode "${failureCode}".`,
-        ...queueResult.repairGuidance ? [`Repair guidance: ${queueResult.repairGuidance}`] : []
-      ];
-      writePrdRunRecord(repoRoot2, {
-        prdRef,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        targetName: start.targetName,
-        start,
-        mode: modeForRecord,
-        blockedGate: "queue",
-        blockedReason: reason,
-        diagnostics,
-        offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "blocked",
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      start: startReceipt,
+      mode,
+      blockedGate: "queue",
+      blockedReason: reason,
+      diagnostics: [
+        "Missing one or more required providers for GitHub-backed mode.",
+        "Provide --issue-provider, --pr-provider, --execution-provider, and --logger options."
+      ],
+      offendingPaths: []
+    });
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
         blockedGate: "queue",
-        blockedReason: reason,
-        diagnostics,
-        offendingPaths: []
-      };
-    }
-    if (queueResult.blockedIssues.length > 0) {
-      const reason = `Queue processed complete but ${queueResult.blockedIssues.length} blocked child issue(s) remain.`;
-      const diagnostics = [
+        failureCode: "missing_github_providers",
         reason,
-        `Blocked issues: ${queueResult.blockedIssues.join(", ")}`,
-        "Resolve blocked children before parent close."
-      ];
-      writePrdRunRecord(repoRoot2, {
-        prdRef,
-        status: "blocked",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        targetName: start.targetName,
-        start,
-        mode: modeForRecord,
-        blockedGate: "queue",
-        blockedReason: reason,
-        diagnostics,
+        repairability: "operator-action",
+        diagnostics: [
+          "Missing one or more required providers for GitHub-backed mode."
+        ],
         offendingPaths: []
-      });
-      return {
-        prdRef,
-        status: "blocked",
-        blockedGate: "queue",
-        blockedReason: reason,
-        diagnostics,
+      },
+      plan,
+      startOutcome
+    );
+  }
+  if (!startReceipt) {
+    writePrdRunRecord(options.repoRoot, {
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      mode,
+      blockedGate: "branch-state",
+      blockedReason: `PRD Run ${prdRef} is missing start receipt before GitHub queue drain.`,
+      diagnostics: [],
+      offendingPaths: []
+    });
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "branch-state",
+        failureCode: "missing_start_receipt",
+        reason: `PRD Run ${prdRef} is missing start receipt before GitHub queue drain.`,
+        repairability: "automatic-retry-safe",
+        diagnostics: [],
         offendingPaths: []
-      };
-    }
-    start.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
-    start.queueProcessedCount = queueResult.completedIssues.length + queueResult.blockedIssues.length;
-    writePrdRunRecord(repoRoot2, {
+      },
+      plan,
+      startOutcome
+    );
+  }
+  if (!options.config) {
+    const reason = `PRD Run ${prdRef} requires config for GitHub-backed queue drain.`;
+    writePrdRunRecord(options.repoRoot, {
       prdRef,
-      status: "drained",
+      status: "blocked",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetName: start.targetName,
-      start,
-      mode: modeForRecord
+      targetName,
+      start: startReceipt,
+      mode,
+      blockedGate: "queue",
+      blockedReason: reason,
+      diagnostics: ["Missing config for GitHub-backed mode."],
+      offendingPaths: []
     });
-    return {
+    return buildLaunchBlockedOutcome(
       prdRef,
-      status: "drained",
-      start,
-      diagnostics: []
-    };
+      {
+        blockedGate: "queue",
+        failureCode: "missing_config",
+        reason,
+        repairability: "operator-action",
+        diagnostics: ["Missing config for GitHub-backed mode."],
+        offendingPaths: []
+      },
+      plan,
+      startOutcome
+    );
   }
   const issueProvider = options.issueProvider;
   const prProvider = options.prProvider;
   const executionProvider = options.executionProvider;
   const logger = options.logger;
+  let resolvedModeForQueue;
+  try {
+    const target = resolveTarget(options.config, options.targetName);
+    resolvedModeForQueue = resolvePrdRunMode(target);
+  } catch {
+    resolvedModeForQueue = void 0;
+  }
   try {
     const outcome = await runQueueCommand({
-      targetName: start.targetName,
+      targetName,
       config: options.config,
       issueProvider,
       prProvider,
@@ -9986,12 +10819,12 @@ async function processStartResult(startResult, options) {
       force: false,
       loop: true,
       logger,
-      repoRoot: repoRoot2,
+      repoRoot: options.repoRoot,
       prdRef,
       queueRunContext: {
         prdRef,
-        prdBranch: start.prdBranch,
-        prdRunMode: resolvedMode
+        prdBranch: startReceipt.prdBranch,
+        prdRunMode: resolvedModeForQueue
       }
     });
     if (outcome.selected === null && outcome.code === "drained") {
@@ -9999,327 +10832,259 @@ async function processStartResult(startResult, options) {
         const diagnostics = [
           "Queue drained without processing issues. No PRD-scoped candidates or runnable Issues."
         ];
-        writePrdRunRecord(repoRoot2, {
+        writePrdRunRecord(options.repoRoot, {
           prdRef,
           status: "blocked",
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          targetName,
+          start: startReceipt,
+          mode,
           blockedGate: "queue",
           blockedReason: diagnostics[0],
           diagnostics,
-          targetName: start.targetName,
-          start,
-          mode: existingRecord.record?.mode,
           offendingPaths: []
         });
-        return {
+        return buildLaunchBlockedOutcome(
           prdRef,
-          status: "blocked",
-          blockedGate: "queue",
-          blockedReason: diagnostics[0],
-          diagnostics,
-          offendingPaths: []
+          {
+            blockedGate: "queue",
+            failureCode: "zero_processed",
+            reason: diagnostics[0],
+            repairability: "automatic-retry-safe",
+            diagnostics,
+            offendingPaths: []
+          },
+          plan,
+          startOutcome
+        );
+      }
+      startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
+      startReceipt.queueProcessedCount = outcome.processedCount;
+      const prdBranch = startReceipt.prdBranch ?? prdRef;
+      writeDrainedRecord(
+        options.repoRoot,
+        prdRef,
+        startReceipt,
+        targetName,
+        mode
+      );
+      const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
+      if (drainRecord) {
+        const drainMode = mode ?? "github";
+        const drainContext = {
+          prdRef,
+          mode: drainMode,
+          baseBranch: startReceipt.startBaseBranch,
+          prdBranch
         };
+        const startEvidence = validatePrdRunStartEvidence(
+          drainRecord,
+          drainContext
+        );
+        if (!startEvidence.ok) {
+          return buildLaunchBlockedOutcome(
+            prdRef,
+            startEvidence.guidance,
+            plan,
+            startOutcome
+          );
+        }
+        const drainEvidence = validatePrdRunDrainEvidence(
+          drainRecord,
+          drainContext
+        );
+        if (!drainEvidence.ok) {
+          return buildLaunchBlockedOutcome(
+            prdRef,
+            drainEvidence.guidance,
+            plan,
+            startOutcome
+          );
+        }
       }
-      start.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
-      start.queueProcessedCount = outcome.processedCount;
-      writePrdRunRecord(repoRoot2, {
+      writeTerminalRecord(
+        options.repoRoot,
         prdRef,
-        status: "drained",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        targetName: start.targetName,
-        start,
-        mode: existingRecord.record?.mode
-      });
+        "completed_prd_branch",
+        targetName,
+        startReceipt,
+        prdBranch,
+        mode
+      );
       return {
+        kind: "completed",
         prdRef,
-        status: "drained",
-        start,
-        diagnostics: []
+        status: "completed_prd_branch",
+        prdBranch,
+        diagnostics: [
+          `PRD Run completed on branch ${prdBranch}. Next: checkout ${prdBranch} for human review, or use release promotion workflow when ready.`
+        ],
+        start: startOutcome,
+        resume: plan
       };
     }
     if (outcome.selected === null) {
       const diagnostics = [outcome.reason];
-      writePrdRunRecord(repoRoot2, {
+      writePrdRunRecord(options.repoRoot, {
         prdRef,
         status: "blocked",
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        targetName,
+        start: startReceipt,
+        mode,
         blockedGate: "queue",
         blockedReason: outcome.reason,
         diagnostics,
-        targetName: start.targetName,
-        start,
-        mode: existingRecord.record?.mode,
         offendingPaths: []
       });
-      return {
+      return buildLaunchBlockedOutcome(
         prdRef,
-        status: "blocked",
-        blockedGate: "queue",
-        blockedReason: outcome.reason,
-        diagnostics,
-        offendingPaths: []
-      };
+        {
+          blockedGate: "queue",
+          failureCode: "queue_blocked",
+          reason: outcome.reason,
+          repairability: "automatic-retry-safe",
+          diagnostics,
+          offendingPaths: []
+        },
+        plan,
+        startOutcome
+      );
     }
     const outcomeReason = `Unexpected queue outcome: selected issue ${outcome.selected.number}`;
     const outcomeDiagnostics = [outcomeReason];
-    writePrdRunRecord(repoRoot2, {
+    writePrdRunRecord(options.repoRoot, {
       prdRef,
       status: "blocked",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      start: startReceipt,
+      mode,
       blockedGate: "queue",
       blockedReason: outcomeReason,
       diagnostics: outcomeDiagnostics,
-      targetName: start.targetName,
-      start,
-      mode: existingRecord.record?.mode,
       offendingPaths: []
     });
-    return {
+    return buildLaunchBlockedOutcome(
       prdRef,
-      status: "blocked",
-      blockedGate: "queue",
-      blockedReason: outcomeReason,
-      diagnostics: outcomeDiagnostics,
-      offendingPaths: []
-    };
+      {
+        blockedGate: "queue",
+        failureCode: "unexpected_queue_outcome",
+        reason: outcomeReason,
+        repairability: "operator-action",
+        diagnostics: outcomeDiagnostics,
+        offendingPaths: []
+      },
+      plan,
+      startOutcome
+    );
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     const diagnostics = [msg];
-    writePrdRunRecord(repoRoot2, {
-      prdRef,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      blockedGate: "queue",
-      blockedReason: msg,
-      diagnostics,
-      targetName: start.targetName,
-      start,
-      mode: existingRecord.record?.mode,
-      offendingPaths: []
-    });
-    return {
+    writePrdRunRecord(options.repoRoot, {
       prdRef,
       status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetName,
+      start: startReceipt,
+      mode,
       blockedGate: "queue",
       blockedReason: msg,
       diagnostics,
       offendingPaths: []
-    };
+    });
+    return buildLaunchBlockedOutcome(
+      prdRef,
+      {
+        blockedGate: "queue",
+        failureCode: "queue_exception",
+        reason: msg,
+        repairability: "automatic-retry-safe",
+        diagnostics,
+        offendingPaths: []
+      },
+      plan,
+      startOutcome
+    );
   }
 }
-function persistStartingPrdRunRecord(repoRoot2, prdRef, existingRecord, start, context) {
-  const {
-    blockedGate: _blockedGate,
-    blockedReason: _blockedReason,
-    diagnostics: _diagnostics,
-    offendingPaths: _offendingPaths,
-    prdBranch: _prdBranch,
-    start: _start,
-    ...cleanRecord
-  } = existingRecord.record ?? { prdRef };
-  writePrdRunRecord(repoRoot2, {
-    ...cleanRecord,
-    prdRef,
-    status: "starting",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    targetName: context.targetName,
-    start,
-    mode: context.mode
-  });
-}
-function inspectRemotePrdBranch(repoRoot2, prdRef) {
-  const result = spawnSync3("git", ["ls-remote", "--heads", "origin", prdRef], {
-    cwd: repoRoot2,
-    encoding: "utf8"
-  });
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      gate: "git",
-      reason: `PRD Run start failed while inspecting remote branch ${prdRef}.`,
-      diagnostics: [
-        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())),
-      offendingPaths: []
-    };
-  }
-  const headSha = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0]?.split(/\s+/)[0];
-  if (!headSha) {
-    return { ok: true, exists: false };
-  }
-  return { ok: true, exists: true, headSha };
+
+// prd-run/final-review-validation.ts
+import { existsSync as existsSync16, readFileSync as readFileSync18 } from "fs";
+
+// commands/prd-run.ts
+async function runPrdRunLaunchCommand(options) {
+  const outcome = await launchPrdRun(options);
+  return mapLaunchPrdRunOutcomeToCommandResult(outcome, options);
 }
-function resolvePrdRunBaseBranch(options) {
-  const raw = options.baseBranchOverride ?? options.targetBaseBranch;
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: value is empty after trimming.`,
-      diagnostics: [`Provided branch value: "${raw}"`],
-      offendingPaths: []
-    };
-  }
-  if (trimmed.startsWith("origin/")) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" must not include "origin/" prefix. Use just the branch lane name (e.g. "dev" instead of "origin/dev").`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  if (/^(refs\/|heads\/|remotes\/|tags\/)/.test(trimmed)) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" must be a simple branch lane name, not a ref specification.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  if (/^[0-9a-f]{7,40}$/i.test(trimmed)) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: value looks like a commit SHA rather than a branch lane name.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  const segments = trimmed.split("/");
-  for (const segment of segments) {
-    if (segment === "." || segment === ".." || segment === "") {
-      return {
-        ok: false,
-        gate: "branch-state",
-        reason: `Invalid PRD Run base branch: "${trimmed}" must not contain ".", "..", or empty segments.`,
-        diagnostics: [`Provided branch value: "${trimmed}"`],
-        offendingPaths: []
-      };
-    }
-  }
-  if (/[~^:?*\[\\]/.test(trimmed)) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" contains invalid characters (~ ^ : ? * [ \\).`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  if (/[\x00-\x1f\x7f]/.test(trimmed)) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: value contains control characters.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  if (trimmed.endsWith("/")) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with a trailing slash.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  if (trimmed.endsWith(".lock")) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with ".lock" suffix.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  const source = options.baseBranchOverride !== void 0 ? "override" : "target";
-  return { ok: true, baseBranch: trimmed, source };
+async function runPrdRunStartCommand(options) {
+  const outcome = await startPrdRun(options);
+  return mapStartPrdRunOutcomeToCommandResult(outcome);
 }
-function fetchOriginBranch(repoRoot2, baseBranch) {
-  const fetchResult = spawnSync3("git", ["fetch", "origin", baseBranch], {
-    cwd: repoRoot2,
-    encoding: "utf8"
-  });
-  if (fetchResult.status !== 0) {
+function mapLaunchPrdRunOutcomeToCommandResult(outcome, options) {
+  const prdRef = normalizePrdRunRef(options.prdRef);
+  if (outcome.kind === "already-terminal") {
+    const diagnostics = [
+      `PRD Run ${prdRef} is already in status "${outcome.status}".`,
+      ...outcome.status === "completed_prd_branch" ? [buildCompletedPrdBranchHint(outcome.prdBranch ?? prdRef)] : [],
+      ...outcome.status === "completed_local_branch" ? [
+        `Local PRD Run ${prdRef} completed. Branch: ${outcome.prdBranch ?? `local/${prdRef}`}.`
+      ] : []
+    ];
     return {
-      ok: false,
-      gate: "git",
-      reason: `PRD Run start failed while fetching origin/${baseBranch}.`,
-      diagnostics: [
-        fetchResult.error instanceof Error ? fetchResult.error.message : void 0,
-        fetchResult.stderr?.toString?.() ?? String(fetchResult.stderr ?? ""),
-        fetchResult.stdout?.toString?.() ?? String(fetchResult.stdout ?? "")
-      ].filter((value) => Boolean(value && value.trim())),
-      offendingPaths: []
+      prdRef,
+      status: outcome.status,
+      attempted: [...outcome.resume.attempted],
+      skipped: [...outcome.resume.skipped],
+      resumed: [...outcome.resume.resumed],
+      diagnostics,
+      prdBranch: outcome.prdBranch
     };
   }
-  const revParseResult = spawnSync3(
-    "git",
-    ["rev-parse", `origin/${baseBranch}`],
-    {
-      cwd: repoRoot2,
-      encoding: "utf8"
-    }
-  );
-  if (revParseResult.status !== 0) {
+  if (outcome.kind === "blocked") {
+    const diagnostics = outcome.guidance.diagnostics ? [...outcome.guidance.diagnostics] : [outcome.guidance.reason];
     return {
-      ok: false,
-      gate: "git",
-      reason: `PRD Run start failed while resolving origin/${baseBranch}.`,
-      diagnostics: [
-        revParseResult.error instanceof Error ? revParseResult.error.message : void 0,
-        revParseResult.stderr?.toString?.() ?? String(revParseResult.stderr ?? ""),
-        revParseResult.stdout?.toString?.() ?? String(revParseResult.stdout ?? "")
-      ].filter((value) => Boolean(value && value.trim())),
-      offendingPaths: []
+      prdRef,
+      status: "blocked",
+      attempted: [...outcome.resume.attempted],
+      skipped: [...outcome.resume.skipped],
+      resumed: [...outcome.resume.resumed],
+      diagnostics,
+      blockedGate: outcome.guidance.blockedGate,
+      blockedReason: outcome.guidance.reason,
+      offendingPaths: outcome.guidance.offendingPaths ? [...outcome.guidance.offendingPaths] : [],
+      start: outcome.start ? mapStartPrdRunOutcomeToCommandResult(outcome.start) : void 0
     };
   }
-  return { ok: true, startBaseCommit: revParseResult.stdout.trim() };
+  return {
+    prdRef,
+    status: outcome.status,
+    attempted: [...outcome.resume.attempted],
+    skipped: [...outcome.resume.skipped],
+    resumed: [...outcome.resume.resumed],
+    diagnostics: [...outcome.diagnostics],
+    prdBranch: outcome.prdBranch,
+    start: outcome.start ? mapStartPrdRunOutcomeToCommandResult(outcome.start) : void 0
+  };
 }
-function fetchPrdBranch(repoRoot2, prdRef) {
-  const result = spawnSync3("git", ["fetch", "origin", prdRef], {
-    cwd: repoRoot2,
-    encoding: "utf8"
-  });
-  if (result.status !== 0) {
+function mapStartPrdRunOutcomeToCommandResult(outcome) {
+  if (outcome.kind === "started") {
     return {
-      ok: false,
-      gate: "git",
-      reason: `PRD Run start failed while fetching origin/${prdRef}.`,
-      diagnostics: [
-        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())),
-      offendingPaths: []
+      prdRef: outcome.prdRef,
+      status: "starting",
+      start: outcome.start,
+      diagnostics: [...outcome.diagnostics]
     };
   }
-  return { ok: true };
-}
-async function ensurePrdBranchPublished(repoRoot2, prdRef, startBaseCommit) {
-  const pushResult = spawnSync3(
-    "git",
-    ["push", "origin", `${startBaseCommit}:refs/heads/${prdRef}`],
-    {
-      cwd: repoRoot2,
-      encoding: "utf8"
-    }
-  );
-  if (pushResult.status !== 0) {
-    throw new Error(
-      `Failed to create PRD Branch ${prdRef} from ${startBaseCommit}: ${[
-        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(" ")}`
-    );
-  }
+  const diagnostics = outcome.guidance.diagnostics ? [...outcome.guidance.diagnostics] : [outcome.guidance.reason];
+  return {
+    prdRef: outcome.prdRef,
+    status: "blocked",
+    blockedGate: outcome.guidance.blockedGate,
+    blockedReason: outcome.guidance.reason,
+    diagnostics,
+    offendingPaths: outcome.guidance.offendingPaths ? [...outcome.guidance.offendingPaths] : []
+  };
 }
 function runPrdRunStatusCommand(options) {
   const prdRef = normalizePrdRunRef(options.prdRef);
@@ -10336,49 +11101,9 @@ function runPrdRunStatusCommand(options) {
 function runPrdRunListCommand(options) {
   return listPrdRuns(options.repoRoot);
 }
-function persistBlockedPrdRunStartRecord(repoRoot2, prdRef, failure, context = {}) {
-  writePrdRunRecord(repoRoot2, {
-    prdRef,
-    status: "blocked",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    blockedGate: coercePrdRunRecordBlockedGate(failure.gate),
-    blockedReason: failure.reason,
-    diagnostics: buildBlockedDiagnostics(failure),
-    offendingPaths: failure.offendingPaths,
-    targetName: context.targetName
-  });
-}
-function coercePrdRunRecordBlockedGate(gate) {
-  switch (gate) {
-    case "receipt-check":
-    case "branch-state":
-    case "git":
-    case "queue":
-    case "final-review":
-      return gate;
-    default:
-      return "branch-state";
-  }
-}
 function buildCompletedPrdBranchHint(prdBranch) {
   return `PRD Run completed on branch ${prdBranch}. Next: checkout ${prdBranch} for human review, or use release promotion workflow when ready.`;
 }
-function buildBlockedDiagnostics(failure) {
-  return failure.diagnostics ?? [
-    failure.reason,
-    ...failure.offendingPaths.map((path9) => `Offending path: ${path9}`)
-  ];
-}
-function buildBlockedStartResult(prdRef, failure, manifestPath) {
-  return {
-    prdRef,
-    status: "blocked",
-    blockedGate: failure.gate,
-    blockedReason: failure.reason,
-    diagnostics: buildBlockedDiagnostics(failure),
-    offendingPaths: failure.offendingPaths.length > 0 ? failure.offendingPaths : manifestPath ? [manifestPath] : []
-  };
-}
 
 // commands/pr-create.ts
 init_common();
@@ -13326,6 +14051,14 @@ var GitHubPRProvider = class {
     this.logger.kv("PR_URL", pr.url);
     return pr;
   }
+  async commentPr(prNumber, body) {
+    await this.client.octokit.rest.issues.createComment({
+      owner: this.client.owner,
+      repo: this.client.repo,
+      issue_number: prNumber,
+      body
+    });
+  }
   async getPr(branchName) {
     try {
       const { data } = await this.client.octokit.rest.pulls.list({
@@ -13631,7 +14364,7 @@ init_common();
 
 // execution/sandcastle-execution.ts
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
@@ -13640,10 +14373,10 @@ init_common();
 import { mkdtempSync } from "fs";
 import { writeFile as writeFile4 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname6, join as join20 } from "path";
+import { dirname as dirname6, join as join21 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join20(worktreePath, artifact.path);
+    const filePath = join21(worktreePath, artifact.path);
     await ensureDir(dirname6(filePath));
     await writeFile4(filePath, artifact.content, "utf-8");
   }
@@ -13961,12 +14694,12 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join21(repoRoot2, ".pourkit", ".tmp", "prompts");
+  const promptsDir = join22(repoRoot2, ".pourkit", ".tmp", "prompts");
   mkdirSync9(promptsDir, { recursive: true });
   const timestamp2 = Date.now();
   const iterationSuffix = iteration !== void 0 ? `-iteration-${iteration}` : "";
   const filename = `${stage}${iterationSuffix}-${timestamp2}.md`;
-  const filePath = join21(promptsDir, filename);
+  const filePath = join22(promptsDir, filename);
   writeFileSync7(filePath, prompt, "utf-8");
 }
 
@@ -14660,11 +15393,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260614201555")) {
-    return "0.0.0-next-20260614201555";
+  if (isPackageVersion("0.0.0-next-20260615001408")) {
+    return "0.0.0-next-20260615001408";
   }
-  if (isReleaseVersion("0.0.0-next-20260614201555")) {
-    return "0.0.0-next-20260614201555";
+  if (isReleaseVersion("0.0.0-next-20260615001408")) {
+    return "0.0.0-next-20260615001408";
   }
   try {
     const root = repoRoot();