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

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");
@@ -6158,10 +6162,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 +8358,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 +8394,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",
@@ -9152,6 +9205,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 +9239,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 {
@@ -9184,7 +9287,7 @@ async function runLocalFinalReview(prdId, options) {
       });
       verdict = "pass_with_retouch";
     } catch {
-      verdict = "pass";
+      verdict = "pass_no_changes";
     }
   } else if (failures.length === commands.length) {
     verdict = "blocked";
@@ -9202,9 +9305,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 });
@@ -9276,6 +9380,26 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
         stdio: "pipe"
       }
     );
+    const mergeCommit = execFileSync3("git", ["rev-parse", "HEAD"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+    const changedPathsResult = execFileSync3(
+      "git",
+      ["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"],
+      {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      }
+    );
+    const changedPaths = changedPathsResult.split(/\r?\n/).filter(Boolean);
+    return {
+      mergeCommit,
+      changedPaths,
+      reviewedTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.toLowerCase().includes("conflict")) {
@@ -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,78 +9734,369 @@ 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)
     };
   }
-  valid2.sort((a, b) => {
-    if (a.priority !== b.priority) return a.priority - b.priority;
-    const ageCmp = a.issue.createdAt.localeCompare(b.issue.createdAt);
-    if (ageCmp !== 0) return ageCmp;
-    return a.issue.number - b.issue.number;
-  });
-  return { ok: true, issue: valid2[0].issue };
 }
 
-// issues/blocked-issue.ts
-function parseBlockedBy(body) {
-  if (!body) return [];
-  const bm = body.match(/## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i);
-  if (!bm) return [];
-  const refs = [];
-  const re = /#(\d+)/g;
-  let m;
-  while ((m = re.exec(bm[1])) !== null) {
-    refs.push(Number(m[1]));
-  }
-  return refs;
+// 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) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    const ageCmp = a.issue.createdAt.localeCompare(b.issue.createdAt);
+    if (ageCmp !== 0) return ageCmp;
+    return a.issue.number - b.issue.number;
+  });
+  return { ok: true, issue: valid2[0].issue };
+}
+
+// issues/blocked-issue.ts
+function parseBlockedBy(body) {
+  if (!body) return [];
+  const bm = body.match(/## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i);
+  if (!bm) return [];
+  const refs = [];
+  const re = /#(\d+)/g;
+  let m;
+  while ((m = re.exec(bm[1])) !== null) {
+    refs.push(Number(m[1]));
+  }
+  return refs;
 }
 async function reconcileBlockedIssue(issue, deps) {
   const blockers = parseBlockedBy(issue.body);
@@ -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,7 +10720,7 @@ function canRetryFinalReviewBlock(record) {
 }
 function loadFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  return existsSync17(promptPath) ? readFileSync16(promptPath, "utf-8") : promptTemplate;
+  return existsSync17(promptPath) ? readFileSync17(promptPath, "utf-8") : promptTemplate;
 }
 function formatVerificationCommands(commands) {
   if (commands.length === 0) return "No verification commands configured.";
@@ -10385,7 +10774,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 +10786,7 @@ function buildFinalReviewBranchName(prdRef) {
   return `pourkit/${normalizePrdRunRef2(prdRef).toLowerCase()}-final-review`;
 }
 function finalReviewWorktreePath(repoRoot2, branchName) {
-  return join20(
+  return join21(
     repoRoot2,
     ".sandcastle",
     "worktrees",
@@ -10420,7 +10809,7 @@ function listFinalReviewChangedPaths(worktreePath, mergeBase) {
     }
     paths.add(path9);
   };
-  const diffResult = spawnSync2(
+  const diffResult = spawnSync3(
     "git",
     ["diff", "--name-only", mergeBase, "--", "."],
     {
@@ -10431,7 +10820,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 +10841,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",
     "",
@@ -10486,7 +10875,7 @@ function buildFinalReviewFinalizerPrompt(options) {
 }
 async function runFinalReviewPrFinalizer(options) {
   const finalizer = options.target.strategy.finalize.prDescriptionAgent;
-  const artifactPathInWorktree = join20(
+  const artifactPathInWorktree = join21(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -10532,7 +10921,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,7 +10957,7 @@ function ensureFinalReviewWorktree(options) {
     };
   }
   mkdirSync11(dirname5(worktreePath), { recursive: true });
-  const branchResult = spawnSync2(
+  const branchResult = spawnSync3(
     "git",
     ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
     { cwd: options.repoRoot, encoding: "utf8" }
@@ -10580,7 +10969,7 @@ function ensureFinalReviewWorktree(options) {
       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 +11011,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 +11029,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 +11045,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}`],
     {
@@ -11072,7 +11461,7 @@ async function runPrdRunFinalReviewCommand(options) {
     };
   }
   const resolvedWorktreePath = executionResult.worktreePath;
-  const artifactPath = join20(
+  const artifactPath = join21(
     resolvedWorktreePath,
     ".pourkit/final-review-artifact.json"
   );
@@ -11656,7 +12045,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 +12059,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 +12211,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 +12269,7 @@ async function runReconcilePreflightAndSetup(options) {
         branchAction: "blocked"
       };
     }
-    const resetResult = spawnSync2(
+    const resetResult = spawnSync3(
       "git",
       ["reset", "--hard", `origin/${prdBranch}`],
       { cwd: worktreeCwd, encoding: "utf8" }
@@ -11923,7 +12312,7 @@ async function runReconcilePreflightAndSetup(options) {
       );
       return { ok: false, diagnostics, branchAction: "blocked" };
     }
-    const adoptionCheck = spawnSync2(
+    const adoptionCheck = spawnSync3(
       "git",
       [
         "merge-base",
@@ -11971,7 +12360,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 +12375,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 +12429,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 +12437,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 +12454,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 +12478,7 @@ function commitAndPushReconciliationChanges(options) {
       };
     }
   }
-  const pushResult = spawnSync2(
+  const pushResult = spawnSync3(
     "git",
     [
       "push",
@@ -12183,7 +12572,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 +12874,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 +12975,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 +13082,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 +13839,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 +13859,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}`],
     {
@@ -13613,17 +14002,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 +14021,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 +14035,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 +14133,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 +14155,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 +14169,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,17 +14328,59 @@ 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");
-    const localStorePath = join20(
+    const localStorePath2 = join21(
       options.repoRoot,
       ".pourkit",
       "local-prd-runs",
       prdRef
     );
-    if (existsSync17(localStorePath)) {
+    if (existsSync17(localStorePath2)) {
+      const prdRecord = readPrdRun(options.repoRoot, prdRef);
+      if (prdRecord.record && prdRecord.record.status !== "drained" && !canRetryFinalReviewBlock(prdRecord.record)) {
+        const reason = `Final Review blocked: Queue drain not completed. Status is "${prdRecord.record.status}". Finish all child Issues before Final Review.`;
+        writePrdRunRecord(options.repoRoot, {
+          prdRef,
+          status: "blocked",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          blockedGate: "final-review",
+          blockedReason: reason,
+          diagnostics: [
+            `Current status: ${prdRecord.record.status}. Queue drain receipt is missing. Run child Issues through queue-run before Final Review.`
+          ],
+          targetName: options.targetName,
+          offendingPaths: []
+        });
+        return {
+          prdRef,
+          status: "blocked",
+          attempted,
+          skipped: [
+            ...skipped.includes("prepare") ? ["prepare"] : [],
+            ...skipped.includes("start") ? ["queue"] : [],
+            "reconcile"
+          ],
+          resumed,
+          diagnostics: [
+            `Current status: ${prdRecord.record.status}. Queue drain receipt is missing. Run child Issues through queue-run before Final Review.`
+          ],
+          blockedGate: "final-review",
+          blockedReason: reason,
+          offendingPaths: [],
+          prepare: prepareResult,
+          start: startResult
+        };
+      }
       const targetConfig = options.config?.targets?.find(
         (t) => t.name === options.targetName
       );
@@ -13948,9 +14419,48 @@ async function runPrdRunLaunchCommand(options) {
           start: startResult
         };
       }
+      if (localResult.verdict === "blocked" || localResult.verdict === "needs_human_review") {
+        const reason = localResult.message ?? `Local Final Review verdict: ${localResult.verdict}`;
+        writePrdRunRecord(options.repoRoot, {
+          prdRef,
+          status: "blocked",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          blockedGate: "final-review",
+          blockedReason: reason,
+          diagnostics: [reason],
+          targetName: options.targetName,
+          offendingPaths: []
+        });
+        return {
+          prdRef,
+          status: "blocked",
+          attempted,
+          skipped: [
+            ...skipped.includes("prepare") ? ["prepare"] : [],
+            ...skipped.includes("start") ? ["queue"] : [],
+            "reconcile"
+          ],
+          resumed,
+          diagnostics: [reason],
+          blockedGate: "final-review",
+          blockedReason: reason,
+          offendingPaths: [],
+          prepare: prepareResult,
+          start: startResult
+        };
+      }
+      let retouchMergeCommit;
+      let changedPaths;
       if (localResult.verdict === "pass_with_retouch") {
         try {
-          await squashFinalReviewRetouch(prdRef, options.repoRoot);
+          const evidence = await squashFinalReviewRetouch(
+            prdRef,
+            options.repoRoot
+          );
+          if (evidence) {
+            retouchMergeCommit = evidence.mergeCommit;
+            changedPaths = evidence.changedPaths;
+          }
         } catch (error) {
           const reason = error instanceof Error ? error.message : String(error);
           writePrdRunRecord(options.repoRoot, {
@@ -13982,14 +14492,16 @@ async function runPrdRunLaunchCommand(options) {
           };
         }
       }
-      const mappedVerdict = localResult.verdict === "pass" ? "pass_no_changes" : localResult.verdict;
       const receipt = {
         status: "final_reviewed",
         targetName: options.targetName,
         prdBranch: `local/${prdRef}`,
+        mergeBase: localResult.receipt?.mergeBase,
         diagnostics: [],
         reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        verdict: mappedVerdict
+        verdict: localResult.verdict ?? "pass_no_changes",
+        retouchMergeCommit,
+        changedPaths
       };
       const existingRecord2 = readPrdRun(options.repoRoot, prdRef);
       writePrdRunRecord(options.repoRoot, {
@@ -14064,17 +14576,100 @@ async function runPrdRunLaunchCommand(options) {
   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") {
+    const localStorePath2 = join21(
+      options.repoRoot,
+      ".pourkit",
+      "local-prd-runs",
+      prdRef
+    );
+    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],
+          resumed,
+          diagnostics: [reason],
+          blockedGate: "reconciliation",
+          blockedReason: reason,
+          offendingPaths: [],
+          prepare: prepareResult,
+          start: startResult,
+          finalReview: finalReviewResult
+        };
+      }
+      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: "succeeded",
+        result: localResult.receipt?.result,
+        changedPlanningPaths: localResult.receipt?.changedPlanningPaths,
+        targetName: options.targetName,
+        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: "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: existingRecord2.record?.finalReview,
+        reconciliation: receipt,
+        scopeChanges: existingRecord2.record?.scopeChanges
+      });
+      reconcileResult = {
+        prdRef,
+        status: "succeeded",
+        reconciliation: receipt,
+        diagnostics: []
+      };
+      diagnostics.push("Local reconciliation completed.");
+    } else {
+      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 && reconcileResult.status === "blocked") {
       return {
         prdRef,
         status: "blocked",
@@ -14091,7 +14686,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 +14771,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 +15123,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 +15143,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 +15158,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 +15280,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 +15410,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 +15471,8 @@ async function runPrdRunStartCommand(options) {
             ...reusedStart
           },
           {
-            targetName
+            targetName,
+            mode: resolvedMode
           }
         );
         return await processStartResult(
@@ -14917,6 +15575,7 @@ async function runPrdRunStartCommand(options) {
         },
         {
           targetName,
+          mode: resolvedMode,
           manifestPath: existingRecord.record?.manifestPath,
           planning: existingRecord.record?.planning
         }
@@ -15076,6 +15735,7 @@ async function runPrdRunStartCommand(options) {
       },
       {
         targetName,
+        mode: resolvedMode,
         manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath,
         planning: existingRecord.record?.planning
       }
@@ -15158,6 +15818,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 +15907,7 @@ async function runPrdRunStartCommand(options) {
     updatedAt,
     targetName,
     start,
+    mode: resolvedMode,
     manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath ?? void 0,
     planning: existingRecord.record?.planning
   });
@@ -15215,26 +15938,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 +16067,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 +16089,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 +16111,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 +16136,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 +16161,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 +16193,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 +16224,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 +16354,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 +16371,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 +16391,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 +16411,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 +16438,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 +16491,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 +16503,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 +16534,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 +16550,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 +16594,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 +16615,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 +16631,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 +16773,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 +16799,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 +16854,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 +16892,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 +19959,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 +19969,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 +19984,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 +19994,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 +20254,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 +20290,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 +21169,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-20260608221925")) {
+    return "0.0.0-next-20260608221925";
   }
-  if (isReleaseVersion("0.0.0-next-20260608072322")) {
-    return "0.0.0-next-20260608072322";
+  if (isReleaseVersion("0.0.0-next-20260608221925")) {
+    return "0.0.0-next-20260608221925";
   }
   try {
     const root = repoRoot();