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

package/dist/cli.js

@@ -153,6 +153,7 @@ __export(common_exports, {
   execJson: () => execJson,
   parseWorktreeListPorcelain: () => parseWorktreeListPorcelain,
   readMaybeEnvInt: () => readMaybeEnvInt,
+  redactSensitiveValues: () => redactSensitiveValues,
   repoRelative: () => repoRelative,
   repoRoot: () => repoRoot,
   sleep: () => sleep,
@@ -311,7 +312,14 @@ function parseWorktreeListPorcelain(text2, branch) {
   }
   return null;
 }
-var execFileAsync, TRANSIENT_GH_ERROR, TYPE_LABELS;
+function redactSensitiveValues(input) {
+  let redacted = input;
+  for (const pattern of TOKEN_LIKE_PATTERNS) {
+    redacted = redacted.replace(pattern, "[REDACTED]");
+  }
+  return redacted;
+}
+var execFileAsync, TRANSIENT_GH_ERROR, TYPE_LABELS, TOKEN_LIKE_PATTERNS;
 var init_common = __esm({
   "shared/common.ts"() {
     "use strict";
@@ -325,6 +333,16 @@ var init_common = __esm({
       "type:polish",
       "type:refactor"
     ];
+    TOKEN_LIKE_PATTERNS = [
+      /gh[ps]_[A-Za-z0-9]{20,}/g,
+      /token[=:_\s][A-Za-z0-9_-]{20,}/gi,
+      /secret[=:_\s][A-Za-z0-9_-]{20,}/gi,
+      /credential[=:_\s][A-Za-z0-9_-]{20,}/gi,
+      /key[=:_\s][A-Za-z0-9_-]{20,}/gi,
+      /bearer\s+[A-Za-z0-9_-]{20,}/gi,
+      /authorization:\s*Bearer\s+[A-Za-z0-9_-]{20,}/gi,
+      /xox[baprs]-[A-Za-z0-9_-]{10,}/g
+    ];
   }
 });
 
@@ -335,13 +353,20 @@ import { pathToFileURL } from "url";
 import { Command, Option, CommanderError } from "commander";
 
 // shared/config.ts
-import { readFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, isAbsolute, join, normalize, sep, resolve } from "path";
 import Ajv from "ajv";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
-var SCHEMA_PATH = resolve(__dirname, "../schema/pourkit.schema.json");
+function resolvePackagedAssetPath(fileName) {
+  const candidates = [
+    resolve(__dirname, "schema", fileName),
+    resolve(__dirname, "../schema", fileName)
+  ];
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+var SCHEMA_PATH = resolvePackagedAssetPath("pourkit.schema.json");
 var _schema = null;
 var _validate = null;
 var _ajvErrors = null;
@@ -929,12 +954,12 @@ function resolveTarget(config, explicitTarget) {
 init_common();
 
 // shared/worktree-run-state.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
 var WORKTREE_RUN_STATE_PATH = ".pourkit/state.json";
 function readWorktreeRunState(worktreePath) {
   const statePath = join2(worktreePath, WORKTREE_RUN_STATE_PATH);
-  if (!existsSync(statePath)) {
+  if (!existsSync2(statePath)) {
     return null;
   }
   try {
@@ -1106,7 +1131,7 @@ async function cleanupRepository(options) {
 // commands/artifact-validation.ts
 import { createHash } from "crypto";
 import { execSync } from "child_process";
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
 import { isAbsolute as isAbsolute3, join as join7, resolve as resolve3 } from "path";
 
 // pr/review-verdict.ts
@@ -1140,7 +1165,7 @@ function parseReviewVerdict(output) {
 
 // commands/review.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync6,
   readdirSync as readdirSync2,
@@ -1149,7 +1174,7 @@ import {
 import { join as join6 } from "path";
 
 // execution/agent-output-retry.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync } from "fs";
 import { dirname as dirname3, join as join4 } from "path";
 async function executeWithMissingOrEmptyArtifactRetry({
   executionProvider,
@@ -1207,7 +1232,7 @@ async function executeWithMissingOrEmptyArtifactRetry({
   };
 }
 function readArtifactOutput(artifactPath) {
-  if (!existsSync2(artifactPath)) {
+  if (!existsSync3(artifactPath)) {
     return { _tag: "missing", path: artifactPath };
   }
   const output = readFileSync3(artifactPath, "utf-8");
@@ -1222,7 +1247,7 @@ function prepareArtifactPath(artifactPath) {
 }
 
 // shared/run-context.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync } from "fs";
 import { isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve2 } from "path";
 
 // commands/run-verification.ts
@@ -1371,13 +1396,6 @@ var STAGE_SECTIONS = {
     "branch",
     "verification-commands",
     "artifacts"
-  ],
-  prdReconciliation: [
-    "issue",
-    "comments",
-    "branch",
-    "verification-commands",
-    "artifacts"
   ]
 };
 function buildRunContextArtifact(options) {
@@ -1524,7 +1542,7 @@ function renderPrdContext(issue, parentPrdIssue, repoRoot2) {
   }
   for (const documentPath of documentPaths) {
     const absolutePath = resolveRepoPath(repoRoot2, documentPath);
-    if (!absolutePath || !existsSync3(absolutePath)) continue;
+    if (!absolutePath || !existsSync4(absolutePath)) continue;
     parts.push(
       `### Document Content: \`${documentPath}\``,
       "",
@@ -1561,27 +1579,20 @@ function resolveRepoPath(repoRoot2, path9) {
   return resolved;
 }
 function findParentPrdPath(repoRoot2, parentRef) {
-  const directPath = join5(
-    repoRoot2,
-    ".pourkit",
-    "architecture",
-    parentRef,
-    "PRD.md"
-  );
-  if (existsSync3(directPath)) return directPath;
-  const architectureRoot = join5(repoRoot2, ".pourkit", "architecture");
-  if (!existsSync3(architectureRoot)) return null;
-  return findPrdMirror(architectureRoot, parentRef);
+  const plansRoot = join5(repoRoot2, ".pourkit", "plans");
+  if (!existsSync4(plansRoot)) return null;
+  return findPrdInPlans(plansRoot, parentRef);
 }
-function findPrdMirror(directory, parentRef) {
+function findPrdInPlans(directory, parentRef) {
   for (const entry of readdirSync(directory, { withFileTypes: true })) {
     const entryPath = join5(directory, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name.startsWith(parentRef)) {
+      const prdNumber = parentRef.match(/^PRD-(\d+)$/)?.[1];
+      if (entry.name.startsWith(parentRef) || prdNumber && entry.name.startsWith(`${prdNumber}-`)) {
         const prdPath = join5(entryPath, "PRD.md");
-        if (existsSync3(prdPath)) return prdPath;
+        if (existsSync4(prdPath)) return prdPath;
       }
-      const nested = findPrdMirror(entryPath, parentRef);
+      const nested = findPrdInPlans(entryPath, parentRef);
       if (nested) return nested;
     }
   }
@@ -1613,7 +1624,7 @@ function appendProtectedWorkGuidance(promptBody) {
 
 // shared/effect-services.ts
 import { Context, Effect, Layer } from "effect";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
 var GitExecutionError = class extends Error {
   _tag = "GitExecutionError";
   message;
@@ -1641,7 +1652,7 @@ var FileSystemDefault = Layer.succeed(
       )
     }),
     exists: (path9) => Effect.try({
-      try: () => existsSync4(path9),
+      try: () => existsSync5(path9),
       catch: (error) => new Error(
         `Failed to check existence of ${path9}: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -2025,7 +2036,7 @@ function extractLatestFindingIds(reviewOutput, iteration) {
   return ids;
 }
 function validateRefactorArtifact(artifactPath, findingIds) {
-  if (!existsSync5(artifactPath)) {
+  if (!existsSync6(artifactPath)) {
     throw new RefactorArtifactValidationError(
       `Refactor artifact missing at ${artifactPath}`
     );
@@ -2516,14 +2527,14 @@ function recoverReviewOutputFromString(logContent) {
   return recoveredOutput.length > 0 ? recoveredOutput : null;
 }
 function recoverReviewOutputFromLog(logPath) {
-  if (!existsSync5(logPath)) {
+  if (!existsSync6(logPath)) {
     return null;
   }
   const logContent = readFileSync6(logPath, "utf-8");
   return recoverReviewOutputFromString(logContent);
 }
 function readReviewArtifact(artifactPath, logPath) {
-  if (existsSync5(artifactPath)) {
+  if (existsSync6(artifactPath)) {
     const output = readFileSync6(artifactPath, "utf-8");
     if (output.trim()) {
       return output;
@@ -2534,7 +2545,7 @@ function readReviewArtifact(artifactPath, logPath) {
     writeFileSync3(artifactPath, recoveredOutput, "utf-8");
     return recoveredOutput;
   }
-  if (!existsSync5(artifactPath)) {
+  if (!existsSync6(artifactPath)) {
     throw new Error(`Reviewer did not produce output at ${artifactPath}`);
   }
   throw new Error(`Reviewer produced empty output at ${artifactPath}`);
@@ -3173,194 +3184,6 @@ function parseConflictResolutionArtifact(output) {
   };
 }
 
-// prd-run/final-review-validation.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-function parseFinalReviewArtifact(artifactPath) {
-  if (!existsSync6(artifactPath)) {
-    return {
-      ok: false,
-      reason: "Final Review artifact not found.",
-      diagnostics: [`Artifact path: ${artifactPath}`]
-    };
-  }
-  let content;
-  try {
-    content = readFileSync7(artifactPath, "utf-8");
-  } catch (error) {
-    return {
-      ok: false,
-      reason: "Final Review artifact could not be read.",
-      diagnostics: [
-        error instanceof Error ? error.message : String(error),
-        `Artifact path: ${artifactPath}`
-      ]
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    return {
-      ok: false,
-      reason: "Final Review artifact is not valid JSON.",
-      diagnostics: [`Artifact path: ${artifactPath}`]
-    };
-  }
-  const verdict = parsed.verdict;
-  if (!verdict || typeof verdict !== "string") {
-    return {
-      ok: false,
-      reason: "Final Review artifact is missing a verdict field.",
-      diagnostics: [`Artifact content preview: ${content.slice(0, 300)}`]
-    };
-  }
-  const allowedVerdicts = [
-    "pass_no_changes",
-    "pass_with_retouch",
-    "needs_human_review",
-    "blocked"
-  ];
-  if (!allowedVerdicts.includes(verdict)) {
-    return {
-      ok: false,
-      reason: `Final Review artifact has unsupported verdict "${verdict}".`,
-      diagnostics: [`Allowed verdicts: ${allowedVerdicts.join(", ")}`]
-    };
-  }
-  const summary = typeof parsed.summary === "string" ? parsed.summary : typeof parsed.reason === "string" ? parsed.reason : String(verdict);
-  const diagnostics = Array.isArray(parsed.diagnostics) ? parsed.diagnostics : [];
-  const changedPaths = Array.isArray(parsed.changedPaths) ? parsed.changedPaths : void 0;
-  const isAutoSummary = !parsed.summary && !parsed.reason;
-  if (verdict === "pass_with_retouch" && (!changedPaths || changedPaths.length === 0) && isAutoSummary) {
-    return {
-      ok: false,
-      reason: 'Final Review artifact with "pass_with_retouch" verdict requires changed paths.',
-      diagnostics: [
-        "pass_with_retouch verdict must include a changedPaths array in the artifact or provide a summary/reason with enough context for git diff fallback.",
-        "Provide changedPaths or a descriptive summary in the artifact."
-      ]
-    };
-  }
-  const prdRef = typeof parsed.prdRef === "string" && parsed.prdRef.trim() ? parsed.prdRef.trim() : void 0;
-  const stage = typeof parsed.stage === "string" && parsed.stage.trim() ? parsed.stage.trim() : void 0;
-  const checkoutBase = typeof parsed.checkoutBase === "string" && parsed.checkoutBase.trim() ? parsed.checkoutBase.trim() : void 0;
-  const reviewBase = typeof parsed.reviewBase === "string" && parsed.reviewBase.trim() ? parsed.reviewBase.trim() : void 0;
-  return {
-    ok: true,
-    verdict,
-    summary,
-    diagnostics,
-    changedPaths,
-    prdRef,
-    stage,
-    checkoutBase,
-    reviewBase
-  };
-}
-function validateFinalReviewArtifactSemanticIds(artifact, context) {
-  const errors = [];
-  if (!artifact.prdRef) {
-    errors.push("Final Review artifact is missing prdRef.");
-  } else if (artifact.prdRef !== context.prdRef) {
-    errors.push(
-      `Final Review artifact prdRef "${artifact.prdRef}" does not match active PRD Run "${context.prdRef}".`
-    );
-  }
-  if (!artifact.stage) {
-    errors.push("Final Review artifact is missing stage field.");
-  } else if (artifact.stage !== "prdFinalReview") {
-    errors.push(
-      `Final Review artifact stage "${artifact.stage}" is not "prdFinalReview".`
-    );
-  }
-  if (!artifact.checkoutBase) {
-    errors.push("Final Review artifact is missing checkoutBase.");
-  } else if (artifact.checkoutBase !== context.prdBranch) {
-    errors.push(
-      `Final Review artifact checkoutBase "${artifact.checkoutBase}" does not match active PRD Branch "${context.prdBranch}".`
-    );
-  }
-  if (!artifact.reviewBase) {
-    errors.push("Final Review artifact is missing reviewBase.");
-  } else if (artifact.reviewBase !== context.mergeBase) {
-    errors.push(
-      `Final Review artifact reviewBase "${artifact.reviewBase}" does not match active merge base "${context.mergeBase}".`
-    );
-  }
-  if (errors.length > 0) {
-    return { ok: false, errors, blockedGate: "final-review" };
-  }
-  return { ok: true };
-}
-function validateFinalReviewRetouchScope(changedPaths) {
-  if (!changedPaths || changedPaths.length === 0) {
-    return {
-      ok: false,
-      reason: "Final Review retouch scope validation failed. No changed paths available. Provide changed paths or run Final Review with a summary that includes changed paths.",
-      diagnostics: ["Changed paths list is empty or undefined."],
-      offendingPaths: []
-    };
-  }
-  const offendingPaths = changedPaths.filter((p) => !isRetouchScopePath(p));
-  const allowedPaths = changedPaths.filter((p) => isRetouchScopePath(p));
-  if (allowedPaths.length === 0) {
-    return {
-      ok: false,
-      reason: "Final Review retouch scope validation failed. No implementation, test, or Changeset paths found for retouch.",
-      diagnostics: [
-        "All changed paths are prohibited for retouch.",
-        ...changedPaths.map((p) => `  - ${p}`)
-      ],
-      offendingPaths
-    };
-  }
-  if (offendingPaths.length > 0) {
-    return {
-      ok: false,
-      reason: "Final Review retouch scope validation failed. Prohibited paths cannot be included in retouch PR.",
-      diagnostics: [
-        "Prohibited paths found:",
-        ...offendingPaths.map((p) => `  - ${p}`)
-      ],
-      offendingPaths
-    };
-  }
-  return { ok: true, changedPaths };
-}
-function validateFinalReviewAgentOutputs(options) {
-  const artifact = parseFinalReviewArtifact(options.artifactPath);
-  if (!artifact.ok) {
-    return { ...artifact, offendingPaths: [] };
-  }
-  const semanticResult = validateFinalReviewArtifactSemanticIds(
-    artifact,
-    options.context
-  );
-  if (!semanticResult.ok) {
-    return {
-      ok: false,
-      reason: "Final Review artifact has mismatched semantic IDs.",
-      diagnostics: semanticResult.errors,
-      offendingPaths: []
-    };
-  }
-  if (artifact.verdict !== "pass_with_retouch") {
-    return { ok: true, artifact };
-  }
-  const changedPaths = options.changedPaths && options.changedPaths.length > 0 ? options.changedPaths : artifact.changedPaths;
-  const retouch = validateFinalReviewRetouchScope(changedPaths ?? []);
-  if (!retouch.ok) {
-    return retouch;
-  }
-  return { ok: true, artifact, retouch };
-}
-function isRetouchScopePath(path9) {
-  if (path9.startsWith(".pourkit/plans/") || path9 === ".pourkit/CONTEXT.md" || path9.startsWith(".pourkit/docs/") || /^\.pourkit\/prd-runs\/[^/]+\.json$/.test(path9)) {
-    return false;
-  }
-  return true;
-}
-
 // commands/artifact-validation.ts
 var CONFLICT_MARKER_PATTERN = /<<<<<<<|=======|>>>>>>>/m;
 function invalid(options, reason, diagnostics = []) {
@@ -3388,7 +3211,7 @@ function readArtifact(options) {
     };
   }
   try {
-    const content = readFileSync8(options.artifactPath, "utf-8");
+    const content = readFileSync7(options.artifactPath, "utf-8");
     if (!content.trim()) {
       return { ok: false, result: invalid(options, "Artifact is empty") };
     }
@@ -3559,7 +3382,7 @@ function validateAgentArtifact(options) {
       case "refactor": {
         let findingIds = options.findingIds ?? [];
         if (findingIds.length === 0 && options.latestReviewArtifactPath) {
-          const latestReview = readFileSync8(
+          const latestReview = readFileSync7(
             options.latestReviewArtifactPath,
             "utf-8"
           );
@@ -3585,7 +3408,7 @@ function validateAgentArtifact(options) {
             const filePath = resolve3(base, file);
             try {
               return CONFLICT_MARKER_PATTERN.test(
-                readFileSync8(filePath, "utf-8")
+                readFileSync7(filePath, "utf-8")
               );
             } catch {
               return false;
@@ -3601,29 +3424,6 @@ function validateAgentArtifact(options) {
         }
         return valid(options, [`status: ${parsed.status}`]);
       }
-      // QUARANTINED: Retained for Issue Final Review artifact validation via
-      // `runPrdRunValidateFinalReviewCommand`. Remove when Issue Final Review
-      // is migrated to its own dedicated validator kind.
-      case "final-review": {
-        if (!options.prdRef || !options.checkoutBase || !options.reviewBase) {
-          return invalid(
-            options,
-            "Final Review artifact validation requires --prd-ref, --checkout-base, and --review-base."
-          );
-        }
-        const result = validateFinalReviewAgentOutputs({
-          artifactPath: options.artifactPath,
-          context: {
-            prdRef: options.prdRef,
-            prdBranch: options.checkoutBase,
-            mergeBase: options.reviewBase
-          }
-        });
-        if (!result.ok) {
-          return invalid(options, result.reason, result.diagnostics);
-        }
-        return valid(options, [`verdict: ${result.artifact.verdict}`]);
-      }
       case "issue-final-review": {
         if (options.issueNumber === void 0 || !options.branchName) {
           return invalid(
@@ -3663,12 +3463,6 @@ function validateAgentArtifact(options) {
         }
         return valid(options, [`decision: ${parsed.json.recoveryDecision}`]);
       }
-      case "reconciliation":
-      case "planning-manifest":
-        return invalid(
-          options,
-          `Artifact kind "${options.kind}" has been removed from PRD Run validation`
-        );
       case "local-prd":
       case "local-issue":
       case "local-triage":
@@ -3749,7 +3543,7 @@ function runLocalValidateArtifactCommand(options) {
 }
 function readLocalArtifact(path9, failureCode) {
   try {
-    const raw = readFileSync8(path9, "utf-8");
+    const raw = readFileSync7(path9, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return {
@@ -4448,7 +4242,7 @@ function validateLocalTriage(prdPath, issuePaths) {
 }
 
 // commands/issue-run.ts
-import { existsSync as existsSync12, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
 import { isAbsolute as isAbsolute4, join as join15 } from "path";
 
 // pr/templates.ts
@@ -4584,7 +4378,7 @@ function runEffectAndMapExit(program) {
 }
 
 // shared/attempt-log.ts
-import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync9 } from "fs";
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
 import { dirname as dirname4, join as join8 } from "path";
 var ATTEMPT_LOG_PATH = ".pourkit/attempt-log.jsonl";
 function writeAttemptLog(worktreePath, entry) {
@@ -4597,7 +4391,7 @@ function readAttemptLog(worktreePath) {
   if (!existsSync8(logPath)) {
     return [];
   }
-  const raw = readFileSync9(logPath, "utf-8");
+  const raw = readFileSync8(logPath, "utf-8");
   const lines = raw.split("\n").filter((l) => l.length > 0);
   const entries = [];
   for (const line of lines) {
@@ -4716,7 +4510,7 @@ async function runBaseRefreshAttempt(options) {
 }
 
 // commands/conflict-resolution.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
 import { join as join9 } from "path";
 init_common();
 var CONFLICT_MARKER_PATTERN2 = /<<<<<<<|=======|>>>>>>>/m;
@@ -4724,7 +4518,7 @@ async function hasUnresolvedConflictMarkers(worktreePath, files) {
   for (const file of files) {
     const filePath = join9(worktreePath, file);
     try {
-      const content = readFileSync10(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       if (CONFLICT_MARKER_PATTERN2.test(content)) {
         return true;
       }
@@ -5055,7 +4849,7 @@ async function prepareSerenaForTarget(options) {
 }
 
 // failure-resolution/failure-resolution-agent.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { join as join10 } from "path";
 
 // failure-resolution/recovery-policy.ts
@@ -5209,7 +5003,7 @@ async function runFailureResolutionAgent(options) {
   }
   let artifact;
   try {
-    const md = readFileSync11(fullArtifactPath, "utf-8");
+    const md = readFileSync10(fullArtifactPath, "utf-8");
     const validation2 = validateAgentArtifact({
       kind: "failure-resolution",
       artifactPath: fullArtifactPath,
@@ -5303,7 +5097,7 @@ async function writeRecoveryAttempt(worktreePath, outcome, fingerprint, summary,
 
 // commands/pr-description-agent.ts
 import { join as join12 } from "path";
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 
 // pr/pr-description-context.ts
 init_common();
@@ -5497,7 +5291,7 @@ function runFinalizerAgent(options) {
       ],
       logger: options.logger
     });
-    const output = readFileSync12(artifactPath, "utf-8");
+    const output = readFileSync11(artifactPath, "utf-8");
     yield* persistGeneratedArtifactEffect(options.worktreePath, output, fs);
     return result;
   });
@@ -5625,7 +5419,7 @@ function persistGeneratedArtifactEffect(worktreePath, output, fs) {
 
 // prd-run/local-merge-coordinator.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
 import { join as join13 } from "path";
 
 // prd-run/local-branches.ts
@@ -5728,7 +5522,7 @@ function readIssueBranchName(repoRoot2, prdId, issueId) {
   const issuePath = getIssueArtifactPath(repoRoot2, prdId, issueId);
   if (!existsSync10(issuePath)) return null;
   try {
-    const content = readFileSync13(issuePath, "utf-8");
+    const content = readFileSync12(issuePath, "utf-8");
     const parsed = JSON.parse(content);
     return typeof parsed.branchName === "string" && parsed.branchName ? parsed.branchName : null;
   } catch {
@@ -5740,7 +5534,7 @@ async function hasLocalIssueMergeReceipt(prdId, issueId, repoRoot2) {
   const receiptPath = getMergeReceiptPath(root, prdId, issueId);
   if (!existsSync10(receiptPath)) return null;
   try {
-    const content = readFileSync13(receiptPath, "utf-8");
+    const content = readFileSync12(receiptPath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed.prdId === "string" && typeof parsed.issueId === "string" && typeof parsed.stage === "string" && typeof parsed.sourceBranch === "string" && typeof parsed.localPrdBranch === "string" && typeof parsed.mergeCommit === "string" && typeof parsed.completedAt === "string") {
       return parsed;
@@ -5756,7 +5550,7 @@ async function squashMergeLocalIssue(prdId, issueId, input, repoRoot2) {
   if (existsSync10(receiptPath)) {
     try {
       const existing = JSON.parse(
-        readFileSync13(receiptPath, "utf-8")
+        readFileSync12(receiptPath, "utf-8")
       );
       if (existing.prdId === prdId && existing.issueId === issueId && existing.mergeCommit) {
         return {
@@ -6165,7 +5959,7 @@ function runMergeCoordinator(options) {
 }
 
 // commands/issue-final-review-agent.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
 import { join as join14 } from "path";
 var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join14(
   ".pourkit",
@@ -6279,7 +6073,7 @@ async function runIssueFinalReviewAgent(options) {
 }
 function loadIssueFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync11(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync11(promptPath) ? readFileSync13(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -6901,7 +6695,7 @@ async function completeIssueRun(options) {
               message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
             });
           }
-          const artifactContent = readFileSync15(
+          const artifactContent = readFileSync14(
             finalizerFromState.artifactPath,
             "utf-8"
           );
@@ -7615,7 +7409,7 @@ async function syncTargetBranch(root, baseBranch, logger) {
 }
 function loadBuilderPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync12(promptPath) ? readFileSync15(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync12(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -8106,26 +7900,16 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 }
 
 // commands/prd-run.ts
-import {
-  cpSync,
-  existsSync as existsSync16,
-  lstatSync,
-  mkdirSync as mkdirSync10,
-  mkdtempSync,
-  readFileSync as readFileSync18,
-  realpathSync,
-  rmSync as rmSync3
-} from "fs";
+import { existsSync as existsSync16, lstatSync, readFileSync as readFileSync18, realpathSync } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { dirname as dirname5, join as join20, relative as relative2 } from "path";
-import { tmpdir } from "os";
+import { join as join19, relative as relative2 } from "path";
 import { Match, pipe } from "effect";
 
 // prd-run/state.ts
 import {
   existsSync as existsSync13,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync4,
   writeFileSync as writeFileSync5
 } from "fs";
@@ -8225,12 +8009,12 @@ function readPrdRun(repoRoot2, prdRef) {
     return { record: null, diagnostics: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync16(recordPath, "utf-8"));
+    const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
     const parsed = normalizeLegacyPrdRunRecord(PrdRunRecordSchema.parse(raw));
     return { record: parsed, diagnostics: [] };
   } catch (error) {
     try {
-      const raw = JSON.parse(readFileSync16(recordPath, "utf-8"));
+      const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
       if (raw && typeof raw === "object" && raw.start && typeof raw.start === "object" && raw.start.startBaseBranch === void 0) {
         return {
           record: raw,
@@ -8264,7 +8048,7 @@ function listPrdRuns(repoRoot2) {
     const recordPath = join16(stateDir, entry.name);
     try {
       const record = normalizeLegacyPrdRunRecord(
-        PrdRunRecordSchema.parse(JSON.parse(readFileSync16(recordPath, "utf-8")))
+        PrdRunRecordSchema.parse(JSON.parse(readFileSync15(recordPath, "utf-8")))
       );
       records.push(record);
     } catch (error) {
@@ -8339,26 +8123,9 @@ function getRecordPath(repoRoot2, prdRef) {
   );
 }
 
-// prd-run/evidence-packet.ts
-import { createHash as createHash2 } from "crypto";
-import { z as z2 } from "zod";
-var PRD_REF_REGEX2 = /^PRD-\d{3,4}$/;
-var StageSchema = z2.enum(["prdFinalReview", "prdReconciliation"]);
-var EvidencePacketSchema = z2.object({
-  prdRef: z2.string().regex(PRD_REF_REGEX2),
-  prdBranch: z2.string().min(1),
-  mergeBase: z2.string().min(6),
-  planningManifestPath: z2.string().min(1),
-  planningManifestFacts: z2.object({
-    parentPrdIssueUrl: z2.string().min(1),
-    childIssueCount: z2.number().int().nonnegative()
-  }),
-  stage: StageSchema,
-  stageReceipts: z2.record(z2.string(), z2.unknown())
-}).strict();
-
-// commands/prd-run.ts
-init_common();
+// prd-run/local-queue-loop.ts
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
+import { join as join18 } from "path";
 
 // prd-run/local-artifacts.ts
 import { existsSync as existsSync14 } from "fs";
@@ -8501,75 +8268,8 @@ async function resolveLocalIssueArtifacts(prdId, repoRoot2) {
   return { ok: true, data: issues };
 }
 
-// prd-run/local-issue-adapter.ts
-var VALID_TRIAGE_LABELS = /* @__PURE__ */ new Set([
-  "needs-triage",
-  "ready-for-agent",
-  "blocked",
-  "ready-for-human",
-  "wontfix"
-]);
-function countTypeLabels(labels) {
-  return labels.filter((l) => l.startsWith("type:")).length;
-}
-function countTriageLabels(labels) {
-  return labels.filter((l) => VALID_TRIAGE_LABELS.has(l)).length;
-}
-function countCategoryLabels(labels) {
-  const triageCount = countTriageLabels(labels);
-  const typeCount = countTypeLabels(labels);
-  return labels.length - triageCount - typeCount;
-}
-function hasValidLabels(labels) {
-  if (countTriageLabels(labels) !== 1) return false;
-  if (!labels.includes("ready-for-agent")) return false;
-  if (countTypeLabels(labels) !== 1) return false;
-  if (countCategoryLabels(labels) !== 1) return false;
-  return true;
-}
-function isIssueBlockedByDependencies(issue, issues) {
-  const blockers = [];
-  for (const depId of issue.dependencyIssueIds) {
-    const dep = issues.find((i) => i.id === depId);
-    if (!dep || dep.receipts.completedAt === null) {
-      blockers.push(depId);
-    }
-  }
-  return blockers;
-}
-async function getRunnableLocalIssues(prdId, repoRoot2) {
-  const issuesResult = await resolveLocalIssueArtifacts(prdId, repoRoot2);
-  if (!issuesResult.ok) return [];
-  const issues = issuesResult.data;
-  const runnable = [];
-  for (const issue of issues) {
-    if (!hasValidLabels(issue.labels)) continue;
-    if (issue.status !== "ready-for-agent") continue;
-    const blockers = isIssueBlockedByDependencies(issue, issues);
-    runnable.push({
-      id: issue.id,
-      title: issue.title,
-      labels: issue.labels,
-      blockedBy: blockers.length > 0 ? blockers : void 0
-    });
-  }
-  const filtered = runnable.filter(
-    (i) => !i.blockedBy || i.blockedBy.length === 0
-  );
-  return filtered;
-}
-
-// prd-run/local-final-review.ts
-import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join18 } from "path";
-
-// prd-run/local-queue-loop.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync7 } from "fs";
-import { join as join19 } from "path";
-
 // prd-run/local-issue-run.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 init_common();
 async function createLocalIssueBranch(prdId, issueId, repoRoot2) {
   const root = repoRoot2 ?? process.cwd();
@@ -8593,7 +8293,7 @@ async function createLocalIssueBranch(prdId, issueId, repoRoot2) {
   }
   const localPrdBranch = `local/${prdId}`;
   try {
-    execFileSync4(
+    execFileSync3(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${localPrdBranch}`],
       {
@@ -8609,7 +8309,7 @@ async function createLocalIssueBranch(prdId, issueId, repoRoot2) {
   }
   let branchExists = false;
   try {
-    execFileSync4(
+    execFileSync3(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
       {
@@ -8622,7 +8322,7 @@ async function createLocalIssueBranch(prdId, issueId, repoRoot2) {
   } catch {
   }
   if (!branchExists) {
-    execFileSync4("git", ["checkout", "-b", branchName, localPrdBranch], {
+    execFileSync3("git", ["checkout", "-b", branchName, localPrdBranch], {
       cwd: root,
       encoding: "utf8",
       stdio: "pipe"
@@ -8687,11 +8387,69 @@ async function runLocalIssue(prdId, issueId, builder, repoRoot2) {
   }
 }
 
+// prd-run/local-issue-adapter.ts
+var VALID_TRIAGE_LABELS = /* @__PURE__ */ new Set([
+  "needs-triage",
+  "ready-for-agent",
+  "blocked",
+  "ready-for-human",
+  "wontfix"
+]);
+function countTypeLabels(labels) {
+  return labels.filter((l) => l.startsWith("type:")).length;
+}
+function countTriageLabels(labels) {
+  return labels.filter((l) => VALID_TRIAGE_LABELS.has(l)).length;
+}
+function countCategoryLabels(labels) {
+  const triageCount = countTriageLabels(labels);
+  const typeCount = countTypeLabels(labels);
+  return labels.length - triageCount - typeCount;
+}
+function hasValidLabels(labels) {
+  if (countTriageLabels(labels) !== 1) return false;
+  if (!labels.includes("ready-for-agent")) return false;
+  if (countTypeLabels(labels) !== 1) return false;
+  if (countCategoryLabels(labels) !== 1) return false;
+  return true;
+}
+function isIssueBlockedByDependencies(issue, issues) {
+  const blockers = [];
+  for (const depId of issue.dependencyIssueIds) {
+    const dep = issues.find((i) => i.id === depId);
+    if (!dep || dep.receipts.completedAt === null) {
+      blockers.push(depId);
+    }
+  }
+  return blockers;
+}
+async function getRunnableLocalIssues(prdId, repoRoot2) {
+  const issuesResult = await resolveLocalIssueArtifacts(prdId, repoRoot2);
+  if (!issuesResult.ok) return [];
+  const issues = issuesResult.data;
+  const runnable = [];
+  for (const issue of issues) {
+    if (!hasValidLabels(issue.labels)) continue;
+    if (issue.status !== "ready-for-agent") continue;
+    const blockers = isIssueBlockedByDependencies(issue, issues);
+    runnable.push({
+      id: issue.id,
+      title: issue.title,
+      labels: issue.labels,
+      blockedBy: blockers.length > 0 ? blockers : void 0
+    });
+  }
+  const filtered = runnable.filter(
+    (i) => !i.blockedBy || i.blockedBy.length === 0
+  );
+  return filtered;
+}
+
 // prd-run/local-queue-loop.ts
 var CHILD_CLEANUP_LABELS = ["agent-in-progress", "pr-open-awaiting-merge"];
 var LOCAL_ISSUE_ID_REGEX = /^I-(\d+)$/i;
 function getIssueArtifactPath2(repoRoot2, prdId, issueId) {
-  return join19(
+  return join18(
     repoRoot2,
     ".pourkit",
     "local-prd-runs",
@@ -8702,7 +8460,7 @@ function getIssueArtifactPath2(repoRoot2, prdId, issueId) {
 }
 function readIssueArtifact(repoRoot2, prdId, issueId) {
   try {
-    const content = readFileSync17(
+    const content = readFileSync16(
       getIssueArtifactPath2(repoRoot2, prdId, issueId),
       "utf-8"
     );
@@ -8712,7 +8470,7 @@ function readIssueArtifact(repoRoot2, prdId, issueId) {
   }
 }
 function writeIssueArtifact(repoRoot2, prdId, issue) {
-  writeFileSync7(
+  writeFileSync6(
     getIssueArtifactPath2(repoRoot2, prdId, issue.id),
     JSON.stringify(issue, null, 2),
     "utf-8"
@@ -9378,6 +9136,9 @@ 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) {
   if (!record) return { attempted: [], skipped: [], resumed: [] };
@@ -9439,10 +9200,10 @@ function planLaunchResume(record) {
   );
 }
 function validateLocalStartStore(repoRoot2, prdRef) {
-  const localStoreDir = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  const localStoreDir = join19(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
   let localStoreReady = false;
   if (existsSync16(localStoreDir)) {
-    const localStorePath = join20(localStoreDir, "prd.json");
+    const localStorePath = join19(localStoreDir, "prd.json");
     try {
       const content = JSON.parse(readFileSync18(localStorePath, "utf8"));
       localStoreReady = content?.id === prdRef && content?.kind === "prd";
@@ -9614,7 +9375,7 @@ async function runPrdRunLaunchCommand(options) {
     attempted.push("queue");
   }
   const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
-  const localStorePath = join20(
+  const localStorePath = join19(
     options.repoRoot,
     ".pourkit",
     "local-prd-runs",
@@ -10131,7 +9892,7 @@ async function processStartResult(startResult, options) {
     start,
     mode: modeForRecord
   });
-  const localStorePath = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  const localStorePath = join19(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
   if (existsSync16(localStorePath)) {
     const queueResult = await runLocalQueueLoop(
       prdRef,
@@ -11029,7 +10790,7 @@ import {
   rename,
   writeFile as writeFile2
 } from "fs/promises";
-import { createHash as createHash3, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 import path5 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -11505,7 +11266,7 @@ async function walkDir(dir) {
 }
 async function computeFileChecksum(filePath) {
   const content = await readFile5(filePath);
-  return createHash3("sha256").update(content).digest("hex");
+  return createHash2("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
   return existsSync17(path5.join(root, name));
@@ -13180,16 +12941,20 @@ async function runSerenaStatusCommand(options) {
 // commands/config-schema.ts
 import { readFileSync as readFileSync19, existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve4, dirname as dirname6 } from "path";
+import { resolve as resolve4, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import Ajv2 from "ajv";
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname6(__filename2);
-var PACKAGED_SCHEMA_PATH = resolve4(
-  __dirname2,
-  "../schema/pourkit.schema.json"
-);
-var PACKAGED_HASH_PATH = resolve4(__dirname2, "../schema/pourkit.schema.hash");
+var __dirname2 = dirname5(__filename2);
+function resolvePackagedAssetPath2(fileName) {
+  const candidates = [
+    resolve4(__dirname2, "schema", fileName),
+    resolve4(__dirname2, "../schema", fileName)
+  ];
+  return candidates.find((candidate) => existsSync18(candidate)) ?? candidates[0];
+}
+var PACKAGED_SCHEMA_PATH = resolvePackagedAssetPath2("pourkit.schema.json");
+var PACKAGED_HASH_PATH = resolvePackagedAssetPath2("pourkit.schema.hash");
 var _schemaValidator = null;
 var _schemaErrors = null;
 function getSchemaValidator() {
@@ -13865,21 +13630,21 @@ function formatChecks2(checks) {
 init_common();
 
 // execution/sandcastle-execution.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync8 } from "fs";
-import { join as join22 } from "path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "fs";
+import { join as join21 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
 // execution/execution-provider.ts
 init_common();
-import { mkdtempSync as mkdtempSync2 } from "fs";
+import { mkdtempSync } from "fs";
 import { writeFile as writeFile4 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname7, join as join21 } from "path";
+import { tmpdir } from "os";
+import { dirname as dirname6, join as join20 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join21(worktreePath, artifact.path);
-    await ensureDir(dirname7(filePath));
+    const filePath = join20(worktreePath, artifact.path);
+    await ensureDir(dirname6(filePath));
     await writeFile4(filePath, artifact.content, "utf-8");
   }
 }
@@ -13889,7 +13654,7 @@ init_common();
 import path7 from "path";
 
 // execution/sandbox-image.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync19, readFileSync as readFileSync20 } from "fs";
 import path6 from "path";
 function sandboxImageName(repoRoot2) {
@@ -13900,7 +13665,7 @@ function sandboxImageName(repoRoot2) {
   if (!existsSync19(dockerfilePath)) {
     return `sandcastle:${baseName}`;
   }
-  const fingerprint = createHash4("sha256").update(readFileSync20(dockerfilePath)).digest("hex").slice(0, 8);
+  const fingerprint = createHash3("sha256").update(readFileSync20(dockerfilePath)).digest("hex").slice(0, 8);
   return `sandcastle:${baseName}-${fingerprint}`;
 }
 
@@ -14196,13 +13961,13 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join22(repoRoot2, ".pourkit", ".tmp", "prompts");
-  mkdirSync11(promptsDir, { recursive: true });
+  const promptsDir = join21(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 = join22(promptsDir, filename);
-  writeFileSync8(filePath, prompt, "utf-8");
+  const filePath = join21(promptsDir, filename);
+  writeFileSync7(filePath, prompt, "utf-8");
 }
 
 // cli.ts
@@ -14302,7 +14067,7 @@ function createCliProgram(version) {
   });
   program.command("validate-artifact").description("Validate an agent handoff artifact").argument(
     "<kind>",
-    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, final-review (retained for Issue Final Review validation), failure-resolution, local-prd, local-issue, local-triage, or issue-final-review"
+    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, failure-resolution, local-prd, local-issue, local-triage, or issue-final-review"
   ).argument("<artifactPath>", "artifact path to validate").argument("[extraPaths...]", "additional artifact paths (for local-triage)").option("--iteration <number>", "review/refactor iteration", (value) => {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed < 1) {
@@ -14335,12 +14100,6 @@ function createCliProgram(version) {
       return previous;
     },
     []
-  ).option("--prd-ref <ref>", "PRD ref for final-review artifacts").option(
-    "--checkout-base <ref>",
-    "checkout base / PRD branch for final-review artifacts"
-  ).option(
-    "--review-base <ref>",
-    "review merge base for final-review artifacts"
   ).option(
     "--issue-number <number>",
     "issue number for issue-final-review artifacts",
@@ -14365,7 +14124,6 @@ function createCliProgram(version) {
         "refactor",
         "finalizer",
         "conflict-resolution",
-        "final-review",
         "failure-resolution",
         "local-prd",
         "local-issue",
@@ -14399,9 +14157,6 @@ function createCliProgram(version) {
         findingIds: options.findingId,
         latestReviewArtifactPath: options.latestReviewArtifact,
         allowedDecisions: options.allowedDecision,
-        prdRef: options.prdRef,
-        checkoutBase: options.checkoutBase,
-        reviewBase: options.reviewBase,
         issueNumber: options.issueNumber,
         branchName: options.branchName,
         checkConflictMarkers: options.checkConflictMarkers
@@ -14905,11 +14660,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260614074434")) {
-    return "0.0.0-next-20260614074434";
+  if (isPackageVersion("0.0.0-next-20260614201555")) {
+    return "0.0.0-next-20260614201555";
   }
-  if (isReleaseVersion("0.0.0-next-20260614074434")) {
-    return "0.0.0-next-20260614074434";
+  if (isReleaseVersion("0.0.0-next-20260614201555")) {
+    return "0.0.0-next-20260614201555";
   }
   try {
     const root = repoRoot();