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

package/dist/cli.js

@@ -776,13 +776,17 @@ function getVerificationCommands(target) {
 }
 function resolvePrdRunMode(target, opts) {
   if (opts?.localOverride === true) {
-    return { mode: "local", source: "cli-override" };
+    return { mode: "local", source: "cli-override", targetName: target.name };
   }
   const configMode = target.strategy.prdRun?.mode;
   if (configMode) {
-    return { mode: configMode, source: "target-config" };
+    return {
+      mode: configMode,
+      source: "target-config",
+      targetName: target.name
+    };
   }
-  return { mode: "github", source: "default" };
+  return { mode: "github", source: "default", targetName: target.name };
 }
 async function loadRepoConfig(repoRoot2, configFileName = "pourkit.config.ts") {
   const { existsSync: existsSync20 } = await import("fs");
@@ -1350,13 +1354,7 @@ function buildRunContextMarkdown(options) {
     );
   }
   if (sections.includes("verification-commands")) {
-    parts.push(
-      ...renderCommandList(
-        target,
-        getVerificationCommands(target),
-        "Verification Commands"
-      )
-    );
+    parts.push(...renderCommandList(target, "Verification Commands"));
   }
   if (sections.includes("review-criteria")) {
     parts.push(...renderCriteria(reviewerCriteria));
@@ -1374,29 +1372,11 @@ function buildRunContextMarkdown(options) {
   }
   return parts.join("\n");
 }
-function renderCommandList(target, commands, heading) {
-  if (commands.length === 0) {
-    return [
-      `## ${heading}`,
-      "",
-      `Run this command from the repository root: \`${buildRunVerificationCommand(target)}\``,
-      "",
-      "Underlying project commands:",
-      "",
-      "(none configured)",
-      ""
-    ];
-  }
+function renderCommandList(target, heading) {
   return [
     `## ${heading}`,
     "",
     `Run this command from the repository root: \`${buildRunVerificationCommand(target)}\``,
-    "",
-    "Underlying project commands:",
-    "",
-    "Run these commands from the repository root exactly as written. Do not substitute equivalent scripts from nested package.json files.",
-    "",
-    ...commands.map((command) => `- ${command.label}: \`${command.command}\``),
     ""
   ];
 }
@@ -6158,10 +6138,57 @@ import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as rea
 import { join as join13 } from "path";
 
 // prd-run/local-branches.ts
-import { execFileSync } from "child_process";
+import { execFileSync, spawnSync as spawnSync2 } from "child_process";
 function getLocalPrdBranchName(prdId) {
   return `local/${prdId}`;
 }
+function materializeLocalPrdBranch(prdId, startBaseCommit, repoRoot2) {
+  const branch = getLocalPrdBranchName(prdId);
+  const root = repoRoot2 ?? process.cwd();
+  const branchExists = (() => {
+    try {
+      return spawnSync2("git", ["rev-parse", "--verify", "--quiet", branch], {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      }).status === 0;
+    } catch {
+      return false;
+    }
+  })();
+  if (branchExists) {
+    const currentCommit = spawnSync2("git", ["rev-parse", branch], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).stdout?.toString?.().trim() ?? "";
+    if (currentCommit !== startBaseCommit) {
+      return {
+        ok: false,
+        failureCode: "branch_commit_mismatch",
+        message: `Local PRD branch ${branch} exists at commit ${currentCommit} but expected commit ${startBaseCommit}. The branch has diverged from the start base. To resolve, delete the local branch and rerun start, or manually reset it to the expected commit.`
+      };
+    }
+    return {
+      ok: true,
+      created: false
+    };
+  }
+  const branchResult = spawnSync2("git", ["branch", branch, startBaseCommit], {
+    cwd: root,
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  if (branchResult.status !== 0) {
+    const stderr = branchResult.stderr?.toString?.() ?? "unknown error";
+    return {
+      ok: false,
+      failureCode: "branch_creation_failed",
+      message: `Failed to create local PRD branch ${branch} at ${startBaseCommit}: ${stderr}`
+    };
+  }
+  return { ok: true, created: true };
+}
 var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["dev", "next", "main"]);
 var LOCAL_BRANCH_PATTERN = /^local\/PRD-\d{4}(\/(I-\d{2}(-[a-z0-9-]+)?)?)?$/;
 function validateLocalBranchName(name) {
@@ -8307,13 +8334,13 @@ import {
   lstatSync,
   mkdirSync as mkdirSync11,
   mkdtempSync,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync16,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync17,
   realpathSync,
   rmSync as rmSync3
 } from "fs";
-import { spawnSync as spawnSync2 } from "child_process";
-import { dirname as dirname5, join as join20, relative as relative2 } from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+import { dirname as dirname5, join as join21, relative as relative2 } from "path";
 import { tmpdir } from "os";
 
 // prd-run/state.ts
@@ -8343,9 +8370,11 @@ var PrdRunRecordSchema = z3.object({
     "waiting_for_integration",
     "finalizing",
     "final_reviewed",
-    "complete"
+    "complete",
+    "completed_local_branch"
   ]),
   updatedAt: z3.string().min(1),
+  mode: z3.enum(["github", "local"]).optional(),
   blockedGate: z3.enum([
     "manifest-location",
     "manifest-readiness",
@@ -8544,7 +8573,20 @@ var LocalPrdRunRecordSchema = z3.object({
       baseCommit: z3.string().min(1)
     }).optional(),
     queue: z3.object({ completedAt: z3.string().min(1) }).optional(),
-    finalReview: z3.object({ completedAt: z3.string().min(1) }).optional(),
+    finalReview: z3.object({
+      completedAt: z3.string().min(1),
+      targetName: z3.string().optional(),
+      prdBranch: z3.string().optional(),
+      mergeBase: z3.string().optional(),
+      verdict: z3.enum([
+        "pass_no_changes",
+        "pass_with_retouch",
+        "needs_human_review",
+        "blocked"
+      ]).optional(),
+      diagnostics: z3.array(z3.string()).optional(),
+      artifactPath: z3.string().optional()
+    }).optional(),
     reconciliation: z3.object({ completedAt: z3.string().min(1) }).optional(),
     complete: z3.object({
       completedAt: z3.string().min(1),
@@ -9152,6 +9194,28 @@ function getLocalStorePath3(repoRoot2, prdId) {
 function getFinalReviewReceiptPath(repoRoot2, prdId) {
   return join17(getLocalStorePath3(repoRoot2, prdId), "final-review-receipt.json");
 }
+function computeLocalMergeBase(repoRoot2, prdBranch) {
+  const candidates = ["dev", "main", "master", "HEAD"];
+  for (const base of candidates) {
+    try {
+      const result = execFileSync3("git", ["merge-base", base, prdBranch], {
+        cwd: repoRoot2,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      const mergeBase = result.trim();
+      if (mergeBase && mergeBase.length >= 6) {
+        return { ok: true, mergeBase };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    ok: false,
+    reason: "Could not compute merge base against any known base branch (dev/main/master/HEAD)."
+  };
+}
 async function runLocalFinalReview(prdId, options) {
   const root = options?.repoRoot ?? process.cwd();
   const commands = options?.verificationCommands ?? [];
@@ -9164,6 +9228,34 @@ async function runLocalFinalReview(prdId, options) {
     };
   }
   const branch = getLocalPrdBranchName(prdId);
+  const mergeBaseResult = computeLocalMergeBase(root, branch);
+  if (!mergeBaseResult.ok) {
+    return {
+      ok: false,
+      failureCode: "merge_base_failed",
+      message: mergeBaseResult.reason
+    };
+  }
+  const semanticResult = validateFinalReviewArtifactSemanticIds(
+    {
+      prdRef: prdId,
+      stage: "prdFinalReview",
+      checkoutBase: branch,
+      reviewBase: mergeBaseResult.mergeBase
+    },
+    {
+      prdRef: prdId,
+      prdBranch: branch,
+      mergeBase: mergeBaseResult.mergeBase
+    }
+  );
+  if (!semanticResult.ok) {
+    return {
+      ok: false,
+      failureCode: "invalid_artifact_semantics",
+      message: semanticResult.errors.join("; ")
+    };
+  }
   const failures = [];
   for (const cmd of commands) {
     try {
@@ -9175,7 +9267,7 @@ async function runLocalFinalReview(prdId, options) {
   }
   let verdict;
   if (commands.length === 0 || failures.length === 0) {
-    const retouchBranch = `local/${prdId}/retouch`;
+    const retouchBranch = `local-${prdId}-final-review-retouch`;
     try {
       execSync2(`git show-ref --verify --quiet refs/heads/${retouchBranch}`, {
         cwd: root,
@@ -9184,12 +9276,12 @@ async function runLocalFinalReview(prdId, options) {
       });
       verdict = "pass_with_retouch";
     } catch {
-      verdict = "pass";
+      verdict = "pass_no_changes";
     }
   } else if (failures.length === commands.length) {
     verdict = "blocked";
   } else {
-    const retouchBranch = `local/${prdId}/retouch`;
+    const retouchBranch = `local-${prdId}-final-review-retouch`;
     try {
       execSync2(`git show-ref --verify --quiet refs/heads/${retouchBranch}`, {
         cwd: root,
@@ -9202,9 +9294,10 @@ async function runLocalFinalReview(prdId, options) {
     }
   }
   const receipt = {
-    reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reviewedTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
     verdict,
-    branch
+    prdBranch: branch,
+    mergeBase: mergeBaseResult.mergeBase
   };
   const receiptPath = getFinalReviewReceiptPath(root, prdId);
   mkdirSync9(getLocalStorePath3(root, prdId), { recursive: true });
@@ -9217,10 +9310,10 @@ async function runLocalFinalReview(prdId, options) {
   }
   return result;
 }
-async function squashFinalReviewRetouch(prdId, repoRoot2) {
+async function squashFinalReviewRetouch(prdId, repoRoot2, title, body) {
   const root = repoRoot2 ?? process.cwd();
   const targetBranch = `local/${prdId}`;
-  const retouchBranch = `local/${prdId}/retouch`;
+  const retouchBranch = `local-${prdId}-final-review-retouch`;
   try {
     execFileSync3(
       "git",
@@ -9267,15 +9360,46 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
       return;
     } catch {
     }
-    execFileSync3(
+    if (title) {
+      const commitBody = body ? `${title}
+
+${body}` : title;
+      execFileSync3("git", ["commit", "-m", commitBody], {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+    } else {
+      execFileSync3(
+        "git",
+        ["commit", "-m", `Squash merge ${retouchBranch} into ${targetBranch}`],
+        {
+          cwd: root,
+          encoding: "utf8",
+          stdio: "pipe"
+        }
+      );
+    }
+    const mergeCommit = execFileSync3("git", ["rev-parse", "HEAD"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+    const changedPathsResult = execFileSync3(
       "git",
-      ["commit", "-m", `Squash merge ${retouchBranch} into ${targetBranch}`],
+      ["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"],
       {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
       }
     );
+    const changedPaths = changedPathsResult.split(/\r?\n/).filter(Boolean);
+    return {
+      mergeCommit,
+      changedPaths,
+      reviewedTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.toLowerCase().includes("conflict")) {
@@ -9287,13 +9411,7 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
 
 // prd-run/local-reconciliation.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync15,
-  readdirSync as readdirSync5,
-  writeFileSync as writeFileSync7
-} from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
 import { join as join18 } from "path";
 function getLocalStorePath4(repoRoot2, prdId) {
   return join18(repoRoot2, ".pourkit", "local-prd-runs", prdId);
@@ -9304,26 +9422,6 @@ function getFinalReviewReceiptPath2(repoRoot2, prdId) {
 function getHandoffArtifactPath(repoRoot2, prdId) {
   return join18(repoRoot2, ".pourkit", ".tmp", "reconciliation", `${prdId}.json`);
 }
-function getCompletionsDir(repoRoot2, prdId) {
-  const initiativesRoot = join18(
-    repoRoot2,
-    ".pourkit",
-    "architecture",
-    "initiatives"
-  );
-  if (existsSync15(initiativesRoot)) {
-    const dirs = readdirSync5(initiativesRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join18(initiativesRoot, e.name));
-    for (const dir of dirs) {
-      const prdsDir = join18(dir, "prds");
-      if (!existsSync15(prdsDir)) continue;
-      const prdDirs = readdirSync5(prdsDir, { withFileTypes: true }).filter(
-        (e) => e.isDirectory() && e.name.startsWith(prdId.toLowerCase())
-      );
-      if (prdDirs.length > 0) return join18(dir, "completions");
-    }
-  }
-  return join18(getLocalStorePath4(repoRoot2, prdId), "completions");
-}
 function getReconciliationReceiptPath(repoRoot2, prdId) {
   return join18(
     getLocalStorePath4(repoRoot2, prdId),
@@ -9365,6 +9463,20 @@ async function runLocalReconciliation(prdId, options) {
       message: "Handoff artifact validation failed. Check Architect reconciliation output."
     };
   }
+  const validResults = [
+    "no_changes_needed",
+    "changes_produced",
+    "blocked"
+  ];
+  if (!validResults.includes(
+    handoff.result
+  )) {
+    return {
+      ok: false,
+      failureCode: "invalid_handoff",
+      message: "Handoff artifact validation failed. Check Architect reconciliation output."
+    };
+  }
   if (handoff.result === "blocked") {
     return {
       ok: false,
@@ -9379,48 +9491,6 @@ async function runLocalReconciliation(prdId, options) {
       message: "Handoff artifact validation failed. Check Architect reconciliation output."
     };
   }
-  if (handoff.result === "changes_produced") {
-    try {
-      const completionsDir = getCompletionsDir(root, prdId);
-      mkdirSync10(completionsDir, { recursive: true });
-      const existing = existsSync15(completionsDir) ? readdirSync5(completionsDir).filter((f) => f.endsWith(".md")) : [];
-      const nextNum = String(existing.length + 1).padStart(3, "0");
-      const filename = `${nextNum}-prd-${prdId.replace("PRD-", "").toLowerCase()}-reconciliation-completion.md`;
-      const filepath = join18(completionsDir, filename);
-      const changedPaths = Array.isArray(handoff.changedPlanningPaths) ? handoff.changedPlanningPaths : [];
-      const summary = typeof handoff.summary === "string" ? handoff.summary : "";
-      const lines = [
-        `# ${prdId} Reconciliation Completion`,
-        "",
-        `Result: ${handoff.result}`
-      ];
-      if (summary) lines.push(`Summary: ${summary}`);
-      lines.push("", "## Changed Planning Paths", "");
-      if (changedPaths.length > 0) {
-        lines.push(...changedPaths.map((p) => `- ${p}`));
-      } else {
-        lines.push("- (none)");
-      }
-      lines.push("");
-      writeFileSync7(filepath, lines.join("\n"), "utf-8");
-      execFileSync4("git", ["add", filepath], {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      });
-      execFileSync4(
-        "git",
-        ["commit", "-m", `docs: ${prdId} reconciliation completion`],
-        { cwd: root, encoding: "utf8", stdio: "pipe" }
-      );
-    } catch {
-      return {
-        ok: false,
-        failureCode: "completion_commit_failed",
-        message: "Failed to commit completion files."
-      };
-    }
-  }
   if (handoff.result === "changes_produced") {
     try {
       const targetBranch = getLocalPrdBranchName(prdId);
@@ -9434,7 +9504,7 @@ async function runLocalReconciliation(prdId, options) {
         return {
           ok: false,
           failureCode: "squash_merge_failed",
-          message: "Squash merge into local PRD Branch failed."
+          message: `Local PRD Branch "${targetBranch}" does not exist. Run prd-run start first to create it.`
         };
       }
       execFileSync4("git", ["checkout", targetBranch], {
@@ -9457,7 +9527,7 @@ async function runLocalReconciliation(prdId, options) {
         return {
           ok: false,
           failureCode: "squash_merge_failed",
-          message: "Squash merge into local PRD Branch failed."
+          message: `Reconciliation source branch "${sourceBranch}" does not exist. Re-run reconciliation.`
         };
       }
       execFileSync4("git", ["merge", "--squash", sourceBranch], {
@@ -9478,6 +9548,25 @@ async function runLocalReconciliation(prdId, options) {
           { cwd: root, encoding: "utf8", stdio: "pipe" }
         );
       }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      return {
+        ok: false,
+        failureCode: "squash_merge_failed",
+        message: `Squash merge into local PRD Branch failed: ${message}`
+      };
+    }
+  }
+  const prdBranch = getLocalPrdBranchName(prdId);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let mergeCommit;
+  if (handoff.result === "changes_produced") {
+    try {
+      mergeCommit = execFileSync4("git", ["rev-parse", "HEAD"], {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      }).trim();
     } catch {
       return {
         ok: false,
@@ -9486,18 +9575,21 @@ async function runLocalReconciliation(prdId, options) {
       };
     }
   }
-  const branch = getLocalPrdBranchName(prdId);
-  const receipt = {
-    reconciledAt: (/* @__PURE__ */ new Date()).toISOString(),
-    branch
+  const changedPaths = Array.isArray(handoff.changedPlanningPaths) ? handoff.changedPlanningPaths : [];
+  const entry = {
+    result: handoff.result ?? "blocked",
+    prdBranch,
+    ...changedPaths.length > 0 ? { changedPlanningPaths: changedPaths } : {},
+    ...mergeCommit ? { mergeCommit } : {},
+    reconciledTimestamp: now
   };
   mkdirSync10(getLocalStorePath4(root, prdId), { recursive: true });
   writeFileSync7(
     getReconciliationReceiptPath(root, prdId),
-    JSON.stringify(receipt, null, 2),
+    JSON.stringify(entry, null, 2),
     "utf-8"
   );
-  return { ok: true, receipt };
+  return { ok: true, receipt: entry };
 }
 
 // prd-run/local-prepare.ts
@@ -9642,55 +9734,346 @@ async function validateLocalPrepareGates(prdId, repoRoot2) {
   return { ok: true, gates };
 }
 
-// commands/queue.ts
-init_common();
-import { Effect as Effect8 } from "effect";
+// prd-run/local-queue-loop.ts
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
+import { join as join20 } from "path";
 
-// issues/select-issue.ts
+// prd-run/local-issue-run.ts
+import { execFileSync as execFileSync5 } from "child_process";
 init_common();
-var TYPE_PRIORITY = {
-  "type:bugfix": 1,
-  "type:infra": 2,
-  "type:feature": 3,
-  "type:polish": 4,
-  "type:refactor": 5
-};
-function selectIssue(candidates, options = {}) {
-  const blockedLabel = options.blockedLabel ?? "blocked";
-  const agentInProgressLabel = options.agentInProgressLabel ?? "agent-in-progress";
-  if (candidates.length === 0) {
-    return { ok: false, reason: "No candidate issues provided." };
+async function createLocalIssueBranch(prdId, issueId, repoRoot2) {
+  const root = repoRoot2 ?? process.cwd();
+  const issuesResult = await resolveLocalIssueArtifacts(prdId, root);
+  if (!issuesResult.ok) {
+    throw new Error(
+      `Cannot create local issue branch: ${issuesResult.message}`
+    );
   }
-  const unblocked = candidates.filter(
-    (issue) => !issue.labels.includes(blockedLabel)
-  );
-  if (unblocked.length === 0) {
-    return { ok: false, reason: "All candidate issues are blocked." };
+  const issue = issuesResult.data.find((i) => i.id === issueId);
+  if (!issue) {
+    throw new Error(`Issue "${issueId}" not found under PRD "${prdId}"`);
   }
-  const valid2 = [];
-  const rejected = [];
-  for (const issue of unblocked) {
-    if (issue.labels.includes(agentInProgressLabel)) {
-      rejected.push(
-        `Issue #${issue.number} is labeled ${agentInProgressLabel}.`
-      );
-      continue;
-    }
-    const typeLabels = issue.labels.filter(
-      (l) => TYPE_LABELS.includes(l)
+  const slug = slugify(issue.title);
+  const branchName = `local/${prdId}/${issueId}-${slug}`;
+  const validation = validateLocalBranchName(branchName);
+  if (!validation.ok) {
+    throw new Error(
+      `Invalid local issue branch name "${branchName}": ${validation.message}`
     );
-    if (typeLabels.length !== 1) {
-      rejected.push(
-        `Issue #${issue.number} has ${typeLabels.length} type label(s); expected exactly one.`
-      );
-      continue;
-    }
-    valid2.push({ issue, priority: TYPE_PRIORITY[typeLabels[0]] });
   }
-  if (valid2.length === 0) {
+  const localPrdBranch = `local/${prdId}`;
+  try {
+    execFileSync5(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${localPrdBranch}`],
+      {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      }
+    );
+  } catch {
+    throw new Error(
+      `Local PRD branch "${localPrdBranch}" does not exist. Create it first.`
+    );
+  }
+  let branchExists = false;
+  try {
+    execFileSync5(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
+      {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      }
+    );
+    branchExists = true;
+  } catch {
+  }
+  if (!branchExists) {
+    execFileSync5("git", ["checkout", "-b", branchName, localPrdBranch], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+  }
+  return { branchName, issue };
+}
+async function runLocalIssue(prdId, issueId, builder, repoRoot2) {
+  try {
+    const root = repoRoot2 ?? process.cwd();
+    const { branchName: branch, issue } = await createLocalIssueBranch(
+      prdId,
+      issueId,
+      root
+    );
+    if (builder) {
+      const result = await builder.execute({
+        prdId,
+        issueId,
+        branch,
+        bodyMarkdown: issue.bodyMarkdown
+      });
+      if (!result.ok) {
+        return {
+          ok: false,
+          issueId,
+          branch,
+          failureCode: result.error ?? "Builder execution failed"
+        };
+      }
+    }
+    return { ok: true, issueId, branch };
+  } catch (error) {
     return {
       ok: false,
-      reason: "No runnable issues: " + rejected.join(" ")
+      issueId,
+      branch: "",
+      failureCode: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// prd-run/local-queue-loop.ts
+var CHILD_CLEANUP_LABELS = ["agent-in-progress", "pr-open-awaiting-merge"];
+function getIssueArtifactPath2(repoRoot2, prdId, issueId) {
+  return join20(
+    repoRoot2,
+    ".pourkit",
+    "local-prd-runs",
+    prdId,
+    "issues",
+    `${issueId}.json`
+  );
+}
+function readIssueArtifact(repoRoot2, prdId, issueId) {
+  try {
+    const content = readFileSync16(
+      getIssueArtifactPath2(repoRoot2, prdId, issueId),
+      "utf-8"
+    );
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeIssueArtifact(repoRoot2, prdId, issue) {
+  writeFileSync8(
+    getIssueArtifactPath2(repoRoot2, prdId, issue.id),
+    JSON.stringify(issue, null, 2),
+    "utf-8"
+  );
+}
+async function reconcileLocalBlockedIssues(prdId, repoRoot2) {
+  const root = repoRoot2 ?? process.cwd();
+  const issuesResult = await resolveLocalIssueArtifacts(prdId, root);
+  if (!issuesResult.ok) return;
+  const issues = issuesResult.data;
+  for (const issue of issues) {
+    const isBlocked = issue.status === "blocked";
+    if (!isBlocked) continue;
+    if (issue.dependencyIssueIds.length === 0) continue;
+    const depResults = await Promise.all(
+      issue.dependencyIssueIds.map(
+        (depId) => hasLocalIssueMergeReceipt(prdId, depId, root)
+      )
+    );
+    if (!depResults.every(Boolean)) continue;
+    const updated = readIssueArtifact(root, prdId, issue.id);
+    if (!updated) continue;
+    updated.blockedReason = null;
+    updated.labels = updated.labels.filter((l) => l !== "blocked");
+    if (!updated.labels.includes("ready-for-agent")) {
+      updated.labels.push("ready-for-agent");
+    }
+    if (hasValidLabels(updated.labels)) {
+      updated.status = "ready-for-agent";
+    } else {
+      updated.status = "needs-triage";
+      updated.labels = updated.labels.filter((l) => l !== "ready-for-agent");
+      if (!updated.labels.includes("needs-triage")) {
+        updated.labels.push("needs-triage");
+      }
+    }
+    updated.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeIssueArtifact(root, prdId, updated);
+  }
+}
+async function cleanupChildGitHubIssue(issue, issueProvider) {
+  const issueNumber = issue.githubProjection.issueNumber;
+  if (!issueNumber) return { ok: true };
+  if (!issueProvider) {
+    return {
+      ok: false,
+      failureCode: "missing_issue_provider",
+      repairGuidance: "Issue provider is not available. Cannot close child GitHub Issue or remove labels. Configure a GitHub Issue provider to enable cleanup parity."
+    };
+  }
+  for (const label of CHILD_CLEANUP_LABELS) {
+    try {
+      await issueProvider.removeLabel(issueNumber, label);
+    } catch {
+    }
+  }
+  try {
+    await issueProvider.closeIssue(issueNumber);
+  } catch {
+  }
+  return { ok: true };
+}
+async function runLocalQueueLoop(prdId, repoRoot2, issueProvider) {
+  const root = repoRoot2 ?? process.cwd();
+  const completedIssues = [];
+  const blockedIssues = [];
+  await reconcileLocalBlockedIssues(prdId, root);
+  for (; ; ) {
+    const runnable = await getRunnableLocalIssues(prdId, root);
+    if (runnable.length === 0) {
+      const issuesResult = await resolveLocalIssueArtifacts(prdId, root);
+      if (issuesResult.ok) {
+        for (const issue2 of issuesResult.data) {
+          if (issue2.status === "blocked") {
+            blockedIssues.push(issue2.id);
+          }
+        }
+      }
+      break;
+    }
+    const issue = runnable[0];
+    const runResult = await runLocalIssue(prdId, issue.id, void 0, root);
+    if (!runResult.ok) {
+      return {
+        ok: false,
+        completedIssues,
+        blockedIssues,
+        failureCode: runResult.failureCode ?? `Issue ${issue.id} failed`,
+        repairGuidance: `Local issue run failed for ${issue.id}. Check the issue artifact and branch state.`,
+        blockedGate: "queue"
+      };
+    }
+    const mergeResult = await squashMergeLocalIssue(
+      prdId,
+      issue.id,
+      void 0,
+      root
+    );
+    if (!mergeResult.ok) {
+      if (mergeResult.failureCode === "already_merged") {
+        const alreadyMergedArtifact = readIssueArtifact(root, prdId, issue.id);
+        if (alreadyMergedArtifact) {
+          alreadyMergedArtifact.status = "complete";
+          alreadyMergedArtifact.receipts.completedAt = mergeResult.receipt?.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+          alreadyMergedArtifact.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          writeIssueArtifact(root, prdId, alreadyMergedArtifact);
+          const cleanupResult = await cleanupChildGitHubIssue(
+            alreadyMergedArtifact,
+            issueProvider
+          );
+          if (!cleanupResult.ok) {
+            return {
+              ok: false,
+              completedIssues,
+              blockedIssues,
+              failureCode: cleanupResult.failureCode ?? "child_cleanup_failed",
+              repairGuidance: cleanupResult.repairGuidance ?? `Child GitHub Issue cleanup failed for ${issue.id}.`,
+              blockedGate: "queue"
+            };
+          }
+        }
+        completedIssues.push(issue.id);
+        await reconcileLocalBlockedIssues(prdId, root);
+        continue;
+      }
+      return {
+        ok: false,
+        completedIssues,
+        blockedIssues,
+        failureCode: mergeResult.failureCode ?? `Merge of ${issue.id} failed`,
+        repairGuidance: mergeResult.repairGuidance,
+        blockedGate: "queue"
+      };
+    }
+    const completedArtifact = readIssueArtifact(root, prdId, issue.id);
+    if (completedArtifact) {
+      completedArtifact.status = "complete";
+      completedArtifact.receipts.completedAt = mergeResult.receipt?.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      completedArtifact.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeIssueArtifact(root, prdId, completedArtifact);
+      const cleanupResult = await cleanupChildGitHubIssue(
+        completedArtifact,
+        issueProvider
+      );
+      if (!cleanupResult.ok) {
+        return {
+          ok: false,
+          completedIssues,
+          blockedIssues,
+          failureCode: cleanupResult.failureCode ?? "child_cleanup_failed",
+          repairGuidance: cleanupResult.repairGuidance ?? `Child GitHub Issue cleanup failed for ${issue.id}.`,
+          blockedGate: "queue"
+        };
+      }
+    }
+    completedIssues.push(issue.id);
+    await reconcileLocalBlockedIssues(prdId, root);
+  }
+  return {
+    ok: true,
+    completedIssues,
+    blockedIssues
+  };
+}
+
+// commands/queue.ts
+init_common();
+import { Effect as Effect8 } from "effect";
+
+// issues/select-issue.ts
+init_common();
+var TYPE_PRIORITY = {
+  "type:bugfix": 1,
+  "type:infra": 2,
+  "type:feature": 3,
+  "type:polish": 4,
+  "type:refactor": 5
+};
+function selectIssue(candidates, options = {}) {
+  const blockedLabel = options.blockedLabel ?? "blocked";
+  const agentInProgressLabel = options.agentInProgressLabel ?? "agent-in-progress";
+  if (candidates.length === 0) {
+    return { ok: false, reason: "No candidate issues provided." };
+  }
+  const unblocked = candidates.filter(
+    (issue) => !issue.labels.includes(blockedLabel)
+  );
+  if (unblocked.length === 0) {
+    return { ok: false, reason: "All candidate issues are blocked." };
+  }
+  const valid2 = [];
+  const rejected = [];
+  for (const issue of unblocked) {
+    if (issue.labels.includes(agentInProgressLabel)) {
+      rejected.push(
+        `Issue #${issue.number} is labeled ${agentInProgressLabel}.`
+      );
+      continue;
+    }
+    const typeLabels = issue.labels.filter(
+      (l) => TYPE_LABELS.includes(l)
+    );
+    if (typeLabels.length !== 1) {
+      rejected.push(
+        `Issue #${issue.number} has ${typeLabels.length} type label(s); expected exactly one.`
+      );
+      continue;
+    }
+    valid2.push({ issue, priority: TYPE_PRIORITY[typeLabels[0]] });
+  }
+  if (valid2.length === 0) {
+    return {
+      ok: false,
+      reason: "No runnable issues: " + rejected.join(" ")
     };
   }
   valid2.sort((a, b) => {
@@ -10164,7 +10547,7 @@ function validateChangedPlanningPaths(paths, options) {
       continue;
     }
     if (options?.repoRoot) {
-      const fullPath = join20(options.repoRoot, p);
+      const fullPath = join21(options.repoRoot, p);
       try {
         if (lstatSync(fullPath).isSymbolicLink()) {
           rejected.push(p);
@@ -10275,6 +10658,12 @@ async function validateFinalReviewChildCompleteness(repoRoot2, prdRef, record, i
       );
       continue;
     }
+    if (!issueData || typeof issueData.state !== "string") {
+      incompleteChildren.push(
+        `${child.id} (#${child.number}): failed to fetch issue state`
+      );
+      continue;
+    }
     if (issueData.state === "closed") {
       continue;
     }
@@ -10331,11 +10720,7 @@ function canRetryFinalReviewBlock(record) {
 }
 function loadFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  return existsSync17(promptPath) ? readFileSync16(promptPath, "utf-8") : promptTemplate;
-}
-function formatVerificationCommands(commands) {
-  if (commands.length === 0) return "No verification commands configured.";
-  return commands.map((cmd) => `- ${cmd.label}: ${cmd.command}`).join("\n");
+  return existsSync17(promptPath) ? readFileSync17(promptPath, "utf-8") : promptTemplate;
 }
 function buildFinalReviewPrompt(options) {
   return [
@@ -10351,9 +10736,6 @@ function buildFinalReviewPrompt(options) {
     "",
     `Run this command before handoff when retouch changes are made: pourkit run-verification --target ${options.targetName}`,
     "",
-    "Underlying project commands:",
-    formatVerificationCommands(options.verificationCommands),
-    "",
     "Evidence Packet (do not infer PRD context from local state files):",
     JSON.stringify(options.evidencePacket, null, 2),
     "",
@@ -10385,7 +10767,7 @@ function buildReconciliationBranchName(prdRef) {
   return `${normalizePrdRunRef2(prdRef)}-reconciliation`;
 }
 function reconciliationWorktreePath(repoRoot2, branchName) {
-  return join20(repoRoot2, ".sandcastle", "worktrees", branchName);
+  return join21(repoRoot2, ".sandcastle", "worktrees", branchName);
 }
 function reconciliationReceiptWorktreePath(branchName) {
   return `.sandcastle/worktrees/${branchName}`;
@@ -10397,7 +10779,7 @@ function buildFinalReviewBranchName(prdRef) {
   return `pourkit/${normalizePrdRunRef2(prdRef).toLowerCase()}-final-review`;
 }
 function finalReviewWorktreePath(repoRoot2, branchName) {
-  return join20(
+  return join21(
     repoRoot2,
     ".sandcastle",
     "worktrees",
@@ -10420,7 +10802,7 @@ function listFinalReviewChangedPaths(worktreePath, mergeBase) {
     }
     paths.add(path9);
   };
-  const diffResult = spawnSync2(
+  const diffResult = spawnSync3(
     "git",
     ["diff", "--name-only", mergeBase, "--", "."],
     {
@@ -10431,7 +10813,7 @@ function listFinalReviewChangedPaths(worktreePath, mergeBase) {
   for (const path9 of diffResult.stdout.split(/\r?\n/).filter(Boolean)) {
     addPath(path9);
   }
-  const statusResult = spawnSync2(
+  const statusResult = spawnSync3(
     "git",
     ["status", "--porcelain", "--untracked-files=all"],
     {
@@ -10452,7 +10834,7 @@ function buildFinalReviewFinalizerPrompt(options) {
     options.repoRoot,
     options.promptTemplate
   );
-  const promptBody = existsSync17(promptPath) ? readFileSync16(promptPath, "utf-8") : options.promptTemplate;
+  const promptBody = existsSync17(promptPath) ? readFileSync17(promptPath, "utf-8") : options.promptTemplate;
   return [
     "# Final Review Retouch PR Finalizer",
     "",
@@ -10478,15 +10860,12 @@ function buildFinalReviewFinalizerPrompt(options) {
     "Changed paths:",
     ...options.changedPaths.map((p) => `- ${p}`),
     "",
-    "Verification commands given to Final Review:",
-    formatVerificationCommands(options.verificationCommands),
-    "",
     promptBody
   ].join("\n");
 }
 async function runFinalReviewPrFinalizer(options) {
   const finalizer = options.target.strategy.finalize.prDescriptionAgent;
-  const artifactPathInWorktree = join20(
+  const artifactPathInWorktree = join21(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -10507,8 +10886,7 @@ async function runFinalReviewPrFinalizer(options) {
           prdBranch: options.prdBranch,
           mergeBase: options.mergeBase,
           summary: options.summary,
-          changedPaths: options.changedPaths,
-          verificationCommands: options.verificationCommands
+          changedPaths: options.changedPaths
         }),
         branchName: options.branchName,
         repoRoot: options.repoRoot,
@@ -10532,7 +10910,7 @@ function ensureFinalReviewWorktree(options) {
     options.repoRoot,
     options.branchName
   );
-  const listResult = spawnSync2("git", ["worktree", "list", "--porcelain"], {
+  const listResult = spawnSync3("git", ["worktree", "list", "--porcelain"], {
     cwd: options.repoRoot,
     encoding: "utf8"
   });
@@ -10568,19 +10946,34 @@ function ensureFinalReviewWorktree(options) {
     };
   }
   mkdirSync11(dirname5(worktreePath), { recursive: true });
-  const branchResult = spawnSync2(
-    "git",
-    ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
-    { cwd: options.repoRoot, encoding: "utf8" }
-  );
-  if (branchResult.status !== 0) {
-    return {
-      ok: false,
-      reason: `Final Review failed to prepare branch ${options.branchName}.`,
-      diagnostics: collectSpawnDiagnostics(branchResult, "git branch failed")
-    };
+  if (options.isLocal) {
+    const branchResult = spawnSync3(
+      "git",
+      ["branch", "-f", options.branchName, options.checkoutBase],
+      { cwd: options.repoRoot, encoding: "utf8" }
+    );
+    if (branchResult.status !== 0) {
+      return {
+        ok: false,
+        reason: `Final Review failed to prepare branch ${options.branchName}.`,
+        diagnostics: collectSpawnDiagnostics(branchResult, "git branch failed")
+      };
+    }
+  } else {
+    const branchResult = spawnSync3(
+      "git",
+      ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
+      { cwd: options.repoRoot, encoding: "utf8" }
+    );
+    if (branchResult.status !== 0) {
+      return {
+        ok: false,
+        reason: `Final Review failed to prepare branch ${options.branchName}.`,
+        diagnostics: collectSpawnDiagnostics(branchResult, "git branch failed")
+      };
+    }
   }
-  const addResult = spawnSync2(
+  const addResult = spawnSync3(
     "git",
     ["worktree", "add", worktreePath, options.branchName],
     { cwd: options.repoRoot, encoding: "utf8" }
@@ -10622,7 +11015,7 @@ async function createOrReuseFinalReviewRetouchPr(options) {
   if (existingPr && existingPr.state === "OPEN") {
     return existingPr;
   }
-  const worktreePath = mkdtempSync(join20(tmpdir(), "pourkit-retouch-"));
+  const worktreePath = mkdtempSync(join21(tmpdir(), "pourkit-retouch-"));
   try {
     runGitOrThrow(
       options.repoRoot,
@@ -10640,8 +11033,8 @@ async function createOrReuseFinalReviewRetouchPr(options) {
       "create retouch branch"
     );
     for (const changedFile of options.changedPaths) {
-      const sourcePath = join20(options.sourceWorktreePath, changedFile);
-      const targetPath = join20(worktreePath, changedFile);
+      const sourcePath = join21(options.sourceWorktreePath, changedFile);
+      const targetPath = join21(worktreePath, changedFile);
       mkdirSync11(dirname5(targetPath), { recursive: true });
       cpSync(sourcePath, targetPath, { recursive: true });
     }
@@ -10656,13 +11049,13 @@ async function createOrReuseFinalReviewRetouchPr(options) {
       "commit retouch diff"
     );
   } finally {
-    spawnSync2("git", ["worktree", "remove", "--force", worktreePath], {
+    spawnSync3("git", ["worktree", "remove", "--force", worktreePath], {
       cwd: options.repoRoot,
       encoding: "utf8"
     });
     rmSync3(worktreePath, { recursive: true, force: true });
   }
-  const pushResult = spawnSync2(
+  const pushResult = spawnSync3(
     "git",
     ["push", "--force", "origin", `${branchName}:refs/heads/${branchName}`],
     {
@@ -10690,6 +11083,156 @@ async function createOrReuseFinalReviewRetouchPr(options) {
     })
   });
 }
+async function writeAndVerifyLocalDualReceipt(repoRoot2, prdRef, record, targetName, prdBranch, mergeBase, verdict, reviewedAt, isLocalMode) {
+  if (!isLocalMode) return null;
+  let currentRecord = await readLocalPrdRun(repoRoot2, prdRef);
+  if (!currentRecord) {
+    currentRecord = {
+      prdId: normalizePrdRunRef2(prdRef),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      receipts: {},
+      metadata: {}
+    };
+  }
+  const localStoreReceipt = {
+    completedAt: reviewedAt,
+    targetName,
+    prdBranch,
+    mergeBase,
+    verdict,
+    diagnostics: [],
+    artifactPath: ".pourkit/final-review-artifact.json"
+  };
+  await writeLocalPrdRunRecord(repoRoot2, prdRef, {
+    ...currentRecord,
+    receipts: {
+      ...currentRecord.receipts,
+      finalReview: localStoreReceipt
+    }
+  });
+  const prdRunStateResult = readPrdRun(repoRoot2, prdRef);
+  const localStoreResult = await readLocalPrdRun(repoRoot2, prdRef);
+  if (!prdRunStateResult.record?.finalReview) {
+    const reason = `PRD Run State missing finalReview receipt after write for ${prdRef}.`;
+    writePrdRunRecord(repoRoot2, {
+      ...record,
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      targetName,
+      offendingPaths: []
+    });
+    return {
+      prdRef,
+      status: "blocked",
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      offendingPaths: []
+    };
+  }
+  if (!localStoreResult?.receipts.finalReview) {
+    const reason = `Local PRD Run store missing finalReview receipt after write for ${prdRef}.`;
+    writePrdRunRecord(repoRoot2, {
+      ...record,
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      targetName,
+      offendingPaths: []
+    });
+    return {
+      prdRef,
+      status: "blocked",
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      offendingPaths: []
+    };
+  }
+  const stateFr = prdRunStateResult.record.finalReview;
+  const localFr = localStoreResult.receipts.finalReview;
+  const mismatchFields = [];
+  if (stateFr.targetName !== localFr.targetName)
+    mismatchFields.push("targetName");
+  if (stateFr.prdBranch !== localFr.prdBranch) mismatchFields.push("prdBranch");
+  if (stateFr.mergeBase !== localFr.mergeBase) mismatchFields.push("mergeBase");
+  if (stateFr.verdict !== localFr.verdict) mismatchFields.push("verdict");
+  if (!stateFr.artifactPath !== !localFr.artifactPath)
+    mismatchFields.push("artifactPath");
+  if (!stateFr.diagnostics !== !localFr.diagnostics)
+    mismatchFields.push("diagnostics");
+  if (!stateFr.reviewedAt !== !localFr.completedAt)
+    mismatchFields.push("reviewedTimestamp");
+  if (mismatchFields.length > 0) {
+    const reason = `Dual receipt mismatch on fields: ${mismatchFields.join(", ")}`;
+    writePrdRunRecord(repoRoot2, {
+      ...record,
+      prdRef,
+      status: "blocked",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      targetName,
+      finalReview: stateFr,
+      offendingPaths: []
+    });
+    return {
+      prdRef,
+      status: "blocked",
+      blockedGate: "final-review",
+      blockedReason: reason,
+      diagnostics: [reason],
+      offendingPaths: []
+    };
+  }
+  return null;
+}
+async function verifyLocalDualFinalReviewReceipts(repoRoot2, prdRef) {
+  const prdRunStateResult = readPrdRun(repoRoot2, prdRef);
+  const stateFr = prdRunStateResult.record?.finalReview;
+  const localStoreResult = await readLocalPrdRun(repoRoot2, prdRef);
+  const localFr = localStoreResult?.receipts.finalReview;
+  const diagnostics = [];
+  const validFinalReviewStatuses = /* @__PURE__ */ new Set(["final_reviewed", "succeeded"]);
+  if (!stateFr || !validFinalReviewStatuses.has(stateFr.status)) {
+    diagnostics.push(
+      stateFr ? `PRD Run State finalReview status is "${stateFr.status}". Expected "final_reviewed" or "succeeded".` : "PRD Run State has no finalReview receipt."
+    );
+    return {
+      ok: false,
+      reason: diagnostics[0],
+      diagnostics
+    };
+  }
+  if (!localFr) {
+    diagnostics.push("Local PRD Run Store has no finalReview receipt.");
+    return {
+      ok: false,
+      reason: diagnostics[0],
+      diagnostics
+    };
+  }
+  const mismatchFields = [];
+  if (stateFr.targetName !== localFr.targetName)
+    mismatchFields.push("targetName");
+  if (stateFr.prdBranch !== localFr.prdBranch) mismatchFields.push("prdBranch");
+  if (stateFr.mergeBase !== localFr.mergeBase) mismatchFields.push("mergeBase");
+  if (stateFr.verdict !== localFr.verdict) mismatchFields.push("verdict");
+  if (mismatchFields.length > 0) {
+    const reason = `Dual receipt mismatch on fields: ${mismatchFields.join(", ")}`;
+    diagnostics.push(reason);
+    return { ok: false, reason, diagnostics };
+  }
+  return { ok: true };
+}
 async function runPrdRunFinalReviewCommand(options) {
   const prdRef = normalizePrdRunRef2(options.prdRef);
   const targetName = options.targetName.trim();
@@ -10754,6 +11297,39 @@ async function runPrdRunFinalReviewCommand(options) {
       offendingPaths: []
     };
   }
+  if (record.mode === "local") {
+    const runnableIssues = await getRunnableLocalIssues(
+      prdRef,
+      options.repoRoot
+    );
+    if (runnableIssues.length > 0) {
+      const reason = `PRD Run ${prdRef} is marked "drained" but ${runnableIssues.length} runnable local Issues remain. Queue drain receipt may be premature.`;
+      writePrdRunRecord(options.repoRoot, {
+        ...record,
+        status: "blocked",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        blockedGate: "final-review",
+        blockedReason: reason,
+        diagnostics: [
+          `Current status: ${record.status}`,
+          `Runnable issues remaining: ${runnableIssues.length}`
+        ],
+        targetName,
+        offendingPaths: []
+      });
+      return {
+        prdRef,
+        status: "blocked",
+        blockedGate: "final-review",
+        blockedReason: reason,
+        diagnostics: [
+          `Current status: ${record.status}`,
+          `Runnable issues remaining: ${runnableIssues.length}`
+        ],
+        offendingPaths: []
+      };
+    }
+  }
   if (!options.issueProvider) {
     const reason = "Missing IssueProvider. Cannot validate child completeness.";
     writePrdRunRecord(options.repoRoot, {
@@ -10862,8 +11438,19 @@ async function runPrdRunFinalReviewCommand(options) {
       offendingPaths: []
     };
   }
-  const verificationCommands = targetConfig.strategy.verify?.commands ?? [];
-  const mergeBaseResult = computeFinalReviewMergeBase(options.repoRoot, prdRef);
+  const isLocalMode = record.mode === "local";
+  let mergeBaseResult;
+  let prdBranch;
+  if (isLocalMode) {
+    prdBranch = getLocalPrdBranchName(prdRef);
+    mergeBaseResult = computeLocalFinalReviewMergeBase(
+      options.repoRoot,
+      prdBranch
+    );
+  } else {
+    prdBranch = record.prdBranch ?? prdRef;
+    mergeBaseResult = computeFinalReviewMergeBase(options.repoRoot, prdRef);
+  }
   if (!mergeBaseResult.ok) {
     writePrdRunRecord(options.repoRoot, {
       ...record,
@@ -10876,7 +11463,7 @@ async function runPrdRunFinalReviewCommand(options) {
       finalReview: {
         status: "blocked",
         targetName,
-        prdBranch: record.prdBranch ?? prdRef,
+        prdBranch,
         mergeBase: mergeBaseResult.mergeBase,
         diagnostics: mergeBaseResult.diagnostics,
         reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -10892,7 +11479,6 @@ async function runPrdRunFinalReviewCommand(options) {
       offendingPaths: []
     };
   }
-  const prdBranch = record.prdBranch ?? prdRef;
   const manifestResult = readPlanningArtifactManifest(options.repoRoot, prdRef);
   if (!manifestResult.ok) {
     const reason = `Evidence Packet construction failed: ${manifestResult.reason}`;
@@ -10952,11 +11538,12 @@ async function runPrdRunFinalReviewCommand(options) {
     planning: record.planning,
     finalReview: startReceipt
   });
-  const finalReviewBranchName = buildFinalReviewBranchName(prdBranch);
+  const finalReviewBranchName = isLocalMode ? `${prdBranch.replace(/\//g, "-")}-final-review-retouch` : buildFinalReviewBranchName(prdBranch);
   const worktreeResult = ensureFinalReviewWorktree({
     repoRoot: options.repoRoot,
     branchName: finalReviewBranchName,
-    checkoutBase: prdBranch
+    checkoutBase: prdBranch,
+    isLocal: isLocalMode
   });
   if (!worktreeResult.ok) {
     writePrdRunRecord(options.repoRoot, {
@@ -10997,8 +11584,7 @@ async function runPrdRunFinalReviewCommand(options) {
         repoRoot: options.repoRoot,
         promptTemplate: finalReviewConfig.promptTemplate,
         targetName,
-        evidencePacket,
-        verificationCommands
+        evidencePacket
       }),
       target: targetConfig,
       repoRoot: options.repoRoot,
@@ -11072,7 +11658,7 @@ async function runPrdRunFinalReviewCommand(options) {
     };
   }
   const resolvedWorktreePath = executionResult.worktreePath;
-  const artifactPath = join20(
+  const artifactPath = join21(
     resolvedWorktreePath,
     ".pourkit/final-review-artifact.json"
   );
@@ -11141,6 +11727,7 @@ async function runPrdRunFinalReviewCommand(options) {
   }
   const { verdict, summary, diagnostics: artifactDiagnostics } = artifactResult;
   if (verdict === "pass_no_changes") {
+    const reviewedAt = (/* @__PURE__ */ new Date()).toISOString();
     const receipt = {
       status: "succeeded",
       targetName,
@@ -11149,17 +11736,29 @@ async function runPrdRunFinalReviewCommand(options) {
       verdict: "pass_no_changes",
       artifactPath: ".pourkit/final-review-artifact.json",
       diagnostics: [],
-      reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+      reviewedAt
     };
     writePrdRunRecord(options.repoRoot, {
       ...record,
       status: "final_reviewed",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: reviewedAt,
       targetName,
       start: record.start,
       planning: record.planning,
       finalReview: receipt
     });
+    const blocked = await writeAndVerifyLocalDualReceipt(
+      options.repoRoot,
+      prdRef,
+      record,
+      targetName,
+      prdBranch,
+      mergeBaseResult.mergeBase,
+      "pass_no_changes",
+      reviewedAt,
+      isLocalMode
+    );
+    if (blocked) return blocked;
     return {
       prdRef,
       status: "final_reviewed",
@@ -11168,7 +11767,7 @@ async function runPrdRunFinalReviewCommand(options) {
     };
   }
   if (verdict === "pass_with_retouch") {
-    if (!options.prProvider) {
+    if (!options.prProvider && !isLocalMode) {
       const reason = "Missing PRProvider. Cannot create retouch PR without a PR provider.";
       writePrdRunRecord(options.repoRoot, {
         ...record,
@@ -11199,7 +11798,7 @@ async function runPrdRunFinalReviewCommand(options) {
       };
     }
     const autoMerge = options.autoMerge ?? true;
-    const existingRetouchPrNumber = record.finalReview?.retouchPrNumber;
+    const existingRetouchPrNumber = !isLocalMode ? record.finalReview?.retouchPrNumber : void 0;
     if (existingRetouchPrNumber && autoMerge) {
       const existingPr = await getPrByNumberIfAvailable(
         options.prProvider,
@@ -11285,7 +11884,6 @@ async function runPrdRunFinalReviewCommand(options) {
       mergeBase: mergeBaseResult.mergeBase,
       summary,
       changedPaths: scopeResult.changedPaths,
-      verificationCommands,
       logger: options.logger
     });
     if (!finalizerResult.ok) {
@@ -11317,6 +11915,116 @@ async function runPrdRunFinalReviewCommand(options) {
         offendingPaths: []
       };
     }
+    if (isLocalMode) {
+      let localResult;
+      try {
+        const result = await squashFinalReviewRetouch(
+          prdRef,
+          options.repoRoot,
+          finalizerResult.title,
+          finalizerResult.body
+        );
+        if (!result) {
+          const reason = "Retouch branch missing or empty. Cannot squash-merge.";
+          writePrdRunRecord(options.repoRoot, {
+            ...record,
+            status: "blocked",
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            blockedGate: "final-review",
+            blockedReason: reason,
+            diagnostics: [reason],
+            targetName,
+            finalReview: {
+              status: "blocked",
+              targetName,
+              prdBranch,
+              mergeBase: mergeBaseResult.mergeBase,
+              verdict: "pass_with_retouch",
+              diagnostics: [reason],
+              reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            offendingPaths: []
+          });
+          return {
+            prdRef,
+            status: "blocked",
+            blockedGate: "final-review",
+            blockedReason: reason,
+            diagnostics: [reason],
+            offendingPaths: []
+          };
+        }
+        localResult = result;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        writePrdRunRecord(options.repoRoot, {
+          ...record,
+          status: "blocked",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          blockedGate: "final-review",
+          blockedReason: `Local retouch squash-merge failed: ${msg}`,
+          diagnostics: [msg],
+          targetName,
+          finalReview: {
+            status: "blocked",
+            targetName,
+            prdBranch,
+            mergeBase: mergeBaseResult.mergeBase,
+            verdict: "pass_with_retouch",
+            diagnostics: [msg],
+            reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          offendingPaths: []
+        });
+        return {
+          prdRef,
+          status: "blocked",
+          blockedGate: "final-review",
+          blockedReason: `Local retouch squash-merge failed: ${msg}`,
+          diagnostics: [msg],
+          offendingPaths: []
+        };
+      }
+      const receipt2 = {
+        status: "final_reviewed",
+        targetName,
+        prdBranch,
+        mergeBase: mergeBaseResult.mergeBase,
+        verdict: "pass_with_retouch",
+        artifactPath: ".pourkit/final-review-artifact.json",
+        diagnostics: [],
+        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        retouchMergeCommit: localResult.mergeCommit,
+        changedPaths: localResult.changedPaths
+      };
+      writePrdRunRecord(options.repoRoot, {
+        ...record,
+        status: "final_reviewed",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        targetName,
+        start: record.start,
+        planning: record.planning,
+        finalReview: receipt2
+      });
+      const blocked = await writeAndVerifyLocalDualReceipt(
+        options.repoRoot,
+        prdRef,
+        record,
+        targetName,
+        prdBranch,
+        mergeBaseResult.mergeBase,
+        "pass_with_retouch",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        isLocalMode
+      );
+      if (blocked) return blocked;
+      return {
+        prdRef,
+        status: "final_reviewed",
+        finalReview: receipt2,
+        diagnostics: []
+      };
+    }
     let retouchPr;
     try {
       retouchPr = await createOrReuseFinalReviewRetouchPr({
@@ -11656,7 +12364,7 @@ async function runPrdRunFinalReviewCommand(options) {
 function runPrdRunValidateFinalReviewCommand(options) {
   const prdRef = normalizePrdRunRef2(options.prdRef);
   const checkoutBase = options.checkoutBase ?? prdRef;
-  const artifactPath = options.artifactPath ? options.artifactPath : join20(options.repoRoot, ".pourkit", "final-review-artifact.json");
+  const artifactPath = options.artifactPath ? options.artifactPath : join21(options.repoRoot, ".pourkit", "final-review-artifact.json");
   const artifact = parseFinalReviewArtifact(artifactPath);
   if (!artifact.ok) {
     return {
@@ -11670,7 +12378,7 @@ function runPrdRunValidateFinalReviewCommand(options) {
   }
   let changedPaths = options.changedPaths;
   if (artifact.verdict === "pass_with_retouch" && (!changedPaths || changedPaths.length === 0) && (!artifact.changedPaths || artifact.changedPaths.length === 0)) {
-    const diffResult = spawnSync2(
+    const diffResult = spawnSync3(
       "git",
       ["diff", "--name-only", options.reviewBase, "HEAD", "--", "."],
       { cwd: options.repoRoot, encoding: "utf8" }
@@ -11822,12 +12530,12 @@ async function runReconcilePreflightAndSetup(options) {
   );
   const worktreeCwd = worktreePath;
   const existingReconciliationReceipt = record.reconciliation;
-  const existingLocalBranch = spawnSync2(
+  const existingLocalBranch = spawnSync3(
     "git",
     ["rev-parse", "--verify", "--quiet", reconciliationBranchName],
     { cwd: options.repoRoot, encoding: "utf8" }
   ).status === 0;
-  const existingWorktree = spawnSync2(
+  const existingWorktree = spawnSync3(
     "git",
     ["worktree", "list", "--porcelain"],
     { cwd: options.repoRoot, encoding: "utf8" }
@@ -11880,7 +12588,7 @@ async function runReconcilePreflightAndSetup(options) {
         branchAction: "blocked"
       };
     }
-    const resetResult = spawnSync2(
+    const resetResult = spawnSync3(
       "git",
       ["reset", "--hard", `origin/${prdBranch}`],
       { cwd: worktreeCwd, encoding: "utf8" }
@@ -11923,7 +12631,7 @@ async function runReconcilePreflightAndSetup(options) {
       );
       return { ok: false, diagnostics, branchAction: "blocked" };
     }
-    const adoptionCheck = spawnSync2(
+    const adoptionCheck = spawnSync3(
       "git",
       [
         "merge-base",
@@ -11971,7 +12679,7 @@ async function runReconcilePreflightAndSetup(options) {
     );
     return { ok: false, diagnostics, branchAction: "blocked" };
   }
-  const branchResult = spawnSync2(
+  const branchResult = spawnSync3(
     "git",
     ["branch", "-f", reconciliationBranchName, `origin/${prdBranch}`],
     { cwd: options.repoRoot, encoding: "utf8" }
@@ -11986,13 +12694,13 @@ async function runReconcilePreflightAndSetup(options) {
     return { ok: false, diagnostics, branchAction: "blocked" };
   }
   mkdirSync11(dirname5(worktreePath), { recursive: true });
-  const addResult = spawnSync2(
+  const addResult = spawnSync3(
     "git",
     ["worktree", "add", worktreePath, reconciliationBranchName],
     { cwd: options.repoRoot, encoding: "utf8" }
   );
   if (addResult.status !== 0) {
-    spawnSync2("git", ["branch", "-D", reconciliationBranchName], {
+    spawnSync3("git", ["branch", "-D", reconciliationBranchName], {
       cwd: options.repoRoot,
       encoding: "utf8"
     });
@@ -12040,7 +12748,7 @@ function buildReconciliationPrBody(options) {
 function commitAndPushReconciliationChanges(options) {
   const diagnostics = [];
   const existingPaths = options.changedPlanningPaths.filter((p) => {
-    return existsSync17(join20(options.worktreeCwd, p));
+    return existsSync17(join21(options.worktreeCwd, p));
   });
   if (existingPaths.length === 0) {
     diagnostics.push(
@@ -12048,7 +12756,7 @@ function commitAndPushReconciliationChanges(options) {
     );
     return { ok: true, diagnostics: [...diagnostics] };
   }
-  const addResult = spawnSync2("git", ["add", "--", ...existingPaths], {
+  const addResult = spawnSync3("git", ["add", "--", ...existingPaths], {
     cwd: options.worktreeCwd,
     encoding: "utf8"
   });
@@ -12065,7 +12773,7 @@ function commitAndPushReconciliationChanges(options) {
     };
   }
   const commitTitle = `docs: reconcile ${normalizePrdRunRef2(options.prdRef)} architecture`;
-  const commitResult = spawnSync2("git", ["commit", "-m", commitTitle], {
+  const commitResult = spawnSync3("git", ["commit", "-m", commitTitle], {
     cwd: options.worktreeCwd,
     encoding: "utf8"
   });
@@ -12089,7 +12797,7 @@ function commitAndPushReconciliationChanges(options) {
       };
     }
   }
-  const pushResult = spawnSync2(
+  const pushResult = spawnSync3(
     "git",
     [
       "push",
@@ -12183,7 +12891,7 @@ async function runPrdRunReconcileCommand(options) {
   const record = preflightResult.record;
   const prdBranch = record?.prdBranch ?? prdRef;
   const mergeBase = preflightResult.mergeBase;
-  const worktreeCwd = preflightResult.worktreePath ? join20(options.repoRoot, preflightResult.worktreePath) : options.repoRoot;
+  const worktreeCwd = preflightResult.worktreePath ? join21(options.repoRoot, preflightResult.worktreePath) : options.repoRoot;
   const staleSucceededRecovery = assessStaleSucceededReconciliationReceipt({
     receipt: record?.reconciliation,
     worktreeCwd,
@@ -12485,7 +13193,7 @@ async function runPrdRunReconcileCommand(options) {
       baseRef: prdBranch,
       checkoutBase,
       reviewBase: mergeBase,
-      worktreePath: join20(options.repoRoot, preflightResult.worktreePath),
+      worktreePath: join21(options.repoRoot, preflightResult.worktreePath),
       sandbox: options.config.sandbox,
       artifactPath,
       logger: options.logger
@@ -12586,7 +13294,7 @@ async function runPrdRunReconcileCommand(options) {
       offendingPaths: []
     };
   }
-  const fullArtifactPath = join20(executionResult.worktreePath, artifactPath);
+  const fullArtifactPath = join21(executionResult.worktreePath, artifactPath);
   let artifactContent;
   try {
     artifactContent = JSON.parse(retryResult.artifact.value);
@@ -12693,11 +13401,11 @@ async function runPrdRunReconcileCommand(options) {
   const artifactResult = artifactContent.result ?? "changes_produced";
   const artifactChangedPaths = artifactContent.changedPlanningPaths ?? [];
   const artifactNoChangeRationale = artifactContent.noChangeRationale;
-  const gitStatusResult = spawnSync2("git", ["status", "--short"], {
+  const gitStatusResult = spawnSync3("git", ["status", "--short"], {
     cwd: worktreeCwd,
     encoding: "utf8"
   });
-  const gitDiffResult = spawnSync2("git", ["diff", "--name-status"], {
+  const gitDiffResult = spawnSync3("git", ["diff", "--name-status"], {
     cwd: worktreeCwd,
     encoding: "utf8"
   });
@@ -13450,7 +14158,7 @@ async function runPrdRunReconcileCommand(options) {
 }
 function computeFinalReviewMergeBase(repoRoot2, prdRef) {
   const normalized = normalizePrdRunRef2(prdRef);
-  const fetchResult = spawnSync2("git", ["fetch", "origin", "dev", normalized], {
+  const fetchResult = spawnSync3("git", ["fetch", "origin", "dev", normalized], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -13470,7 +14178,7 @@ function computeFinalReviewMergeBase(repoRoot2, prdRef) {
   if (fetchResult.stderr?.toString?.()?.trim()) {
     fetchDiagnostics.push(fetchResult.stderr.toString().trim());
   }
-  const mergeBaseResult = spawnSync2(
+  const mergeBaseResult = spawnSync3(
     "git",
     ["merge-base", "origin/dev", `origin/${normalized}`],
     {
@@ -13506,6 +14214,37 @@ function computeFinalReviewMergeBase(repoRoot2, prdRef) {
   }
   return { ok: true, mergeBase, diagnostics: fetchDiagnostics };
 }
+function computeLocalFinalReviewMergeBase(repoRoot2, prdBranch) {
+  const mergeBaseResult = spawnSync3("git", ["merge-base", "dev", prdBranch], {
+    cwd: repoRoot2,
+    encoding: "utf8"
+  });
+  if (mergeBaseResult.status !== 0) {
+    const diagnostics = [];
+    if (mergeBaseResult.stderr?.toString?.()?.trim()) {
+      diagnostics.push(mergeBaseResult.stderr.toString().trim());
+    }
+    if (mergeBaseResult.stdout?.toString?.()?.trim()) {
+      diagnostics.push(mergeBaseResult.stdout.toString().trim());
+    }
+    return {
+      ok: false,
+      gate: "final-review",
+      reason: `Final Review merge-base computation failed for dev and ${prdBranch}.`,
+      diagnostics: diagnostics.length > 0 ? diagnostics : ["git merge-base returned non-zero exit status"]
+    };
+  }
+  const mergeBase = mergeBaseResult.stdout?.toString?.()?.trim();
+  if (!mergeBase) {
+    return {
+      ok: false,
+      gate: "final-review",
+      reason: `Final Review merge-base returned empty result for dev and ${prdBranch}.`,
+      diagnostics: [`merge-base stdout was empty for dev..${prdBranch}`]
+    };
+  }
+  return { ok: true, mergeBase, diagnostics: [] };
+}
 function validateReconciliationArtifact2(artifact, context) {
   const errors = [];
   if (!artifact.prdRef) {
@@ -13613,17 +14352,17 @@ function auditPrd047Implementation(repoRoot2, prdRef) {
   const blockerBugs = [];
   const blockersFixed = [];
   const nonBlockers = [];
-  const prdMirrorPath = join20(repoRoot2, PRD_047_PRD_MIRROR_PATH);
-  const completionsDir = join20(repoRoot2, dirname5(PRD_047_ESCAPE_HATCH_PATH));
+  const prdMirrorPath = join21(repoRoot2, PRD_047_PRD_MIRROR_PATH);
+  const completionsDir = join21(repoRoot2, dirname5(PRD_047_ESCAPE_HATCH_PATH));
   let escapeHatchPresent = false;
   if (existsSync17(completionsDir)) {
-    const files = readdirSync6(completionsDir);
+    const files = readdirSync5(completionsDir);
     escapeHatchPresent = files.some(
       (f) => f.endsWith(".md") && (f.includes("prd-047") || f.includes("prd-reconciliation"))
     );
   }
   if (!escapeHatchPresent) {
-    escapeHatchPresent = existsSync17(join20(repoRoot2, PRD_047_ESCAPE_HATCH_PATH));
+    escapeHatchPresent = existsSync17(join21(repoRoot2, PRD_047_ESCAPE_HATCH_PATH));
   }
   const prdMirrorExists = existsSync17(prdMirrorPath);
   if (!prdMirrorExists) {
@@ -13632,7 +14371,7 @@ function auditPrd047Implementation(repoRoot2, prdRef) {
     );
   }
   if (prdMirrorExists) {
-    const mirrorContent = readFileSync16(prdMirrorPath, "utf-8");
+    const mirrorContent = readFileSync17(prdMirrorPath, "utf-8");
     const hasReconcileCommand = mirrorContent.includes("prd-run reconcile");
     const hasEscapeHatch = mirrorContent.includes("escape hatch");
     if (!hasReconcileCommand) {
@@ -13646,16 +14385,16 @@ function auditPrd047Implementation(repoRoot2, prdRef) {
       );
     }
   }
-  const childIssueDir = join20(repoRoot2, PRD_047_CHILD_ISSUE_DIR);
+  const childIssueDir = join21(repoRoot2, PRD_047_CHILD_ISSUE_DIR);
   const childIssuesExist = existsSync17(childIssueDir);
   if (!childIssuesExist) {
     nonBlockers.push(
       `PRD-0047 child Issue mirrors not found at ${PRD_047_CHILD_ISSUE_DIR}.`
     );
   }
-  const manifestPath = join20(repoRoot2, PRD_047_MANIFEST_PATH);
+  const manifestPath = join21(repoRoot2, PRD_047_MANIFEST_PATH);
   if (existsSync17(manifestPath)) {
-    const manifestContent = readFileSync16(manifestPath, "utf-8");
+    const manifestContent = readFileSync17(manifestPath, "utf-8");
     if (!manifestContent.includes("ready_for_prepare")) {
       nonBlockers.push(
         "Planning Artifact Manifest is not marked as ready_for_prepare."
@@ -13744,6 +14483,17 @@ function runPrdRunAuditCommand(options) {
   const prdRef = normalizePrdRunRef2(options.prdRef);
   return auditPrd047Implementation(options.repoRoot, prdRef);
 }
+async function closeParentGitHubIssue(prdRef, repoRoot2, issueProvider) {
+  const prdResult = await resolveLocalPrdArtifact(prdRef, repoRoot2);
+  const parentIssueNumber = prdResult.ok ? prdResult.data.githubProjection.issueNumber : null;
+  if (!parentIssueNumber) return { closed: false, issueNumber: null };
+  try {
+    await issueProvider.closeIssue(parentIssueNumber);
+    return { closed: true, issueNumber: parentIssueNumber };
+  } catch {
+    return { closed: false, issueNumber: parentIssueNumber };
+  }
+}
 async function runPrdRunLaunchCommand(options) {
   const prdRef = normalizePrdRunRef2(options.prdRef);
   const attempted = [];
@@ -13755,10 +14505,11 @@ async function runPrdRunLaunchCommand(options) {
     const terminal = /* @__PURE__ */ new Set([
       "waiting_for_integration",
       "finalizing",
-      "complete"
+      "complete",
+      "completed_local_branch"
     ]);
     if (terminal.has(existingRecord.record.status)) {
-      return {
+      const result = {
         prdRef,
         status: existingRecord.record.status,
         attempted: [],
@@ -13768,10 +14519,38 @@ async function runPrdRunLaunchCommand(options) {
           `PRD Run ${prdRef} is already in status "${existingRecord.record.status}".`
         ]
       };
+      if (existingRecord.record.status === "completed_local_branch" && existingRecord.record.prdBranch) {
+        result.prdBranch = existingRecord.record.prdBranch;
+      }
+      return result;
     }
   }
   if (existingRecord.record) {
     const status = existingRecord.record.status;
+    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 {
+        prdRef,
+        status: "blocked",
+        attempted: [],
+        skipped: ["prepare", "start", "queue", "final-review", "reconcile"],
+        resumed: [],
+        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 or --local-override.`,
+        offendingPaths: []
+      };
+    }
     if (status === "drained") {
       skipped.push("prepare", "start", "queue");
       resumed.push("final-review");
@@ -13899,182 +14678,216 @@ async function runPrdRunLaunchCommand(options) {
     }
     diagnostics.push(...startResult.diagnostics);
     attempted.push("queue");
+    if (startResult.status === "drained" && options.issueProvider && existsSync17(join21(options.repoRoot, ".pourkit", "local-prd-runs", prdRef))) {
+      await closeParentGitHubIssue(
+        prdRef,
+        options.repoRoot,
+        options.issueProvider
+      );
+    }
+  }
+  let finalReviewResult;
+  if (!skipped.includes("final-review")) {
+    attempted.push("final-review");
+    if (existingRecord.record?.mode === "local") {
+      const runnableIssues = await getRunnableLocalIssues(
+        prdRef,
+        options.repoRoot
+      );
+      if (runnableIssues.length > 0) {
+        const reason = `Config-local Final Review blocked: Queue not drained (${runnableIssues.length} runnable Issues remain).`;
+        return {
+          prdRef,
+          status: "blocked",
+          attempted,
+          skipped: ["start", "queue", "reconcile"],
+          resumed,
+          diagnostics: [reason],
+          blockedGate: "final-review",
+          blockedReason: reason,
+          offendingPaths: [],
+          prepare: prepareResult,
+          start: startResult,
+          finalReview: {
+            prdRef,
+            status: "blocked",
+            blockedGate: "final-review",
+            blockedReason: reason,
+            diagnostics: [reason],
+            offendingPaths: []
+          }
+        };
+      }
+    }
+    finalReviewResult = await runPrdRunFinalReviewCommand({
+      repoRoot: options.repoRoot,
+      prdRef,
+      targetName: options.targetName,
+      autoMerge: options.autoMerge,
+      issueProvider: options.issueProvider,
+      prProvider: options.prProvider,
+      executionProvider: options.executionProvider,
+      config: options.config,
+      logger: options.logger
+    });
+    const skippedAfterFr = [
+      ...skipped.includes("prepare") ? ["prepare"] : [],
+      ...skipped.includes("start") ? ["queue"] : [],
+      "reconcile"
+    ];
+    if (finalReviewResult.status === "blocked") {
+      return {
+        prdRef,
+        status: "blocked",
+        attempted,
+        skipped: skippedAfterFr,
+        resumed,
+        diagnostics: finalReviewResult.diagnostics,
+        blockedGate: "final-review",
+        blockedReason: finalReviewResult.blockedReason,
+        offendingPaths: finalReviewResult.offendingPaths,
+        prepare: prepareResult,
+        start: startResult,
+        finalReview: finalReviewResult
+      };
+    }
+    if (finalReviewResult.status === "needs_human_review") {
+      return {
+        prdRef,
+        status: "blocked",
+        attempted,
+        skipped: skippedAfterFr,
+        resumed,
+        diagnostics: finalReviewResult.diagnostics,
+        blockedGate: "final-review",
+        blockedReason: finalReviewResult.finalReview.verdict ?? "needs_human_review",
+        offendingPaths: [],
+        prepare: prepareResult,
+        start: startResult,
+        finalReview: finalReviewResult
+      };
+    }
+    diagnostics.push(...finalReviewResult.diagnostics);
   }
-  let finalReviewResult;
-  if (!skipped.includes("final-review")) {
-    attempted.push("final-review");
-    const localStorePath = join20(
+  let reconcileResult;
+  if (!skipped.includes("reconcile")) {
+    attempted.push("reconcile");
+    const localStorePath2 = join21(
       options.repoRoot,
       ".pourkit",
       "local-prd-runs",
       prdRef
     );
-    if (existsSync17(localStorePath)) {
-      const targetConfig = options.config?.targets?.find(
-        (t) => t.name === options.targetName
-      );
-      const verificationCommands = targetConfig?.strategy?.verify?.commands ?? [];
-      const localResult = await runLocalFinalReview(prdRef, {
-        repoRoot: options.repoRoot,
-        verificationCommands
-      });
-      if (!localResult.ok) {
-        const reason = localResult.message ?? "Local Final Review blocked.";
-        writePrdRunRecord(options.repoRoot, {
-          prdRef,
-          status: "blocked",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          blockedGate: "final-review",
-          blockedReason: reason,
-          diagnostics: [reason],
-          targetName: options.targetName,
-          offendingPaths: []
-        });
+    if (existsSync17(localStorePath2)) {
+      const prdRecord = readPrdRun(options.repoRoot, prdRef);
+      const finalReviewReceipt = prdRecord.record?.finalReview;
+      const hasCompletedFinalReview = finalReviewReceipt?.status === "final_reviewed" || finalReviewReceipt?.status === "succeeded";
+      if (!hasCompletedFinalReview) {
+        const reason = `Reconciliation blocked: Final Review not completed. Run Final Review before reconciliation.`;
         return {
           prdRef,
           status: "blocked",
           attempted,
-          skipped: [
-            ...skipped.includes("prepare") ? ["prepare"] : [],
-            ...skipped.includes("start") ? ["queue"] : [],
-            "reconcile"
-          ],
+          skipped: [...skipped],
           resumed,
           diagnostics: [reason],
-          blockedGate: "final-review",
+          blockedGate: "reconciliation",
           blockedReason: reason,
           offendingPaths: [],
           prepare: prepareResult,
-          start: startResult
+          start: startResult,
+          finalReview: finalReviewResult
         };
       }
-      if (localResult.verdict === "pass_with_retouch") {
-        try {
-          await squashFinalReviewRetouch(prdRef, options.repoRoot);
-        } catch (error) {
-          const reason = error instanceof Error ? error.message : String(error);
-          writePrdRunRecord(options.repoRoot, {
-            prdRef,
-            status: "blocked",
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            blockedGate: "final-review",
-            blockedReason: reason,
-            diagnostics: [reason],
-            targetName: options.targetName,
-            offendingPaths: []
-          });
+      if (prdRecord.record?.mode === "local") {
+        const dualCheck = await verifyLocalDualFinalReviewReceipts(
+          options.repoRoot,
+          prdRef
+        );
+        if (!dualCheck.ok) {
           return {
             prdRef,
             status: "blocked",
             attempted,
-            skipped: [
-              ...skipped.includes("prepare") ? ["prepare"] : [],
-              ...skipped.includes("start") ? ["queue"] : [],
-              "reconcile"
-            ],
+            skipped: [...skipped],
             resumed,
-            diagnostics: [reason],
-            blockedGate: "final-review",
-            blockedReason: reason,
+            diagnostics: dualCheck.diagnostics,
+            blockedGate: "reconciliation",
+            blockedReason: dualCheck.reason,
             offendingPaths: [],
             prepare: prepareResult,
-            start: startResult
+            start: startResult,
+            finalReview: finalReviewResult
           };
         }
       }
-      const mappedVerdict = localResult.verdict === "pass" ? "pass_no_changes" : localResult.verdict;
+      const localResult = await runLocalReconciliation(prdRef, {
+        repoRoot: options.repoRoot
+      });
+      if (!localResult.ok) {
+        return {
+          prdRef,
+          status: "blocked",
+          attempted,
+          skipped: [...skipped],
+          resumed,
+          diagnostics: localResult.message ? [localResult.message] : [],
+          blockedGate: "reconciliation",
+          blockedReason: localResult.message ?? "Local reconciliation blocked.",
+          offendingPaths: [],
+          prepare: prepareResult,
+          start: startResult,
+          finalReview: finalReviewResult
+        };
+      }
       const receipt = {
-        status: "final_reviewed",
+        status: "succeeded",
+        result: localResult.receipt?.result,
+        changedPlanningPaths: localResult.receipt?.changedPlanningPaths,
         targetName: options.targetName,
-        prdBranch: `local/${prdRef}`,
-        diagnostics: [],
-        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        verdict: mappedVerdict
+        prdBranch: localResult.receipt?.prdBranch ?? `local/${prdRef}`,
+        mergeCommit: localResult.receipt?.mergeCommit,
+        reconciledAt: localResult.receipt?.reconciledTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+        autoMerge: false,
+        agentIdentity: "pourkit-architect",
+        noChange: localResult.receipt?.result === "no_changes_needed",
+        source: "dev",
+        target: localResult.receipt?.prdBranch ?? `local/${prdRef}`
       };
       const existingRecord2 = readPrdRun(options.repoRoot, prdRef);
       writePrdRunRecord(options.repoRoot, {
         prdRef,
-        status: "final_reviewed",
+        status: "completed_local_branch",
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         targetName: options.targetName,
+        prdBranch: `local/${prdRef}`,
         manifestPath: existingRecord2.record?.manifestPath,
         planning: existingRecord2.record?.planning,
         start: existingRecord2.record?.start,
-        finalReview: receipt
+        finalReview: existingRecord2.record?.finalReview,
+        reconciliation: receipt,
+        scopeChanges: existingRecord2.record?.scopeChanges
       });
-      finalReviewResult = {
+      reconcileResult = {
         prdRef,
-        status: "final_reviewed",
-        finalReview: receipt,
-        diagnostics: localResult.message ? [localResult.message] : []
+        status: "succeeded",
+        reconciliation: receipt,
+        diagnostics: []
       };
-      diagnostics.push(...localResult.message ? [localResult.message] : []);
+      diagnostics.push("Local reconciliation completed.");
     } else {
-      finalReviewResult = await runPrdRunFinalReviewCommand({
+      reconcileResult = await runPrdRunReconcileCommand({
         repoRoot: options.repoRoot,
         prdRef,
         targetName: options.targetName,
-        autoMerge: options.autoMerge,
-        issueProvider: options.issueProvider,
-        prProvider: options.prProvider,
-        executionProvider: options.executionProvider,
         config: options.config,
-        logger: options.logger
+        logger: options.logger,
+        executionProvider: options.executionProvider,
+        prProvider: options.prProvider,
+        autoMerge: options.autoMerge
       });
     }
-    const skippedAfterFr = [
-      ...skipped.includes("prepare") ? ["prepare"] : [],
-      ...skipped.includes("start") ? ["queue"] : [],
-      "reconcile"
-    ];
-    if (finalReviewResult.status === "blocked") {
-      return {
-        prdRef,
-        status: "blocked",
-        attempted,
-        skipped: skippedAfterFr,
-        resumed,
-        diagnostics: finalReviewResult.diagnostics,
-        blockedGate: "final-review",
-        blockedReason: finalReviewResult.blockedReason,
-        offendingPaths: finalReviewResult.offendingPaths,
-        prepare: prepareResult,
-        start: startResult,
-        finalReview: finalReviewResult
-      };
-    }
-    if (finalReviewResult.status === "needs_human_review") {
-      return {
-        prdRef,
-        status: "blocked",
-        attempted,
-        skipped: skippedAfterFr,
-        resumed,
-        diagnostics: finalReviewResult.diagnostics,
-        blockedGate: "final-review",
-        blockedReason: finalReviewResult.finalReview.verdict ?? "needs_human_review",
-        offendingPaths: [],
-        prepare: prepareResult,
-        start: startResult,
-        finalReview: finalReviewResult
-      };
-    }
-    diagnostics.push(...finalReviewResult.diagnostics);
-  }
-  let reconcileResult;
-  if (!skipped.includes("reconcile")) {
-    attempted.push("reconcile");
-    reconcileResult = await runPrdRunReconcileCommand({
-      repoRoot: options.repoRoot,
-      prdRef,
-      targetName: options.targetName,
-      config: options.config,
-      logger: options.logger,
-      executionProvider: options.executionProvider,
-      prProvider: options.prProvider,
-      autoMerge: options.autoMerge
-    });
-    if (reconcileResult.status === "blocked") {
+    if (reconcileResult && reconcileResult.status === "blocked") {
       return {
         prdRef,
         status: "blocked",
@@ -14091,7 +14904,9 @@ async function runPrdRunLaunchCommand(options) {
         reconcile: reconcileResult
       };
     }
-    diagnostics.push(...reconcileResult.diagnostics);
+    if (reconcileResult) {
+      diagnostics.push(...reconcileResult.diagnostics);
+    }
   }
   const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
   const reconciliationReceipt = reconcileResult && reconcileResult.status === "succeeded" ? reconcileResult.reconciliation : currentRecord?.reconciliation;
@@ -14174,6 +14989,29 @@ async function runPrdRunLaunchCommand(options) {
       reconcile: reconcileResult
     };
   }
+  const localStorePath = join21(
+    options.repoRoot,
+    ".pourkit",
+    "local-prd-runs",
+    prdRef
+  );
+  if (existsSync17(localStorePath)) {
+    return {
+      prdRef,
+      status: "completed_local_branch",
+      prdBranch: `local/${prdRef}`,
+      attempted,
+      skipped,
+      resumed,
+      diagnostics: [
+        `Local PRD Run ${prdRef} completed. Branch: local/${prdRef}.`
+      ],
+      prepare: prepareResult,
+      start: startResult,
+      finalReview: finalReviewResult,
+      reconcile: reconcileResult
+    };
+  }
   writePrdRunRecord(options.repoRoot, {
     prdRef,
     status: "waiting_for_integration",
@@ -14503,7 +15341,7 @@ async function runLocalStartCommand(prdId, repoRoot2) {
   const branch = `local/${normalizedRef}`;
   const branchExists = (() => {
     try {
-      return spawnSync2("git", ["rev-parse", "--verify", "--quiet", branch], {
+      return spawnSync3("git", ["rev-parse", "--verify", "--quiet", branch], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
@@ -14523,7 +15361,7 @@ async function runLocalStartCommand(prdId, repoRoot2) {
       message: `Branch ${branch} already exists without a matching start receipt. Remove it manually or use a different PRD ID.`
     };
   }
-  const branchResult = spawnSync2("git", ["branch", branch], {
+  const branchResult = spawnSync3("git", ["branch", branch], {
     cwd: root,
     encoding: "utf8",
     stdio: "pipe"
@@ -14538,7 +15376,7 @@ async function runLocalStartCommand(prdId, repoRoot2) {
   }
   const baseCommit = (() => {
     try {
-      return spawnSync2("git", ["rev-parse", "HEAD"], {
+      return spawnSync3("git", ["rev-parse", "HEAD"], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
@@ -14660,6 +15498,17 @@ async function runLocalLaunchCommand(prdId, repoRoot2) {
         };
         return { ok: false, failedStage: "finalReview", stages };
       }
+      if (result.verdict === "blocked" || result.verdict === "needs_human_review") {
+        stages.finalReview = {
+          ok: false,
+          stage: "finalReview",
+          failureCode: result.verdict === "blocked" ? "final_review_blocked" : "needs_human_review",
+          repairabilityClass: "manual",
+          reason: result.message ?? `Final Review verdict: ${result.verdict}`,
+          repairGuidance: `Fix final review failures and rerun \`pourkit prd-run launch --local ${normalizedRef}\`.`
+        };
+        return { ok: false, failedStage: "finalReview", stages };
+      }
       if (result.verdict === "pass_with_retouch") {
         try {
           await squashFinalReviewRetouch(normalizedRef, root);
@@ -14779,6 +15628,32 @@ async function runPrdRunStartCommand(options) {
     );
   }
   const existingRecord = readPrdRun(options.repoRoot, prdRef);
+  const resolvedMode = options.config ? (() => {
+    try {
+      const target = resolveTarget(options.config, targetName);
+      return resolvePrdRunMode(target).mode;
+    } catch {
+      return void 0;
+    }
+  })() : 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: [
+        `Recorded mode: ${existingRecord.record.mode}`,
+        `Resolved mode: ${resolvedMode}`
+      ],
+      offendingPaths: []
+    };
+    persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
+      manifestPath: existingRecord.record?.manifestPath,
+      planning: existingRecord.record?.planning,
+      targetName
+    });
+    return buildBlockedStartResult(prdRef, failure);
+  }
   if (existingRecord.record?.start) {
     const fetchResult2 = fetchOriginDev(options.repoRoot);
     if (!fetchResult2.ok) {
@@ -14814,7 +15689,8 @@ async function runPrdRunStartCommand(options) {
             ...reusedStart
           },
           {
-            targetName
+            targetName,
+            mode: resolvedMode
           }
         );
         return await processStartResult(
@@ -14917,6 +15793,7 @@ async function runPrdRunStartCommand(options) {
         },
         {
           targetName,
+          mode: resolvedMode,
           manifestPath: existingRecord.record?.manifestPath,
           planning: existingRecord.record?.planning
         }
@@ -15076,6 +15953,7 @@ async function runPrdRunStartCommand(options) {
       },
       {
         targetName,
+        mode: resolvedMode,
         manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath,
         planning: existingRecord.record?.planning
       }
@@ -15158,6 +16036,68 @@ async function runPrdRunStartCommand(options) {
     });
     return buildBlockedStartResult(prdRef, failure);
   }
+  if (resolvedMode === "local") {
+    const localBranchResult = materializeLocalPrdBranch(
+      prdRef,
+      fetchResult.startBaseCommit,
+      options.repoRoot
+    );
+    if (!localBranchResult.ok) {
+      const failure = {
+        ok: false,
+        gate: "branch-state",
+        reason: localBranchResult.message,
+        diagnostics: [localBranchResult.message],
+        offendingPaths: []
+      };
+      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
+        manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath,
+        planning: existingRecord.record?.planning,
+        targetName
+      });
+      return buildBlockedStartResult(prdRef, failure);
+    }
+    const localStoreDir = join21(
+      options.repoRoot,
+      ".pourkit",
+      "local-prd-runs",
+      prdRef
+    );
+    let localStoreReady = false;
+    if (existsSync17(localStoreDir)) {
+      const localStorePath = join21(localStoreDir, "prd.json");
+      try {
+        const content = JSON.parse(readFileSync17(localStorePath, "utf8"));
+        localStoreReady = content?.id === prdRef && content?.kind === "prd";
+      } catch {
+        localStoreReady = false;
+      }
+    }
+    const prereqs = {
+      localBranchName: getLocalPrdBranchName(prdRef),
+      localBranchExists: !localBranchResult.created,
+      localBranchCommit: fetchResult.startBaseCommit,
+      localStoreReady
+    };
+    if (existsSync17(localStoreDir) && !prereqs.localStoreReady) {
+      const failure = {
+        ok: false,
+        gate: "branch-state",
+        reason: `Local PRD Run Store not ready for ${prdRef}. Expected valid prd.json at .pourkit/local-prd-runs/${prdRef}/prd.json with matching PRD ID. Ensure Local PRD Run Store is initialized before starting.`,
+        diagnostics: [
+          `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
+          `Expected PRD ID: ${prdRef}`
+        ],
+        offendingPaths: []
+      };
+      persistBlockedPrdRunStartRecord(options.repoRoot, prdRef, failure, {
+        manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath,
+        planning: existingRecord.record?.planning,
+        targetName
+      });
+      return buildBlockedStartResult(prdRef, failure);
+    }
+  }
   const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const start = {
     status: "started",
@@ -15185,6 +16125,7 @@ async function runPrdRunStartCommand(options) {
     updatedAt,
     targetName,
     start,
+    mode: resolvedMode,
     manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath ?? void 0,
     planning: existingRecord.record?.planning
   });
@@ -15215,26 +16156,93 @@ async function processStartResult(startResult, options) {
   } catch {
     resolvedMode = void 0;
   }
+  const modeForRecord = resolvedMode?.mode;
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status: "running",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName: start.targetName,
     start,
+    mode: modeForRecord,
     manifestPath: existingRecord.record?.manifestPath,
     planning: existingRecord.record?.planning
   });
-  const localStorePath = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  const localStorePath = join21(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
   if (existsSync17(localStorePath)) {
-    const localIssues = await getRunnableLocalIssues(prdRef, repoRoot2);
+    const queueResult = await runLocalQueueLoop(
+      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,
+        manifestPath: existingRecord.record?.manifestPath,
+        planning: existingRecord.record?.planning,
+        blockedGate: "queue",
+        blockedReason: reason,
+        diagnostics,
+        offendingPaths: []
+      });
+      return {
+        prdRef,
+        status: "blocked",
+        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 = [
+        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,
+        manifestPath: existingRecord.record?.manifestPath,
+        planning: existingRecord.record?.planning,
+        blockedGate: "queue",
+        blockedReason: reason,
+        diagnostics,
+        offendingPaths: []
+      });
+      return {
+        prdRef,
+        status: "blocked",
+        blockedGate: "queue",
+        blockedReason: reason,
+        diagnostics,
+        offendingPaths: []
+      };
+    }
     start.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
-    start.queueProcessedCount = localIssues.length;
+    start.queueProcessedCount = queueResult.completedIssues.length + queueResult.blockedIssues.length;
     writePrdRunRecord(repoRoot2, {
       prdRef,
       status: "drained",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName: start.targetName,
       start,
+      mode: modeForRecord,
       manifestPath: existingRecord.record?.manifestPath,
       planning: existingRecord.record?.planning
     });
@@ -15277,6 +16285,7 @@ async function processStartResult(startResult, options) {
           diagnostics,
           targetName: start.targetName,
           start,
+          mode: existingRecord.record?.mode,
           manifestPath: existingRecord.record?.manifestPath,
           planning: existingRecord.record?.planning,
           offendingPaths: []
@@ -15298,6 +16307,7 @@ async function processStartResult(startResult, options) {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         targetName: start.targetName,
         start,
+        mode: existingRecord.record?.mode,
         manifestPath: existingRecord.record?.manifestPath,
         planning: existingRecord.record?.planning
       });
@@ -15319,6 +16329,7 @@ async function processStartResult(startResult, options) {
         diagnostics,
         targetName: start.targetName,
         start,
+        mode: existingRecord.record?.mode,
         manifestPath: existingRecord.record?.manifestPath,
         planning: existingRecord.record?.planning,
         offendingPaths: []
@@ -15343,6 +16354,7 @@ async function processStartResult(startResult, options) {
       diagnostics: outcomeDiagnostics,
       targetName: start.targetName,
       start,
+      mode: existingRecord.record?.mode,
       manifestPath: existingRecord.record?.manifestPath,
       planning: existingRecord.record?.planning,
       offendingPaths: []
@@ -15367,6 +16379,7 @@ async function processStartResult(startResult, options) {
       diagnostics,
       targetName: start.targetName,
       start,
+      mode: existingRecord.record?.mode,
       manifestPath: existingRecord.record?.manifestPath,
       planning: existingRecord.record?.planning,
       offendingPaths: []
@@ -15398,12 +16411,13 @@ function persistStartingPrdRunRecord(repoRoot2, prdRef, existingRecord, start, c
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName: context.targetName,
     start,
+    mode: context.mode,
     manifestPath: context.manifestPath ?? existingRecord.record?.manifestPath,
     planning: context.planning ?? existingRecord.record?.planning
   });
 }
 function inspectRemotePrdBranch(repoRoot2, prdRef) {
-  const result = spawnSync2("git", ["ls-remote", "--heads", "origin", prdRef], {
+  const result = spawnSync3("git", ["ls-remote", "--heads", "origin", prdRef], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15428,7 +16442,7 @@ function inspectRemotePrdBranch(repoRoot2, prdRef) {
 }
 function ensureAdoptableExistingPrdBranch(repoRoot2, prdRef, prepareMergeCommit) {
   const branchRef = `refs/remotes/origin/${prdRef}`;
-  const result = spawnSync2(
+  const result = spawnSync3(
     "git",
     ["merge-base", "--is-ancestor", prepareMergeCommit, branchRef],
     {
@@ -15558,7 +16572,7 @@ async function createOrReusePlanningPr(options) {
   });
 }
 function fetchOriginDev(repoRoot2) {
-  const fetchResult = spawnSync2("git", ["fetch", "origin", "dev"], {
+  const fetchResult = spawnSync3("git", ["fetch", "origin", "dev"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15575,7 +16589,7 @@ function fetchOriginDev(repoRoot2) {
       offendingPaths: []
     };
   }
-  const revParseResult = spawnSync2("git", ["rev-parse", "origin/dev"], {
+  const revParseResult = spawnSync3("git", ["rev-parse", "origin/dev"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15595,7 +16609,7 @@ function fetchOriginDev(repoRoot2) {
   return { ok: true, startBaseCommit: revParseResult.stdout.trim() };
 }
 function fetchPrdBranch(repoRoot2, prdRef) {
-  const result = spawnSync2("git", ["fetch", "origin", prdRef], {
+  const result = spawnSync3("git", ["fetch", "origin", prdRef], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15615,7 +16629,7 @@ function fetchPrdBranch(repoRoot2, prdRef) {
   return { ok: true };
 }
 function ensureAncestorGuard(repoRoot2, prepareMergeCommit, startBaseRef, startBaseCommit) {
-  const result = spawnSync2(
+  const result = spawnSync3(
     "git",
     ["merge-base", "--is-ancestor", prepareMergeCommit, startBaseRef],
     {
@@ -15642,7 +16656,7 @@ function ensureAncestorGuard(repoRoot2, prepareMergeCommit, startBaseRef, startB
   return { ok: true };
 }
 async function ensurePrdBranchPublished(repoRoot2, prdRef, startBaseCommit) {
-  const pushResult = spawnSync2(
+  const pushResult = spawnSync3(
     "git",
     ["push", "origin", `${startBaseCommit}:refs/heads/${prdRef}`],
     {
@@ -15695,7 +16709,7 @@ function buildPlanningPrBody(options) {
   ].join("\n");
 }
 function runGitOrThrow(cwd, args, label) {
-  const result = spawnSync2("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync3("git", args, { cwd, encoding: "utf8" });
   if (result.status !== 0) {
     throw new Error(
       `Failed to ${label}: ${[
@@ -15707,7 +16721,7 @@ function runGitOrThrow(cwd, args, label) {
   }
 }
 function validatePrepareAutoMergeDevCheckout(repoRoot2) {
-  const branchResult = spawnSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const branchResult = spawnSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15738,7 +16752,7 @@ function validatePrepareAutoMergeDevCheckout(repoRoot2) {
 function syncLocalDevToOriginDev(repoRoot2) {
   const branchResult = validatePrepareAutoMergeDevCheckout(repoRoot2);
   if (!branchResult.ok) return branchResult;
-  const fetchResult = spawnSync2("git", ["fetch", "origin", "dev"], {
+  const fetchResult = spawnSync3("git", ["fetch", "origin", "dev"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15754,7 +16768,7 @@ function syncLocalDevToOriginDev(repoRoot2) {
       offendingPaths: []
     };
   }
-  const resetResult = spawnSync2("git", ["reset", "--hard", "origin/dev"], {
+  const resetResult = spawnSync3("git", ["reset", "--hard", "origin/dev"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -15798,14 +16812,14 @@ function isArchitecturePlanningDiffPath(path9) {
   return path9.startsWith(".pourkit/architecture/") || path9 === ".pourkit/CONTEXT.md" || path9.startsWith(".pourkit/docs/");
 }
 async function ensurePlanningBranchPublished(repoRoot2, branchName, changedFiles) {
-  const remoteResult = spawnSync2("git", ["remote", "get-url", "origin"], {
+  const remoteResult = spawnSync3("git", ["remote", "get-url", "origin"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
   if (remoteResult.status !== 0) {
     return;
   }
-  const worktreePath = mkdtempSync(join20(tmpdir(), "pourkit-planning-"));
+  const worktreePath = mkdtempSync(join21(tmpdir(), "pourkit-planning-"));
   try {
     runGitOrThrow(repoRoot2, ["fetch", "origin", "dev"], "fetch origin/dev");
     runGitOrThrow(
@@ -15819,8 +16833,8 @@ async function ensurePlanningBranchPublished(repoRoot2, branchName, changedFiles
       "create planning branch"
     );
     for (const changedFile of changedFiles) {
-      const sourcePath = join20(repoRoot2, changedFile);
-      const targetPath = join20(worktreePath, changedFile);
+      const sourcePath = join21(repoRoot2, changedFile);
+      const targetPath = join21(worktreePath, changedFile);
       mkdirSync11(dirname5(targetPath), { recursive: true });
       cpSync(sourcePath, targetPath, { recursive: true });
     }
@@ -15835,13 +16849,13 @@ async function ensurePlanningBranchPublished(repoRoot2, branchName, changedFiles
       "commit planning diff"
     );
   } finally {
-    spawnSync2("git", ["worktree", "remove", "--force", worktreePath], {
+    spawnSync3("git", ["worktree", "remove", "--force", worktreePath], {
       cwd: repoRoot2,
       encoding: "utf8"
     });
     rmSync3(worktreePath, { recursive: true, force: true });
   }
-  const pushResult = spawnSync2(
+  const pushResult = spawnSync3(
     "git",
     ["push", "--force", "origin", `${branchName}:refs/heads/${branchName}`],
     {
@@ -15977,7 +16991,7 @@ function validateStartPrepareReceipt(prdRef, record, options = {}) {
 function validateStartArtifactExistenceOnOriginDev(repoRoot2, manifest) {
   for (const artifactPath of listManifestArtifactPaths(repoRoot2, manifest)) {
     const repoRelativePath = toRepoRelativePath2(repoRoot2, artifactPath);
-    const result = spawnSync2(
+    const result = spawnSync3(
       "git",
       ["show", `origin/dev:${repoRelativePath}`],
       {
@@ -16003,7 +17017,7 @@ function validateStartArtifactExistenceOnOriginDev(repoRoot2, manifest) {
   return { ok: true };
 }
 function collectGitChangedFiles(repoRoot2, ignoredPrdRunRecordRef) {
-  const result = spawnSync2("git", ["status", "--porcelain=v1", "-uall"], {
+  const result = spawnSync3("git", ["status", "--porcelain=v1", "-uall"], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -16058,11 +17072,11 @@ function collectGitChangedFiles(repoRoot2, ignoredPrdRunRecordRef) {
   };
 }
 function collectObservedReconciliationDirtyPaths(options) {
-  const statusResult = spawnSync2("git", ["status", "--porcelain=v1", "-uall"], {
+  const statusResult = spawnSync3("git", ["status", "--porcelain=v1", "-uall"], {
     cwd: options.worktreeCwd,
     encoding: "utf8"
   });
-  const diffResult = spawnSync2("git", ["diff", "--name-status"], {
+  const diffResult = spawnSync3("git", ["diff", "--name-status"], {
     cwd: options.worktreeCwd,
     encoding: "utf8"
   });
@@ -16096,13 +17110,13 @@ function collectObservedReconciliationDirtyPaths(options) {
   };
 }
 function gitRefExists(repoRoot2, ref) {
-  return spawnSync2("git", ["rev-parse", "--verify", "--quiet", ref], {
+  return spawnSync3("git", ["rev-parse", "--verify", "--quiet", ref], {
     cwd: repoRoot2,
     encoding: "utf8"
   }).status === 0;
 }
 function collectGitDiffNames(repoRoot2, baseRef, headRef) {
-  const result = spawnSync2("git", ["diff", "--name-only", baseRef, headRef], {
+  const result = spawnSync3("git", ["diff", "--name-only", baseRef, headRef], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -19163,8 +20177,8 @@ function formatChecks2(checks) {
 init_common();
 
 // execution/sandcastle-execution.ts
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync8 } from "fs";
-import { join as join22 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync9 } from "fs";
+import { join as join23 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
@@ -19173,10 +20187,10 @@ init_common();
 import { mkdtempSync as mkdtempSync2 } from "fs";
 import { writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname6, join as join21 } from "path";
+import { dirname as dirname6, join as join22 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join21(worktreePath, artifact.path);
+    const filePath = join22(worktreePath, artifact.path);
     await ensureDir(dirname6(filePath));
     await writeFile3(filePath, artifact.content, "utf-8");
   }
@@ -19188,7 +20202,7 @@ import path7 from "path";
 
 // execution/sandbox-image.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "fs";
 import path6 from "path";
 function sandboxImageName(repoRoot2) {
   const dirName = path6.basename(repoRoot2.replace(/[\\/]+$/, "")) || "local";
@@ -19198,7 +20212,7 @@ function sandboxImageName(repoRoot2) {
   if (!existsSync19(dockerfilePath)) {
     return `sandcastle:${baseName}`;
   }
-  const fingerprint = createHash4("sha256").update(readFileSync17(dockerfilePath)).digest("hex").slice(0, 8);
+  const fingerprint = createHash4("sha256").update(readFileSync18(dockerfilePath)).digest("hex").slice(0, 8);
   return `sandcastle:${baseName}-${fingerprint}`;
 }
 
@@ -19458,17 +20472,32 @@ function parseToolCallArgs(formattedArgs) {
     return { ok: false };
   }
 }
+var SUMMARIZED_TOOL_FIELDS = {
+  write: { content: "contentCount" },
+  edit: { oldString: "oldCount", newString: "newCount" }
+};
+var SUMMARIZED_TOOL_ARRAY_FIELDS = {
+  todowrite: { todos: "todoCount" }
+};
 function summarizeToolCallArgs(name, args) {
   if (!isPlainObject(args)) {
     return args;
   }
-  if (name.toLowerCase() !== "write") {
+  const fields = SUMMARIZED_TOOL_FIELDS[name.toLowerCase()];
+  const arrayFields = SUMMARIZED_TOOL_ARRAY_FIELDS[name.toLowerCase()];
+  if (!fields && !arrayFields) {
     return args;
   }
   const summarizedArgs = {};
   for (const [key, value] of Object.entries(args)) {
-    if (key === "content" && typeof value === "string") {
-      summarizedArgs.contentCount = value.length;
+    const mappedKey = fields?.[key];
+    if (mappedKey && typeof value === "string") {
+      summarizedArgs[mappedKey] = value.length;
+      continue;
+    }
+    const mappedArrayKey = arrayFields?.[key];
+    if (mappedArrayKey && Array.isArray(value)) {
+      summarizedArgs[mappedArrayKey] = value.length;
       continue;
     }
     summarizedArgs[key] = value;
@@ -19479,13 +20508,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");
+  const promptsDir = join23(repoRoot2, ".pourkit", ".tmp", "prompts");
   mkdirSync12(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 = join23(promptsDir, filename);
+  writeFileSync9(filePath, prompt, "utf-8");
 }
 
 // cli.ts
@@ -20358,11 +21387,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260608072322")) {
-    return "0.0.0-next-20260608072322";
+  if (isPackageVersion("0.0.0-next-20260609130908")) {
+    return "0.0.0-next-20260609130908";
   }
-  if (isReleaseVersion("0.0.0-next-20260608072322")) {
-    return "0.0.0-next-20260608072322";
+  if (isReleaseVersion("0.0.0-next-20260609130908")) {
+    return "0.0.0-next-20260609130908";
   }
   try {
     const root = repoRoot();