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

package/dist/cli.js

@@ -376,6 +376,7 @@ var VerificationCommandSchema = z.object({
   command: d.command,
   label: d.label && d.label.trim() !== "" ? d.label : void 0
 }));
+var PrdRunModeSchema = z.enum(["github", "local"]);
 var QueueConfigSchema = z.object({
   loop: z.boolean().optional()
 }).strict();
@@ -422,6 +423,7 @@ var ReviewRefactorLoopStrategySchema = z.object({
     maxAttempts: z.number().int().positive()
   }).strict(),
   prdRun: z.object({
+    mode: PrdRunModeSchema.optional(),
     // Uses promptTemplate (canonical StageAgentConfig field), not prompt as Issue contract may suggest
     finalReview: StageAgentConfigSchema,
     reconciliation: StageAgentConfigSchema.optional()
@@ -715,6 +717,7 @@ function parseConfig(raw) {
         },
         ...t.strategy.prdRun ? {
           prdRun: {
+            ...t.strategy.prdRun.mode ? { mode: t.strategy.prdRun.mode } : {},
             finalReview: t.strategy.prdRun.finalReview,
             ...t.strategy.prdRun.reconciliation ? { reconciliation: t.strategy.prdRun.reconciliation } : {}
           }
@@ -771,14 +774,28 @@ function assertKnownKeys(value, path9, knownKeys) {
 function getVerificationCommands(target) {
   return target.strategy.verify?.commands ?? [];
 }
+function resolvePrdRunMode(target, opts) {
+  if (opts?.localOverride === true) {
+    return { mode: "local", source: "cli-override", targetName: target.name };
+  }
+  const configMode = target.strategy.prdRun?.mode;
+  if (configMode) {
+    return {
+      mode: configMode,
+      source: "target-config",
+      targetName: target.name
+    };
+  }
+  return { mode: "github", source: "default", targetName: target.name };
+}
 async function loadRepoConfig(repoRoot2, configFileName = "pourkit.config.ts") {
-  const { existsSync: existsSync19 } = await import("fs");
+  const { existsSync: existsSync20 } = await import("fs");
   const { mkdir: mkdir6, writeFile: writeFile4, rm } = await import("fs/promises");
   const { join: pjoin, basename } = await import("path");
   const { pathToFileURL: pathToFileURL2 } = await import("url");
   const { build } = await import("esbuild");
   const configPath = pjoin(repoRoot2, configFileName);
-  if (!existsSync19(configPath)) {
+  if (!existsSync20(configPath)) {
     throw new Error(
       `No config file found at ${configPath}. Create a ${configFileName} that exports a default PourkitConfig.`
     );
@@ -1142,6 +1159,77 @@ function prepareArtifactPath(artifactPath) {
   rmSync(artifactPath, { recursive: true, force: true });
 }
 
+// commands/run-verification.ts
+init_common();
+function buildRunVerificationCommand(target) {
+  return `pourkit run-verification --target ${target.name}`;
+}
+async function runVerificationCommand(command, cwd, logger) {
+  try {
+    const result = await execCapture("bash", ["-lc", command.command], {
+      cwd,
+      logger,
+      label: command.label
+    });
+    return {
+      label: command.label,
+      command: command.command,
+      ok: true,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    return {
+      label: command.label,
+      command: command.command,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function runVerificationCommands(options) {
+  const commands = getVerificationCommands(options.target);
+  const diagnostics = [];
+  if (commands.length === 0) {
+    diagnostics.push(
+      `No verification commands configured for target "${options.target.name}".`
+    );
+    return {
+      ok: true,
+      target: options.target.name,
+      commands: [],
+      diagnostics
+    };
+  }
+  const results = [];
+  for (const command of commands) {
+    const result = await runVerificationCommand(
+      command,
+      options.cwd,
+      options.logger
+    );
+    results.push(result);
+    if (!result.ok) {
+      diagnostics.push(`Verification failed for "${command.label}".`);
+      return {
+        ok: false,
+        target: options.target.name,
+        commands: results,
+        diagnostics
+      };
+    }
+  }
+  diagnostics.push(
+    `Verification passed for target "${options.target.name}".`
+  );
+  return {
+    ok: true,
+    target: options.target.name,
+    commands: results,
+    diagnostics
+  };
+}
+
 // shared/run-context.ts
 var RUN_CONTEXT_PATH_IN_WORKTREE = ".pourkit/.tmp/run-context.md";
 var ALL_RUN_CONTEXT_SECTIONS = [
@@ -1268,6 +1356,7 @@ function buildRunContextMarkdown(options) {
   if (sections.includes("verification-commands")) {
     parts.push(
       ...renderCommandList(
+        target,
         getVerificationCommands(target),
         "Verification Commands"
       )
@@ -1289,13 +1378,26 @@ function buildRunContextMarkdown(options) {
   }
   return parts.join("\n");
 }
-function renderCommandList(commands, heading) {
+function renderCommandList(target, commands, heading) {
   if (commands.length === 0) {
-    return [`## ${heading}`, "", "(none)", ""];
+    return [
+      `## ${heading}`,
+      "",
+      `Run this command from the repository root: \`${buildRunVerificationCommand(target)}\``,
+      "",
+      "Underlying project commands:",
+      "",
+      "(none configured)",
+      ""
+    ];
   }
   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}\``),
@@ -2079,7 +2181,7 @@ ${criteriaBlock}
 
 Write your review to: ${artifactPathInWorktree}
 
-Before handoff, run: npm run pourkit:validate-reviewer -- ${artifactPathInWorktree} --iteration ${iteration}${priorRefactorArtifacts ? " --prior-refactor-artifacts" : ""}
+Before handoff, run: pourkit validate-artifact reviewer ${artifactPathInWorktree} --iteration ${iteration}${priorRefactorArtifacts ? " --prior-refactor-artifacts" : ""}
 
 Do not provide a separate chat response. The runner only reads the file above.
 
@@ -2615,7 +2717,7 @@ ${latestReview.trimEnd()}
 
 Write your refactor artifact to: ${artifactPathInWorktree}
 
-Before handoff, run: npm run pourkit:validate-refactor -- ${artifactPathInWorktree} --iteration ${iteration}${findingArgs}
+Before handoff, run: pourkit validate-artifact refactor ${artifactPathInWorktree} --iteration ${iteration}${findingArgs}
 
 When you are done, finish with <promise>COMPLETE</promise>.`);
   });
@@ -4879,8 +4981,8 @@ function validateLocalTriage(prdPath, issuePaths) {
 }
 
 // commands/issue-run.ts
-import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { join as join14 } from "path";
 
 // pr/templates.ts
 init_common();
@@ -5581,7 +5683,7 @@ async function runFailureResolutionAgent(options) {
     "",
     "Allowed decisions: " + packet.allowedDecisions.join(", "),
     "",
-    `Before handoff, run: npm run pourkit:validate-failure-resolution -- ${artifactPath} ${packet.allowedDecisions.map((decision) => `--allowed-decision ${decision}`).join(" ")}`
+    `Before handoff, run: pourkit validate-artifact failure-resolution ${artifactPath} ${packet.allowedDecisions.map((decision) => `--allowed-decision ${decision}`).join(" ")}`
   ].join("\n");
   const retryResult = await executeWithMissingOrEmptyArtifactRetry({
     executionProvider,
@@ -5853,7 +5955,7 @@ Rules:
 
 Write your finalizer output to: ${artifactPathInWorktree}
 
-Before handoff, run: npm run pourkit:validate-finalizer -- ${artifactPathInWorktree}`;
+Before handoff, run: pourkit validate-artifact finalizer ${artifactPathInWorktree}`;
 }
 
 // commands/pr-description-agent.ts
@@ -6054,110 +6156,444 @@ function persistGeneratedArtifactEffect(worktreePath, output, fs) {
   });
 }
 
-// pr/pr-body.ts
-import { readFile as readFile2 } from "fs/promises";
-var DEFAULT_MANUAL_PR_BODY = `## Summary
-
-- Summarize why this branch exists.
-
-## Changes
+// prd-run/local-merge-coordinator.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
+import { join as join13 } from "path";
 
-- Summarize the final net change in this branch.`;
-async function buildPrBody(input) {
-  const { defaultBody, options } = input;
-  let bodyText = await resolveBodyText(defaultBody, options);
-  bodyText = appendClosingRef(bodyText, options.issue);
-  return bodyText;
+// prd-run/local-branches.ts
+import { execFileSync, spawnSync as spawnSync2 } from "child_process";
+function getLocalPrdBranchName(prdId) {
+  return `local/${prdId}`;
 }
-function ensureClosingRefs(body, issue) {
-  const stripped = stripClosingRefs(body || "");
-  if (issue === void 0) {
-    return stripped;
+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
+    };
   }
-  if (!stripped) {
-    return `Closes #${issue}`;
+  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 `${stripped}
-
-Closes #${issue}`;
-}
-function stripClosingRefs(body) {
-  const linePattern = /^[ \t]*[-*+]\s+(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#\d+\s*$/gim;
-  let result = body.replace(linePattern, "");
-  const inlinePattern = /(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#\d+/gi;
-  result = result.replace(inlinePattern, "").trimEnd();
-  return result;
+  return { ok: true, created: true };
 }
-async function resolveBodyText(defaultBody, options) {
-  if (options.body && options.bodyFile) {
-    throw new Error("--body and --body-file cannot be used together");
+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) {
+  if (!name || name.length === 0) {
+    return {
+      ok: false,
+      failureCode: "invalid_format",
+      message: "Branch name is empty."
+    };
   }
-  if (options.body !== void 0) {
-    return options.body;
+  if (isProtectedBranch(name)) {
+    return {
+      ok: false,
+      failureCode: "protected_branch",
+      message: `Branch "${name}" is protected.`
+    };
   }
-  if (options.bodyFile !== void 0) {
-    return await readFile2(options.bodyFile, "utf-8");
+  if (!LOCAL_BRANCH_PATTERN.test(name)) {
+    return {
+      ok: false,
+      failureCode: "invalid_format",
+      message: `Branch "${name}" does not match the local branch pattern.`
+    };
   }
-  return defaultBody;
+  return { ok: true };
 }
-function appendClosingRef(body, issue) {
-  if (issue === void 0) {
-    return body;
+function isProtectedBranch(name) {
+  return PROTECTED_BRANCHES.has(name);
+}
+function hasRemoteBackedCollision(localName, repoRoot2) {
+  const match = localName.match(/^local\/(PRD-\d{4})/);
+  if (!match) {
+    return Promise.resolve({
+      ok: false,
+      failureCode: "invalid_format",
+      message: `Cannot extract PRD ref from "${localName}".`
+    });
   }
-  const existingRefs = extractClosingRefs(body);
-  if (existingRefs.has(issue)) {
-    return body;
+  const prdRef = match[1];
+  try {
+    execFileSync(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${prdRef}`],
+      {
+        cwd: repoRoot2 ?? process.cwd(),
+        encoding: "utf8",
+        stdio: "pipe"
+      }
+    );
+    return Promise.resolve({
+      ok: false,
+      failureCode: "remote_backed_collision",
+      message: `Branch "${prdRef}" exists locally.`
+    });
+  } catch {
   }
-  return `${body}
+  try {
+    execFileSync(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${prdRef}`],
+      {
+        cwd: repoRoot2 ?? process.cwd(),
+        encoding: "utf8",
+        stdio: "pipe"
+      }
+    );
+    return Promise.resolve({
+      ok: false,
+      failureCode: "remote_backed_collision",
+      message: `Remote branch "origin/${prdRef}" exists.`
+    });
+  } catch {
+  }
+  return Promise.resolve({ ok: true });
+}
 
-Closes #${issue}`;
+// prd-run/local-merge-coordinator.ts
+function getLocalStorePath(repoRoot2, prdId) {
+  return join13(repoRoot2, ".pourkit", "local-prd-runs", prdId);
 }
-function extractClosingRefs(body) {
-  const refs = /* @__PURE__ */ new Set();
-  const pattern = /(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#(\d+)/gi;
-  let match;
-  while ((match = pattern.exec(body)) !== null) {
-    refs.add(parseInt(match[1], 10));
+function getMergeReceiptPath(repoRoot2, prdId, issueId) {
+  return join13(
+    getLocalStorePath(repoRoot2, prdId),
+    "merge-receipts",
+    `${issueId}.json`
+  );
+}
+function getIssueArtifactPath(repoRoot2, prdId, issueId) {
+  return join13(getLocalStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
+}
+function readIssueBranchName(repoRoot2, prdId, issueId) {
+  const issuePath = getIssueArtifactPath(repoRoot2, prdId, issueId);
+  if (!existsSync9(issuePath)) return null;
+  try {
+    const content = readFileSync11(issuePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return typeof parsed.branchName === "string" && parsed.branchName ? parsed.branchName : null;
+  } catch {
+    return null;
   }
-  return refs;
 }
-
-// issues/target-green.ts
-init_common();
-var RED_CHECK_CONCLUSIONS = /* @__PURE__ */ new Set([
-  "FAILURE",
-  "CANCELLED",
-  "TIMED_OUT",
-  "STARTUP_FAILURE",
-  "ACTION_REQUIRED",
-  "STALE"
-]);
-async function waitForBranchChecks(prProvider, logger, options) {
-  const checksFoundTimeoutMs = options.checksFoundTimeoutMs ?? 60 * 1e3;
-  const checksCompletionTimeoutMs = options.checksCompletionTimeoutMs ?? 5 * 60 * 1e3;
-  const pollIntervalMs = options.pollIntervalMs ?? 15 * 1e3;
-  const stableHeadMs = options.stableHeadMs ?? pollIntervalMs;
-  let lastHeadSha = "";
-  let headStableSince = 0;
-  let checksFoundDeadline = 0;
-  let checksCompletionDeadline = 0;
-  let checksDiscovered = false;
-  logger.step("wait", `waiting for ${options.branchName} to be green`);
-  while (true) {
-    const observedAt = Date.now();
-    const status = await prProvider.getBranchStatus(options.branchName);
-    if (status.headSha !== lastHeadSha) {
-      logger.step(
-        "info",
-        `branch head changed to ${status.headSha.substring(0, 7)}`
-      );
-      lastHeadSha = status.headSha;
-      headStableSince = observedAt;
-      if (checksFoundDeadline === 0) {
-        checksFoundDeadline = observedAt + checksFoundTimeoutMs;
-      }
-      checksCompletionDeadline = 0;
-      checksDiscovered = false;
+async function hasLocalIssueMergeReceipt(prdId, issueId, repoRoot2) {
+  const root = repoRoot2 ?? process.cwd();
+  const receiptPath = getMergeReceiptPath(root, prdId, issueId);
+  if (!existsSync9(receiptPath)) return null;
+  try {
+    const content = readFileSync11(receiptPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.prdId === "string" && typeof parsed.issueId === "string" && typeof parsed.stage === "string" && typeof parsed.sourceBranch === "string" && typeof parsed.localPrdBranch === "string" && typeof parsed.mergeCommit === "string" && typeof parsed.completedAt === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function squashMergeLocalIssue(prdId, issueId, input, repoRoot2) {
+  const root = repoRoot2 ?? process.cwd();
+  const receiptPath = getMergeReceiptPath(root, prdId, issueId);
+  if (existsSync9(receiptPath)) {
+    try {
+      const existing = JSON.parse(
+        readFileSync11(receiptPath, "utf-8")
+      );
+      if (existing.prdId === prdId && existing.issueId === issueId && existing.mergeCommit) {
+        return {
+          ok: false,
+          failureCode: "already_merged",
+          repairGuidance: `Issue ${issueId} was already merged into ${existing.localPrdBranch}. Merge commit: ${existing.mergeCommit}`
+        };
+      }
+      return {
+        ok: false,
+        failureCode: "invalid_receipt",
+        repairGuidance: `Merge receipt for ${issueId} belongs to different prd/issue. Remove it manually: ${receiptPath}`
+      };
+    } catch {
+      return {
+        ok: false,
+        failureCode: "invalid_receipt",
+        repairGuidance: `Merge receipt for ${issueId} is corrupted. Remove it manually: ${receiptPath}`
+      };
+    }
+  }
+  const sourceBranch = input?.sourceBranch ?? readIssueBranchName(root, prdId, issueId);
+  if (!sourceBranch) {
+    return {
+      ok: false,
+      failureCode: "not_found",
+      repairGuidance: `No source branch found for issue ${issueId} under PRD ${prdId}. Ensure the issue artifact exists with a valid branchName field.`
+    };
+  }
+  try {
+    execFileSync2(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${sourceBranch}`],
+      { cwd: root, encoding: "utf8", stdio: "pipe" }
+    );
+  } catch {
+    return {
+      ok: false,
+      failureCode: "not_found",
+      repairGuidance: `Source branch "${sourceBranch}" does not exist locally. Check that the branch was created and not deleted.`
+    };
+  }
+  const targetBranch = getLocalPrdBranchName(prdId);
+  try {
+    execFileSync2(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
+      { cwd: root, encoding: "utf8", stdio: "pipe" }
+    );
+  } catch {
+    return {
+      ok: false,
+      failureCode: "not_found",
+      repairGuidance: `Local PRD branch "${targetBranch}" does not exist. Run \`prd-run start\` first to create it.`
+    };
+  }
+  try {
+    execFileSync2("git", ["checkout", targetBranch], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    let preMergeHead;
+    try {
+      preMergeHead = execFileSync2("git", ["rev-parse", "HEAD"], {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "pipe"
+      }).trim();
+    } catch {
+      return {
+        ok: false,
+        failureCode: "merge_error",
+        repairGuidance: "Failed to read current HEAD before merge."
+      };
+    }
+    execFileSync2("git", ["merge", "--squash", sourceBranch], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    if (input) {
+      execFileSync2(
+        "git",
+        ["commit", "-m", input.finalizerTitle, "-m", input.finalizerBody],
+        { cwd: root, encoding: "utf8", stdio: "pipe" }
+      );
+    } else {
+      execFileSync2(
+        "git",
+        ["commit", "-m", `Squash merge ${sourceBranch} into ${targetBranch}`],
+        { cwd: root, encoding: "utf8", stdio: "pipe" }
+      );
+    }
+    const revParseResult = execFileSync2("git", ["rev-parse", "HEAD"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const mergeCommit = revParseResult.trim();
+    const receipt = {
+      prdId,
+      issueId,
+      stage: "child-issue",
+      sourceBranch,
+      localPrdBranch: targetBranch,
+      mergeCommit,
+      finalizerArtifactPath: input?.finalizerArtifactPath ?? "",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const receiptsDir = join13(
+        root,
+        ".pourkit",
+        "local-prd-runs",
+        prdId,
+        "merge-receipts"
+      );
+      mkdirSync7(receiptsDir, { recursive: true });
+      writeFileSync4(receiptPath, JSON.stringify(receipt, null, 2), "utf-8");
+    } catch {
+      try {
+        execFileSync2("git", ["reset", "--hard", preMergeHead], {
+          cwd: root,
+          encoding: "utf8",
+          stdio: "pipe"
+        });
+      } catch {
+      }
+      return {
+        ok: false,
+        failureCode: "receipt_error",
+        repairGuidance: "Failed to write merge receipt. Check disk space and permissions on .pourkit/local-prd-runs/. The merge commit has been rolled back."
+      };
+    }
+    return { ok: true, receipt };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.toLowerCase().includes("conflict")) {
+      return {
+        ok: false,
+        failureCode: "conflict",
+        repairGuidance: "Merge conflict during squash. Resolve conflicts in the working tree, then retry."
+      };
+    }
+    const stderr = error instanceof Error && "stderr" in error ? error.stderr : void 0;
+    return {
+      ok: false,
+      failureCode: "merge_error",
+      repairGuidance: stderr ? `Merge failed: ${stderr}` : `Merge failed: ${message}`
+    };
+  }
+}
+
+// pr/pr-body.ts
+import { readFile as readFile2 } from "fs/promises";
+var DEFAULT_MANUAL_PR_BODY = `## Summary
+
+- Summarize why this branch exists.
+
+## Changes
+
+- Summarize the final net change in this branch.`;
+async function buildPrBody(input) {
+  const { defaultBody, options } = input;
+  let bodyText = await resolveBodyText(defaultBody, options);
+  bodyText = appendClosingRef(bodyText, options.issue);
+  return bodyText;
+}
+function ensureClosingRefs(body, issue) {
+  const stripped = stripClosingRefs(body || "");
+  if (issue === void 0) {
+    return stripped;
+  }
+  if (!stripped) {
+    return `Closes #${issue}`;
+  }
+  return `${stripped}
+
+Closes #${issue}`;
+}
+function stripClosingRefs(body) {
+  const linePattern = /^[ \t]*[-*+]\s+(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#\d+\s*$/gim;
+  let result = body.replace(linePattern, "");
+  const inlinePattern = /(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#\d+/gi;
+  result = result.replace(inlinePattern, "").trimEnd();
+  return result;
+}
+async function resolveBodyText(defaultBody, options) {
+  if (options.body && options.bodyFile) {
+    throw new Error("--body and --body-file cannot be used together");
+  }
+  if (options.body !== void 0) {
+    return options.body;
+  }
+  if (options.bodyFile !== void 0) {
+    return await readFile2(options.bodyFile, "utf-8");
+  }
+  return defaultBody;
+}
+function appendClosingRef(body, issue) {
+  if (issue === void 0) {
+    return body;
+  }
+  const existingRefs = extractClosingRefs(body);
+  if (existingRefs.has(issue)) {
+    return body;
+  }
+  return `${body}
+
+Closes #${issue}`;
+}
+function extractClosingRefs(body) {
+  const refs = /* @__PURE__ */ new Set();
+  const pattern = /(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#(\d+)/gi;
+  let match;
+  while ((match = pattern.exec(body)) !== null) {
+    refs.add(parseInt(match[1], 10));
+  }
+  return refs;
+}
+
+// issues/target-green.ts
+init_common();
+var RED_CHECK_CONCLUSIONS = /* @__PURE__ */ new Set([
+  "FAILURE",
+  "CANCELLED",
+  "TIMED_OUT",
+  "STARTUP_FAILURE",
+  "ACTION_REQUIRED",
+  "STALE"
+]);
+async function waitForBranchChecks(prProvider, logger, options) {
+  const checksFoundTimeoutMs = options.checksFoundTimeoutMs ?? 60 * 1e3;
+  const checksCompletionTimeoutMs = options.checksCompletionTimeoutMs ?? 5 * 60 * 1e3;
+  const pollIntervalMs = options.pollIntervalMs ?? 15 * 1e3;
+  const stableHeadMs = options.stableHeadMs ?? pollIntervalMs;
+  let lastHeadSha = "";
+  let headStableSince = 0;
+  let checksFoundDeadline = 0;
+  let checksCompletionDeadline = 0;
+  let checksDiscovered = false;
+  logger.step("wait", `waiting for ${options.branchName} to be green`);
+  while (true) {
+    const observedAt = Date.now();
+    const status = await prProvider.getBranchStatus(options.branchName);
+    if (status.headSha !== lastHeadSha) {
+      logger.step(
+        "info",
+        `branch head changed to ${status.headSha.substring(0, 7)}`
+      );
+      lastHeadSha = status.headSha;
+      headStableSince = observedAt;
+      if (checksFoundDeadline === 0) {
+        checksFoundDeadline = observedAt + checksFoundTimeoutMs;
+      }
+      checksCompletionDeadline = 0;
+      checksDiscovered = false;
     }
     if (status.checks.length > 0 && !checksDiscovered) {
       checksDiscovered = true;
@@ -6786,44 +7222,75 @@ async function completeIssueRun(options) {
     let prTitle = issue.title;
     let prBody;
     let finalizerResult;
+    const isLocalModeForFinalizer = options.prdRunMode?.mode === "local";
     const finalizerFromState = worktreeState?.finalizer?.completed ? worktreeState.finalizer : null;
     if (finalizerFromState) {
-      if (finalizerFromState.title && finalizerFromState.body) {
-        prTitle = finalizerFromState.title;
-        prBody = finalizerFromState.body;
-      } else if (finalizerFromState.artifactPath) {
-        if (!existsSync9(finalizerFromState.artifactPath)) {
+      try {
+        if (finalizerFromState.title && finalizerFromState.body) {
+          prTitle = finalizerFromState.title;
+          prBody = finalizerFromState.body;
+        } else if (finalizerFromState.artifactPath) {
+          if (!existsSync10(finalizerFromState.artifactPath)) {
+            throw new FinalizerFailure({
+              message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
+            });
+          }
+          const artifactContent = readFileSync12(
+            finalizerFromState.artifactPath,
+            "utf-8"
+          );
+          const parsed = parsePrDescription(artifactContent);
+          prTitle = parsed.title;
+          prBody = parsed.body;
+        } else {
           throw new FinalizerFailure({
-            message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
+            message: "Finalizer state is incomplete: missing title, body, and artifactPath"
           });
         }
-        const artifactContent = readFileSync11(
-          finalizerFromState.artifactPath,
-          "utf-8"
-        );
-        const parsed = parsePrDescription(artifactContent);
-        prTitle = parsed.title;
-        prBody = parsed.body;
-      } else {
-        throw new FinalizerFailure({
-          message: "Finalizer state is incomplete: missing title, body, and artifactPath"
-        });
+      } catch (error) {
+        if (isLocalModeForFinalizer) {
+          return {
+            branchName,
+            target,
+            issue,
+            noOp: false,
+            mode: "local",
+            failureCode: "finalizer_failed",
+            repairGuidance: error instanceof Error ? error.message : "Finalizer state is invalid"
+          };
+        }
+        throw error;
       }
     } else {
-      finalizerResult = await runEffectAndMapExit(
-        runFinalizerAgent({
-          executionProvider,
-          config,
-          target,
-          issue,
-          builderBranch: branchName,
-          targetBaseBranch: effectiveBaseBranch,
-          worktreePath: executionResult.worktreePath,
-          reviewArtifactPath,
-          repoRoot: ROOT,
-          logger
-        })
-      );
+      try {
+        finalizerResult = await runEffectAndMapExit(
+          runFinalizerAgent({
+            executionProvider,
+            config,
+            target,
+            issue,
+            builderBranch: branchName,
+            targetBaseBranch: effectiveBaseBranch,
+            worktreePath: executionResult.worktreePath,
+            reviewArtifactPath,
+            repoRoot: ROOT,
+            logger
+          })
+        );
+      } catch (error) {
+        if (isLocalModeForFinalizer) {
+          return {
+            branchName,
+            target,
+            issue,
+            noOp: false,
+            mode: "local",
+            failureCode: "finalizer_failed",
+            repairGuidance: error instanceof Error ? error.message : "Finalizer execution failed"
+          };
+        }
+        throw error;
+      }
       prTitle = finalizerResult.title;
       prBody = finalizerResult.body;
     }
@@ -6868,6 +7335,113 @@ async function completeIssueRun(options) {
         });
       }
     }
+    const isLocalMode = options.prdRunMode?.mode === "local";
+    if (isLocalMode) {
+      const parsed = parseStackedIssue(issue.title, issue.body);
+      const prdId = parsed.parentRef;
+      if (!prdId) {
+        return {
+          branchName,
+          target,
+          issue,
+          noOp: false,
+          mode: "local",
+          failureCode: "finalizer_failed",
+          repairGuidance: "Local mode requires a PRD reference (## Parent) in the issue body or title. Add the parent PRD reference and retry."
+        };
+      }
+      const finalizerFromWorktreeState = worktreeState?.finalizer;
+      if (finalizerFromWorktreeState && !finalizerFromWorktreeState.completed) {
+        return {
+          branchName,
+          target,
+          issue,
+          noOp: false,
+          mode: "local",
+          failureCode: "finalizer_failed",
+          repairGuidance: "Finalizer did not complete on previous run. Re-run the issue finalizer and try again."
+        };
+      }
+      if (!prTitle || !finalBody) {
+        return {
+          branchName,
+          target,
+          issue,
+          noOp: false,
+          mode: "local",
+          failureCode: "finalizer_failed",
+          repairGuidance: "Finalizer produced empty title or body. Re-run the issue finalizer and try again."
+        };
+      }
+      const existingReceipt = await hasLocalIssueMergeReceipt(
+        prdId,
+        `issue-${issueNumber}`,
+        ROOT
+      );
+      if (existingReceipt) {
+        return {
+          branchName,
+          target,
+          issue,
+          noOp: false,
+          mode: "local",
+          failureCode: "already_merged",
+          localPrdBranch: existingReceipt.localPrdBranch,
+          mergeCommit: existingReceipt.mergeCommit,
+          receiptPath: join14(
+            ROOT,
+            ".pourkit",
+            "local-prd-runs",
+            prdId,
+            "merge-receipts",
+            `issue-${issueNumber}.json`
+          )
+        };
+      }
+      const mergeResult = await squashMergeLocalIssue(
+        prdId,
+        `issue-${issueNumber}`,
+        {
+          finalizerTitle: prTitle,
+          finalizerBody: finalBody,
+          finalizerArtifactPath: worktreeState?.finalizer?.artifactPath ?? "",
+          sourceBranch: branchName
+        },
+        ROOT
+      );
+      if (!mergeResult.ok) {
+        return {
+          branchName,
+          target,
+          issue,
+          noOp: false,
+          mode: "local",
+          failureCode: mergeResult.failureCode,
+          repairGuidance: mergeResult.repairGuidance ?? `Local squash-merge failed: ${mergeResult.failureCode}`
+        };
+      }
+      await issueProvider.removeLabel(
+        issueNumber,
+        config.labels.agentInProgress
+      );
+      return {
+        branchName,
+        target,
+        issue,
+        noOp: false,
+        mode: "local",
+        localPrdBranch: getLocalPrdBranchName(prdId),
+        mergeCommit: mergeResult.receipt.mergeCommit,
+        receiptPath: join14(
+          ROOT,
+          ".pourkit",
+          "local-prd-runs",
+          prdId,
+          "merge-receipts",
+          `issue-${issueNumber}.json`
+        )
+      };
+    }
     let pr;
     if (worktreeState?.pr?.merged) {
       mergeCompleted = true;
@@ -7309,7 +7883,7 @@ async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   return { mode: "new", branchName, baseRef };
 }
 function issueWorktreePath(root, branchName) {
-  return join13(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
+  return join14(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
 }
 function resolveRegisteredIssueWorktreePath(worktreeListPorcelain, root, branchName) {
   const branchWorktreePath = parseWorktreeListPorcelain(
@@ -7337,7 +7911,7 @@ async function syncTargetBranch(root, baseBranch, logger) {
 }
 function loadBuilderPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync9(promptPath) ? readFileSync11(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync10(promptPath) ? readFileSync12(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -7780,29 +8354,29 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 // commands/prd-run.ts
 import {
   cpSync,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   lstatSync,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   mkdtempSync,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync15,
+  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 join19, 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
 import {
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync12,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync13,
   readdirSync as readdirSync4,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { z as z3 } from "zod";
 var PRD_RUN_STATE_DIR = ".pourkit/prd-runs";
 var PrdRunRecordSchema = z3.object({
@@ -7820,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",
@@ -7946,12 +8522,12 @@ function normalizePrdRunRef2(ref) {
 function readPrdRun(repoRoot2, prdRef) {
   const normalized = normalizePrdRunRef2(prdRef);
   const recordPath = getRecordPath(repoRoot2, normalized);
-  if (!existsSync10(recordPath)) {
+  if (!existsSync11(recordPath)) {
     return { record: null, diagnostics: [] };
   }
   try {
     const parsed = PrdRunRecordSchema.parse(
-      JSON.parse(readFileSync12(recordPath, "utf-8"))
+      JSON.parse(readFileSync13(recordPath, "utf-8"))
     );
     return { record: parsed, diagnostics: [] };
   } catch (error) {
@@ -7965,8 +8541,8 @@ function readPrdRun(repoRoot2, prdRef) {
   }
 }
 function listPrdRuns(repoRoot2) {
-  const stateDir = join14(repoRoot2, PRD_RUN_STATE_DIR);
-  if (!existsSync10(stateDir)) {
+  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
+  if (!existsSync11(stateDir)) {
     return { records: [], diagnostics: [] };
   }
   const records = [];
@@ -7975,10 +8551,10 @@ function listPrdRuns(repoRoot2) {
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const recordPath = join14(stateDir, entry.name);
+    const recordPath = join15(stateDir, entry.name);
     try {
       const record = PrdRunRecordSchema.parse(
-        JSON.parse(readFileSync12(recordPath, "utf-8"))
+        JSON.parse(readFileSync13(recordPath, "utf-8"))
       );
       records.push(record);
     } catch (error) {
@@ -7991,10 +8567,10 @@ function listPrdRuns(repoRoot2) {
 }
 function writePrdRunRecord(repoRoot2, record) {
   const normalized = normalizePrdRunRef2(record.prdRef);
-  const stateDir = join14(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
   const recordPath = getRecordPath(repoRoot2, normalized);
-  mkdirSync7(stateDir, { recursive: true });
-  writeFileSync4(
+  mkdirSync8(stateDir, { recursive: true });
+  writeFileSync5(
     recordPath,
     JSON.stringify({ ...record, prdRef: normalized }, null, 2),
     "utf-8"
@@ -8031,8 +8607,8 @@ var LocalPrdRunRecordSchema = z3.object({
   }),
   metadata: z3.record(z3.unknown())
 });
-function getLocalStorePath(repoRoot2, prdId) {
-  return join14(
+function getLocalStorePath2(repoRoot2, prdId) {
+  return join15(
     repoRoot2,
     LOCAL_PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef2(prdId)}.json`
@@ -8040,8 +8616,8 @@ function getLocalStorePath(repoRoot2, prdId) {
 }
 async function readLocalPrdRun(repoRoot2, prdId) {
   const normalized = normalizePrdRunRef2(prdId);
-  const recordPath = getLocalStorePath(repoRoot2, normalized);
-  if (!existsSync10(recordPath)) {
+  const recordPath = getLocalStorePath2(repoRoot2, normalized);
+  if (!existsSync11(recordPath)) {
     return null;
   }
   try {
@@ -8053,16 +8629,16 @@ async function readLocalPrdRun(repoRoot2, prdId) {
 }
 async function writeLocalPrdRunRecord(repoRoot2, prdId, record) {
   const normalized = normalizePrdRunRef2(prdId);
-  const storeDir = join14(repoRoot2, LOCAL_PRD_RUN_STATE_DIR);
+  const storeDir = join15(repoRoot2, LOCAL_PRD_RUN_STATE_DIR);
   await mkdir4(storeDir, { recursive: true });
   await writeFile(
-    getLocalStorePath(repoRoot2, normalized),
+    getLocalStorePath2(repoRoot2, normalized),
     JSON.stringify({ ...record, prdId: normalized }, null, 2),
     "utf-8"
   );
 }
 function getRecordPath(repoRoot2, prdRef) {
-  return join14(
+  return join15(
     repoRoot2,
     PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef2(prdRef)}.json`
@@ -8195,9 +8771,9 @@ function redactSensitiveValues(input) {
 }
 
 // prd-run/final-review-validation.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
 function parseFinalReviewArtifact(artifactPath) {
-  if (!existsSync11(artifactPath)) {
+  if (!existsSync12(artifactPath)) {
     return {
       ok: false,
       reason: "Final Review artifact not found.",
@@ -8206,7 +8782,7 @@ function parseFinalReviewArtifact(artifactPath) {
   }
   let content;
   try {
-    content = readFileSync13(artifactPath, "utf-8");
+    content = readFileSync14(artifactPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -8386,8 +8962,8 @@ function isRetouchScopePath(path9) {
 init_common();
 
 // prd-run/local-artifacts.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join16 } from "path";
 var REQUIRED_PRD_FIELDS = [
   "schemaVersion",
   "kind",
@@ -8420,13 +8996,13 @@ var REQUIRED_ISSUE_FIELDS = [
   "githubProjection"
 ];
 function prdStorePath(repoRoot2, prdId) {
-  return join15(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+  return join16(repoRoot2, ".pourkit", "local-prd-runs", prdId);
 }
 function prdArtifactPath(repoRoot2, prdId) {
-  return join15(prdStorePath(repoRoot2, prdId), "prd.json");
+  return join16(prdStorePath(repoRoot2, prdId), "prd.json");
 }
 function issueArtifactPath(repoRoot2, prdId, issueId) {
-  return join15(prdStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
+  return join16(prdStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
 }
 function hasRequiredFields(data, requiredFields) {
   for (const field of requiredFields) {
@@ -8439,7 +9015,7 @@ function hasRequiredFields(data, requiredFields) {
 async function resolveLocalPrdArtifact(prdId, repoRoot2) {
   const root = repoRoot2 ?? process.cwd();
   const prdPath = prdArtifactPath(root, prdId);
-  if (!existsSync12(prdPath)) {
+  if (!existsSync13(prdPath)) {
     return {
       ok: false,
       failureCode: "missing_prd_artifact",
@@ -8484,7 +9060,7 @@ async function resolveLocalIssueArtifacts(prdId, repoRoot2) {
   const issues = [];
   for (const childId of childIssueIds) {
     const issuePath = issueArtifactPath(root, prdId, childId);
-    if (!existsSync12(issuePath)) {
+    if (!existsSync13(issuePath)) {
       return {
         ok: false,
         failureCode: "missing_child_issue",
@@ -8620,97 +9196,36 @@ async function getRunnableLocalIssues(prdId, repoRoot2) {
 }
 
 // prd-run/local-final-review.ts
-import { execFileSync as execFileSync2, execSync as execSync2 } from "child_process";
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join16 } from "path";
-
-// prd-run/local-branches.ts
-import { execFileSync } from "child_process";
-function getLocalPrdBranchName(prdId) {
-  return `local/${prdId}`;
-}
-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) {
-  if (!name || name.length === 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_format",
-      message: "Branch name is empty."
-    };
-  }
-  if (isProtectedBranch(name)) {
-    return {
-      ok: false,
-      failureCode: "protected_branch",
-      message: `Branch "${name}" is protected.`
-    };
-  }
-  if (!LOCAL_BRANCH_PATTERN.test(name)) {
-    return {
-      ok: false,
-      failureCode: "invalid_format",
-      message: `Branch "${name}" does not match the local branch pattern.`
-    };
-  }
-  return { ok: true };
+import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join17 } from "path";
+function getLocalStorePath3(repoRoot2, prdId) {
+  return join17(repoRoot2, ".pourkit", "local-prd-runs", prdId);
 }
-function isProtectedBranch(name) {
-  return PROTECTED_BRANCHES.has(name);
+function getFinalReviewReceiptPath(repoRoot2, prdId) {
+  return join17(getLocalStorePath3(repoRoot2, prdId), "final-review-receipt.json");
 }
-function hasRemoteBackedCollision(localName, repoRoot2) {
-  const match = localName.match(/^local\/(PRD-\d{4})/);
-  if (!match) {
-    return Promise.resolve({
-      ok: false,
-      failureCode: "invalid_format",
-      message: `Cannot extract PRD ref from "${localName}".`
-    });
-  }
-  const prdRef = match[1];
-  try {
-    execFileSync(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${prdRef}`],
-      {
-        cwd: repoRoot2 ?? process.cwd(),
-        encoding: "utf8",
-        stdio: "pipe"
-      }
-    );
-    return Promise.resolve({
-      ok: false,
-      failureCode: "remote_backed_collision",
-      message: `Branch "${prdRef}" exists locally.`
-    });
-  } catch {
-  }
-  try {
-    execFileSync(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${prdRef}`],
-      {
-        cwd: repoRoot2 ?? process.cwd(),
+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 };
       }
-    );
-    return Promise.resolve({
-      ok: false,
-      failureCode: "remote_backed_collision",
-      message: `Remote branch "origin/${prdRef}" exists.`
-    });
-  } catch {
+    } catch {
+      continue;
+    }
   }
-  return Promise.resolve({ ok: true });
-}
-
-// prd-run/local-final-review.ts
-function getLocalStorePath2(repoRoot2, prdId) {
-  return join16(repoRoot2, ".pourkit", "local-prd-runs", prdId);
-}
-function getFinalReviewReceiptPath(repoRoot2, prdId) {
-  return join16(getLocalStorePath2(repoRoot2, prdId), "final-review-receipt.json");
+  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();
@@ -8724,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 {
@@ -8744,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";
@@ -8762,13 +9305,14 @@ 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);
-  mkdirSync8(getLocalStorePath2(root, prdId), { recursive: true });
-  writeFileSync5(receiptPath, JSON.stringify(receipt, null, 2), "utf-8");
+  mkdirSync9(getLocalStorePath3(root, prdId), { recursive: true });
+  writeFileSync6(receiptPath, JSON.stringify(receipt, null, 2), "utf-8");
   const result = { ok: true, verdict, receipt };
   if (failures.length > 0) {
     result.message = failures.map(
@@ -8782,7 +9326,7 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
   const targetBranch = `local/${prdId}`;
   const retouchBranch = `local/${prdId}/retouch`;
   try {
-    execFileSync2(
+    execFileSync3(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${retouchBranch}`],
       {
@@ -8795,7 +9339,7 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
     return;
   }
   try {
-    execFileSync2(
+    execFileSync3(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
       {
@@ -8808,18 +9352,18 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
     return;
   }
   try {
-    execFileSync2("git", ["checkout", targetBranch], {
+    execFileSync3("git", ["checkout", targetBranch], {
       cwd: root,
       encoding: "utf8",
       stdio: "pipe"
     });
-    execFileSync2("git", ["merge", "--squash", retouchBranch], {
+    execFileSync3("git", ["merge", "--squash", retouchBranch], {
       cwd: root,
       encoding: "utf8",
       stdio: "pipe"
     });
     try {
-      execFileSync2("git", ["diff", "--cached", "--quiet"], {
+      execFileSync3("git", ["diff", "--cached", "--quiet"], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
@@ -8827,7 +9371,7 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
       return;
     } catch {
     }
-    execFileSync2(
+    execFileSync3(
       "git",
       ["commit", "-m", `Squash merge ${retouchBranch} into ${targetBranch}`],
       {
@@ -8836,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")) {
@@ -8846,53 +9410,27 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
 }
 
 // prd-run/local-reconciliation.ts
-import { execFileSync as execFileSync3 } from "child_process";
-import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync14,
-  readdirSync as readdirSync5,
-  writeFileSync as writeFileSync6
-} from "fs";
-import { join as join17 } from "path";
-function getLocalStorePath3(repoRoot2, prdId) {
-  return join17(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+import { execFileSync as execFileSync4 } from "child_process";
+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);
 }
 function getFinalReviewReceiptPath2(repoRoot2, prdId) {
-  return join17(getLocalStorePath3(repoRoot2, prdId), "final-review-receipt.json");
+  return join18(getLocalStorePath4(repoRoot2, prdId), "final-review-receipt.json");
 }
 function getHandoffArtifactPath(repoRoot2, prdId) {
-  return join17(repoRoot2, ".pourkit", ".tmp", "reconciliation", `${prdId}.json`);
-}
-function getCompletionsDir(repoRoot2, prdId) {
-  const initiativesRoot = join17(
-    repoRoot2,
-    ".pourkit",
-    "architecture",
-    "initiatives"
-  );
-  if (existsSync14(initiativesRoot)) {
-    const dirs = readdirSync5(initiativesRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join17(initiativesRoot, e.name));
-    for (const dir of dirs) {
-      const prdsDir = join17(dir, "prds");
-      if (!existsSync14(prdsDir)) continue;
-      const prdDirs = readdirSync5(prdsDir, { withFileTypes: true }).filter(
-        (e) => e.isDirectory() && e.name.startsWith(prdId.toLowerCase())
-      );
-      if (prdDirs.length > 0) return join17(dir, "completions");
-    }
-  }
-  return join17(getLocalStorePath3(repoRoot2, prdId), "completions");
+  return join18(repoRoot2, ".pourkit", ".tmp", "reconciliation", `${prdId}.json`);
 }
 function getReconciliationReceiptPath(repoRoot2, prdId) {
-  return join17(
-    getLocalStorePath3(repoRoot2, prdId),
+  return join18(
+    getLocalStorePath4(repoRoot2, prdId),
     "reconciliation-receipt.json"
   );
 }
 async function runLocalReconciliation(prdId, options) {
   const root = options?.repoRoot ?? process.cwd();
-  if (!existsSync14(getFinalReviewReceiptPath2(root, prdId))) {
+  if (!existsSync15(getFinalReviewReceiptPath2(root, prdId))) {
     return {
       ok: false,
       failureCode: "missing_final_review",
@@ -8900,7 +9438,7 @@ async function runLocalReconciliation(prdId, options) {
     };
   }
   try {
-    execFileSync3("pourkit-architect", ["reconcile", prdId], {
+    execFileSync4("pourkit-architect", ["reconcile", prdId], {
       cwd: root,
       encoding: "utf8",
       stdio: "pipe"
@@ -8916,7 +9454,7 @@ async function runLocalReconciliation(prdId, options) {
   }
   let handoff;
   try {
-    const content = readFileSync14(getHandoffArtifactPath(root, prdId), "utf-8");
+    const content = readFileSync15(getHandoffArtifactPath(root, prdId), "utf-8");
     handoff = JSON.parse(content);
   } catch {
     return {
@@ -8925,67 +9463,39 @@ async function runLocalReconciliation(prdId, options) {
       message: "Handoff artifact validation failed. Check Architect reconciliation output."
     };
   }
-  if (handoff.result === "blocked") {
-    return {
-      ok: false,
-      failureCode: "reconciliation_blocked",
-      message: "Architect reconciliation is blocked."
-    };
-  }
-  if (handoff.result === "changes_produced" && (!Array.isArray(handoff.changedPlanningPaths) || handoff.changedPlanningPaths.length === 0)) {
+  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,
+      failureCode: "reconciliation_blocked",
+      message: "Architect reconciliation is blocked."
+    };
+  }
+  if (handoff.result === "changes_produced" && (!Array.isArray(handoff.changedPlanningPaths) || handoff.changedPlanningPaths.length === 0)) {
     return {
       ok: false,
       failureCode: "invalid_handoff",
       message: "Handoff artifact validation failed. Check Architect reconciliation output."
     };
   }
-  if (handoff.result === "changes_produced") {
-    try {
-      const completionsDir = getCompletionsDir(root, prdId);
-      mkdirSync9(completionsDir, { recursive: true });
-      const existing = existsSync14(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 = join17(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("");
-      writeFileSync6(filepath, lines.join("\n"), "utf-8");
-      execFileSync3("git", ["add", filepath], {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      });
-      execFileSync3(
-        "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);
       try {
-        execFileSync3(
+        execFileSync4(
           "git",
           ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
           { cwd: root, encoding: "utf8", stdio: "pipe" }
@@ -8994,17 +9504,17 @@ 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.`
         };
       }
-      execFileSync3("git", ["checkout", targetBranch], {
+      execFileSync4("git", ["checkout", targetBranch], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
       });
       const sourceBranch = `local/${prdId}/reconciliation`;
       try {
-        execFileSync3(
+        execFileSync4(
           "git",
           ["show-ref", "--verify", "--quiet", `refs/heads/${sourceBranch}`],
           {
@@ -9017,27 +9527,46 @@ 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.`
         };
       }
-      execFileSync3("git", ["merge", "--squash", sourceBranch], {
+      execFileSync4("git", ["merge", "--squash", sourceBranch], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
       });
       try {
-        execFileSync3("git", ["diff", "--cached", "--quiet"], {
+        execFileSync4("git", ["diff", "--cached", "--quiet"], {
           cwd: root,
           encoding: "utf8",
           stdio: "pipe"
         });
       } catch {
-        execFileSync3(
+        execFileSync4(
           "git",
           ["commit", "-m", `Squash merge ${sourceBranch} into ${targetBranch}`],
           { 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,
@@ -9046,23 +9575,26 @@ 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
   };
-  mkdirSync9(getLocalStorePath3(root, prdId), { recursive: true });
-  writeFileSync6(
+  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
-import { existsSync as existsSync15 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join19 } from "path";
 var VALID_TRIAGE_LABELS2 = /* @__PURE__ */ new Set([
   "needs-triage",
   "ready-for-agent",
@@ -9080,8 +9612,8 @@ function fail(gate, failureCode, repairGuidance, gates) {
 async function validateLocalPrepareGates(prdId, repoRoot2) {
   const root = repoRoot2 ?? process.cwd();
   const gates = {};
-  const storePath = join18(root, ".pourkit", "local-prd-runs", prdId);
-  if (!existsSync15(storePath)) {
+  const storePath = join19(root, ".pourkit", "local-prd-runs", prdId);
+  if (!existsSync16(storePath)) {
     return fail(
       "store_shape",
       "local_prepare_store_shape_failed",
@@ -9202,6 +9734,297 @@ async function validateLocalPrepareGates(prdId, repoRoot2) {
   return { ok: true, gates };
 }
 
+// prd-run/local-queue-loop.ts
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
+import { join as join20 } from "path";
+
+// prd-run/local-issue-run.ts
+import { execFileSync as execFileSync5 } from "child_process";
+init_common();
+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 issue = issuesResult.data.find((i) => i.id === issueId);
+  if (!issue) {
+    throw new Error(`Issue "${issueId}" not found under PRD "${prdId}"`);
+  }
+  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}`
+    );
+  }
+  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,
+      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";
@@ -9507,6 +10330,7 @@ function runOneQueueIssueEffect(options) {
     }
     const { issue: selected } = outcome;
     const baseBranchOverride = options.queueRunContext?.prdBranch;
+    const prdRunMode = options.prdRunMode ?? options.queueRunContext?.prdRunMode;
     const runResult = yield* Effect8.tryPromise({
       try: () => runIssueCommand({
         issueNumber: selected.number,
@@ -9518,7 +10342,8 @@ function runOneQueueIssueEffect(options) {
         force,
         logger,
         repoRoot: repoRoot2,
-        ...baseBranchOverride ? { baseBranchOverride } : {}
+        ...baseBranchOverride ? { baseBranchOverride } : {},
+        ...prdRunMode ? { prdRunMode } : {}
       }),
       catch: (e) => {
         if (e instanceof Error) return e;
@@ -9529,6 +10354,10 @@ function runOneQueueIssueEffect(options) {
     logger.raw(`  Branch: ${runResult.branchName}`);
     if (runResult.noOp) {
       logger.raw("  Status: no-op (closed without PR)");
+    } else if (runResult.mode === "local") {
+      logger.raw(`  Local PRD Branch: ${runResult.localPrdBranch}`);
+      logger.raw(`  Merge Commit: ${runResult.mergeCommit}`);
+      logger.raw(`  Receipt: ${runResult.receiptPath}`);
     } else {
       logger.raw(`  PR Title: ${runResult.prTitle}`);
       logger.raw(`  PR Number: ${runResult.prNumber}`);
@@ -9588,7 +10417,8 @@ async function runQueueCommand(options) {
     logger: options.logger,
     repoRoot: options.repoRoot,
     prdRef: options.prdRef,
-    queueRunContext: options.queueRunContext
+    queueRunContext: options.queueRunContext,
+    prdRunMode: options.queueRunContext?.prdRunMode
   };
   if (!options.loop) {
     return runEffectAndMapExit(runQueue(queueOptions));
@@ -9717,7 +10547,7 @@ function validateChangedPlanningPaths(paths, options) {
       continue;
     }
     if (options?.repoRoot) {
-      const fullPath = join19(options.repoRoot, p);
+      const fullPath = join21(options.repoRoot, p);
       try {
         if (lstatSync(fullPath).isSymbolicLink()) {
           rejected.push(p);
@@ -9742,7 +10572,7 @@ function assessStaleSucceededReconciliationReceipt(options) {
   if (!receipt || receipt.status !== "succeeded" || receipt.prNumber || receipt.mergeCommit) {
     return { mode: "none" };
   }
-  const observedDiff = collectObservedReconciliationPlanningDiff({
+  const observedDiff = collectObservedReconciliationDirtyPaths({
     worktreeCwd: options.worktreeCwd,
     ignoredPrdRunRecordRef: options.prdRef
   });
@@ -9753,23 +10583,14 @@ function assessStaleSucceededReconciliationReceipt(options) {
       offendingPaths: []
     };
   }
-  if (observedDiff.rejectedPaths.length > 0) {
-    return {
-      mode: "blocked",
-      diagnostics: [
-        "Reconciliation worktree contains unpublished changes outside safe planning scope."
-      ],
-      offendingPaths: observedDiff.rejectedPaths
-    };
-  }
-  if (observedDiff.changedPlanningPaths.length === 0) {
+  if (observedDiff.dirtyPaths.length === 0) {
     return { mode: "none" };
   }
   return {
     mode: "recoverable",
-    changedPlanningPaths: observedDiff.changedPlanningPaths,
+    dirtyPaths: observedDiff.dirtyPaths,
     diagnostics: [
-      "Recovered stale reconciliation success receipt from unpublished planning changes in worktree."
+      "Recovered stale reconciliation success receipt from dirty reconciliation worktree."
     ]
   };
 }
@@ -9837,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;
     }
@@ -9893,7 +10720,7 @@ function canRetryFinalReviewBlock(record) {
 }
 function loadFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  return existsSync16(promptPath) ? readFileSync15(promptPath, "utf-8") : promptTemplate;
+  return existsSync17(promptPath) ? readFileSync17(promptPath, "utf-8") : promptTemplate;
 }
 function formatVerificationCommands(commands) {
   if (commands.length === 0) return "No verification commands configured.";
@@ -9906,12 +10733,14 @@ function buildFinalReviewPrompt(options) {
     `Worktree checkout base: ${options.evidencePacket.prdBranch}`,
     `Review only this range: ${options.evidencePacket.mergeBase}..HEAD`,
     "Do not compare against current target branch HEAD; the merge base is the review baseline.",
-    `Before handoff, run: npm run pourkit:validate-final-review -- ${options.evidencePacket.prdRef} --checkout-base ${options.evidencePacket.prdBranch} --review-base ${options.evidencePacket.mergeBase}`,
+    `Before handoff, run: pourkit prd-run validate-final-review ${options.evidencePacket.prdRef} --checkout-base ${options.evidencePacket.prdBranch} --review-base ${options.evidencePacket.mergeBase}`,
     "Fix any validation failures before handing off.",
     "",
-    "## Target Verification Commands",
+    "## Verification",
+    "",
+    `Run this command before handoff when retouch changes are made: pourkit run-verification --target ${options.targetName}`,
     "",
-    "Run these commands before handoff when retouch changes are made:",
+    "Underlying project commands:",
     formatVerificationCommands(options.verificationCommands),
     "",
     "Evidence Packet (do not infer PRD context from local state files):",
@@ -9938,14 +10767,14 @@ function buildReconciliationPrompt(options) {
     options.artifactPath,
     "",
     "Self-validation command:",
-    `validate-artifact reconciliation ${options.artifactPath}`
+    `pourkit validate-artifact reconciliation ${options.artifactPath}`
   ].join("\n");
 }
 function buildReconciliationBranchName(prdRef) {
   return `${normalizePrdRunRef2(prdRef)}-reconciliation`;
 }
 function reconciliationWorktreePath(repoRoot2, branchName) {
-  return join19(repoRoot2, ".sandcastle", "worktrees", branchName);
+  return join21(repoRoot2, ".sandcastle", "worktrees", branchName);
 }
 function reconciliationReceiptWorktreePath(branchName) {
   return `.sandcastle/worktrees/${branchName}`;
@@ -9957,7 +10786,7 @@ function buildFinalReviewBranchName(prdRef) {
   return `pourkit/${normalizePrdRunRef2(prdRef).toLowerCase()}-final-review`;
 }
 function finalReviewWorktreePath(repoRoot2, branchName) {
-  return join19(
+  return join21(
     repoRoot2,
     ".sandcastle",
     "worktrees",
@@ -9980,7 +10809,7 @@ function listFinalReviewChangedPaths(worktreePath, mergeBase) {
     }
     paths.add(path9);
   };
-  const diffResult = spawnSync2(
+  const diffResult = spawnSync3(
     "git",
     ["diff", "--name-only", mergeBase, "--", "."],
     {
@@ -9991,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"],
     {
@@ -10012,7 +10841,7 @@ function buildFinalReviewFinalizerPrompt(options) {
     options.repoRoot,
     options.promptTemplate
   );
-  const promptBody = existsSync16(promptPath) ? readFileSync15(promptPath, "utf-8") : options.promptTemplate;
+  const promptBody = existsSync17(promptPath) ? readFileSync17(promptPath, "utf-8") : options.promptTemplate;
   return [
     "# Final Review Retouch PR Finalizer",
     "",
@@ -10046,7 +10875,7 @@ function buildFinalReviewFinalizerPrompt(options) {
 }
 async function runFinalReviewPrFinalizer(options) {
   const finalizer = options.target.strategy.finalize.prDescriptionAgent;
-  const artifactPathInWorktree = join19(
+  const artifactPathInWorktree = join21(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -10092,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"
   });
@@ -10120,15 +10949,15 @@ function ensureFinalReviewWorktree(options) {
     }
     return { ok: true, worktreePath: registeredPath };
   }
-  if (existsSync16(worktreePath)) {
+  if (existsSync17(worktreePath)) {
     return {
       ok: false,
       reason: "Final Review worktree path exists but is not registered with git.",
       diagnostics: [`stale worktree path: ${worktreePath}`]
     };
   }
-  mkdirSync10(dirname5(worktreePath), { recursive: true });
-  const branchResult = spawnSync2(
+  mkdirSync11(dirname5(worktreePath), { recursive: true });
+  const branchResult = spawnSync3(
     "git",
     ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
     { cwd: options.repoRoot, encoding: "utf8" }
@@ -10140,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" }
@@ -10182,7 +11011,7 @@ async function createOrReuseFinalReviewRetouchPr(options) {
   if (existingPr && existingPr.state === "OPEN") {
     return existingPr;
   }
-  const worktreePath = mkdtempSync(join19(tmpdir(), "pourkit-retouch-"));
+  const worktreePath = mkdtempSync(join21(tmpdir(), "pourkit-retouch-"));
   try {
     runGitOrThrow(
       options.repoRoot,
@@ -10200,9 +11029,9 @@ async function createOrReuseFinalReviewRetouchPr(options) {
       "create retouch branch"
     );
     for (const changedFile of options.changedPaths) {
-      const sourcePath = join19(options.sourceWorktreePath, changedFile);
-      const targetPath = join19(worktreePath, changedFile);
-      mkdirSync10(dirname5(targetPath), { recursive: true });
+      const sourcePath = join21(options.sourceWorktreePath, changedFile);
+      const targetPath = join21(worktreePath, changedFile);
+      mkdirSync11(dirname5(targetPath), { recursive: true });
       cpSync(sourcePath, targetPath, { recursive: true });
     }
     runGitOrThrow(
@@ -10216,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}`],
     {
@@ -10556,6 +11385,7 @@ async function runPrdRunFinalReviewCommand(options) {
       prompt: buildFinalReviewPrompt({
         repoRoot: options.repoRoot,
         promptTemplate: finalReviewConfig.promptTemplate,
+        targetName,
         evidencePacket,
         verificationCommands
       }),
@@ -10631,7 +11461,7 @@ async function runPrdRunFinalReviewCommand(options) {
     };
   }
   const resolvedWorktreePath = executionResult.worktreePath;
-  const artifactPath = join19(
+  const artifactPath = join21(
     resolvedWorktreePath,
     ".pourkit/final-review-artifact.json"
   );
@@ -11215,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 : join19(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 {
@@ -11229,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" }
@@ -11381,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" }
@@ -11439,7 +12269,7 @@ async function runReconcilePreflightAndSetup(options) {
         branchAction: "blocked"
       };
     }
-    const resetResult = spawnSync2(
+    const resetResult = spawnSync3(
       "git",
       ["reset", "--hard", `origin/${prdBranch}`],
       { cwd: worktreeCwd, encoding: "utf8" }
@@ -11482,7 +12312,7 @@ async function runReconcilePreflightAndSetup(options) {
       );
       return { ok: false, diagnostics, branchAction: "blocked" };
     }
-    const adoptionCheck = spawnSync2(
+    const adoptionCheck = spawnSync3(
       "git",
       [
         "merge-base",
@@ -11523,14 +12353,14 @@ async function runReconcilePreflightAndSetup(options) {
     );
     return { ok: false, diagnostics, branchAction: "blocked" };
   }
-  if (existsSync16(worktreePath)) {
+  if (existsSync17(worktreePath)) {
     diagnostics.push(
       "Reconciliation worktree path exists but is not registered with git.",
       `stale worktree path: ${worktreePath}`
     );
     return { ok: false, diagnostics, branchAction: "blocked" };
   }
-  const branchResult = spawnSync2(
+  const branchResult = spawnSync3(
     "git",
     ["branch", "-f", reconciliationBranchName, `origin/${prdBranch}`],
     { cwd: options.repoRoot, encoding: "utf8" }
@@ -11544,14 +12374,14 @@ async function runReconcilePreflightAndSetup(options) {
     );
     return { ok: false, diagnostics, branchAction: "blocked" };
   }
-  mkdirSync10(dirname5(worktreePath), { recursive: true });
-  const addResult = spawnSync2(
+  mkdirSync11(dirname5(worktreePath), { recursive: true });
+  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"
     });
@@ -11599,7 +12429,7 @@ function buildReconciliationPrBody(options) {
 function commitAndPushReconciliationChanges(options) {
   const diagnostics = [];
   const existingPaths = options.changedPlanningPaths.filter((p) => {
-    return existsSync16(join19(options.worktreeCwd, p));
+    return existsSync17(join21(options.worktreeCwd, p));
   });
   if (existingPaths.length === 0) {
     diagnostics.push(
@@ -11607,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"
   });
@@ -11624,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"
   });
@@ -11648,7 +12478,7 @@ function commitAndPushReconciliationChanges(options) {
       };
     }
   }
-  const pushResult = spawnSync2(
+  const pushResult = spawnSync3(
     "git",
     [
       "push",
@@ -11742,7 +12572,7 @@ async function runPrdRunReconcileCommand(options) {
   const record = preflightResult.record;
   const prdBranch = record?.prdBranch ?? prdRef;
   const mergeBase = preflightResult.mergeBase;
-  const worktreeCwd = preflightResult.worktreePath ? join19(options.repoRoot, preflightResult.worktreePath) : options.repoRoot;
+  const worktreeCwd = preflightResult.worktreePath ? join21(options.repoRoot, preflightResult.worktreePath) : options.repoRoot;
   const staleSucceededRecovery = assessStaleSucceededReconciliationReceipt({
     receipt: record?.reconciliation,
     worktreeCwd,
@@ -12044,7 +12874,7 @@ async function runPrdRunReconcileCommand(options) {
       baseRef: prdBranch,
       checkoutBase,
       reviewBase: mergeBase,
-      worktreePath: join19(options.repoRoot, preflightResult.worktreePath),
+      worktreePath: join21(options.repoRoot, preflightResult.worktreePath),
       sandbox: options.config.sandbox,
       artifactPath,
       logger: options.logger
@@ -12145,7 +12975,7 @@ async function runPrdRunReconcileCommand(options) {
       offendingPaths: []
     };
   }
-  const fullArtifactPath = join19(executionResult.worktreePath, artifactPath);
+  const fullArtifactPath = join21(executionResult.worktreePath, artifactPath);
   let artifactContent;
   try {
     artifactContent = JSON.parse(retryResult.artifact.value);
@@ -12252,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"
   });
@@ -12267,11 +13097,27 @@ async function runPrdRunReconcileCommand(options) {
     gitStatusShortLines,
     gitDiffNameStatusLines
   });
+  const observedWorktreeDiff = collectObservedReconciliationDirtyPaths({
+    worktreeCwd,
+    ignoredPrdRunRecordRef: prdRef
+  });
   let outcomeResult;
   let outcomeDiagnostics = [];
   let outcomeChangedPaths = [];
   let outcomeRationale;
-  if (artifactResult === "no_changes_needed") {
+  if (!observedWorktreeDiff.ok) {
+    outcomeResult = "blocked";
+    outcomeDiagnostics.push(...observedWorktreeDiff.diagnostics);
+  } else if (observedWorktreeDiff.dirtyPaths.length > 0) {
+    outcomeResult = "changes_produced";
+    outcomeChangedPaths = [...observedWorktreeDiff.dirtyPaths];
+    outcomeRationale = void 0;
+    if (artifactResult === "no_changes_needed") {
+      outcomeDiagnostics.push(
+        "Dirty reconciliation worktree observed after agent run; treating reconciliation result as changes_produced."
+      );
+    }
+  } else if (artifactResult === "no_changes_needed") {
     outcomeResult = "no_changes_needed";
     outcomeChangedPaths = [];
     outcomeRationale = artifactNoChangeRationale ?? "No changes needed.";
@@ -12292,11 +13138,11 @@ async function runPrdRunReconcileCommand(options) {
   }
   if (staleSucceededRecovery.mode === "recoverable" && artifactResult === "no_changes_needed") {
     outcomeResult = "changes_produced";
-    outcomeChangedPaths = [...staleSucceededRecovery.changedPlanningPaths];
+    outcomeChangedPaths = [...staleSucceededRecovery.dirtyPaths];
     outcomeRationale = void 0;
     outcomeDiagnostics.push(...staleSucceededRecovery.diagnostics);
   }
-  if (!pathValidation.ok && outcomeResult !== "blocked") {
+  if (!pathValidation.ok && outcomeResult !== "blocked" && observedWorktreeDiff.ok && observedWorktreeDiff.dirtyPaths.length === 0) {
     outcomeResult = "blocked";
     outcomeDiagnostics.push(
       `Unsafe changed planning paths: ${(pathValidation.rejected ?? []).join(", ")}`
@@ -12993,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"
   });
@@ -13013,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}`],
     {
@@ -13156,26 +14002,26 @@ function auditPrd047Implementation(repoRoot2, prdRef) {
   const blockerBugs = [];
   const blockersFixed = [];
   const nonBlockers = [];
-  const prdMirrorPath = join19(repoRoot2, PRD_047_PRD_MIRROR_PATH);
-  const completionsDir = join19(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 (existsSync16(completionsDir)) {
-    const files = readdirSync6(completionsDir);
+  if (existsSync17(completionsDir)) {
+    const files = readdirSync5(completionsDir);
     escapeHatchPresent = files.some(
       (f) => f.endsWith(".md") && (f.includes("prd-047") || f.includes("prd-reconciliation"))
     );
   }
   if (!escapeHatchPresent) {
-    escapeHatchPresent = existsSync16(join19(repoRoot2, PRD_047_ESCAPE_HATCH_PATH));
+    escapeHatchPresent = existsSync17(join21(repoRoot2, PRD_047_ESCAPE_HATCH_PATH));
   }
-  const prdMirrorExists = existsSync16(prdMirrorPath);
+  const prdMirrorExists = existsSync17(prdMirrorPath);
   if (!prdMirrorExists) {
     nonBlockers.push(
       `PRD-0047 PRD mirror not found at ${PRD_047_PRD_MIRROR_PATH}. Cannot verify scope alignment from published mirrors.`
     );
   }
   if (prdMirrorExists) {
-    const mirrorContent = readFileSync15(prdMirrorPath, "utf-8");
+    const mirrorContent = readFileSync17(prdMirrorPath, "utf-8");
     const hasReconcileCommand = mirrorContent.includes("prd-run reconcile");
     const hasEscapeHatch = mirrorContent.includes("escape hatch");
     if (!hasReconcileCommand) {
@@ -13189,16 +14035,16 @@ function auditPrd047Implementation(repoRoot2, prdRef) {
       );
     }
   }
-  const childIssueDir = join19(repoRoot2, PRD_047_CHILD_ISSUE_DIR);
-  const childIssuesExist = existsSync16(childIssueDir);
+  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 = join19(repoRoot2, PRD_047_MANIFEST_PATH);
-  if (existsSync16(manifestPath)) {
-    const manifestContent = readFileSync15(manifestPath, "utf-8");
+  const manifestPath = join21(repoRoot2, PRD_047_MANIFEST_PATH);
+  if (existsSync17(manifestPath)) {
+    const manifestContent = readFileSync17(manifestPath, "utf-8");
     if (!manifestContent.includes("ready_for_prepare")) {
       nonBlockers.push(
         "Planning Artifact Manifest is not marked as ready_for_prepare."
@@ -13287,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 = [];
@@ -13298,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: [],
@@ -13311,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");
@@ -13442,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 = join19(
+    const localStorePath2 = join21(
       options.repoRoot,
       ".pourkit",
       "local-prd-runs",
       prdRef
     );
-    if (existsSync16(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
       );
@@ -13491,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, {
@@ -13525,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, {
@@ -13607,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",
@@ -13634,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;
@@ -13717,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",
@@ -14046,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"
@@ -14066,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"
@@ -14081,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"
@@ -14203,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);
@@ -14322,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) {
@@ -14357,7 +15471,8 @@ async function runPrdRunStartCommand(options) {
             ...reusedStart
           },
           {
-            targetName
+            targetName,
+            mode: resolvedMode
           }
         );
         return await processStartResult(
@@ -14460,6 +15575,7 @@ async function runPrdRunStartCommand(options) {
         },
         {
           targetName,
+          mode: resolvedMode,
           manifestPath: existingRecord.record?.manifestPath,
           planning: existingRecord.record?.planning
         }
@@ -14619,6 +15735,7 @@ async function runPrdRunStartCommand(options) {
       },
       {
         targetName,
+        mode: resolvedMode,
         manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath,
         planning: existingRecord.record?.planning
       }
@@ -14701,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",
@@ -14728,6 +15907,7 @@ async function runPrdRunStartCommand(options) {
     updatedAt,
     targetName,
     start,
+    mode: resolvedMode,
     manifestPath: existingRecord.record?.manifestPath ?? manifest?.manifestPath ?? void 0,
     planning: existingRecord.record?.planning
   });
@@ -14751,26 +15931,100 @@ async function processStartResult(startResult, options) {
   start.queueStartedAt = (/* @__PURE__ */ new Date()).toISOString();
   start.queueCommand = "queue-run";
   const existingRecord = readPrdRun(repoRoot2, prdRef);
+  let resolvedMode;
+  try {
+    const target = options.config ? resolveTarget(options.config, start.targetName) : null;
+    resolvedMode = target?.strategy ? resolvePrdRunMode(target) : void 0;
+  } catch {
+    resolvedMode = void 0;
+  }
+  const modeForRecord = resolvedMode?.mode;
   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 = join19(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
-  if (existsSync16(localStorePath)) {
-    const localIssues = await getRunnableLocalIssues(prdRef, repoRoot2);
+  const localStorePath = join21(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  if (existsSync17(localStorePath)) {
+    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
     });
@@ -14795,7 +16049,8 @@ async function processStartResult(startResult, options) {
       prdRef,
       queueRunContext: {
         prdRef,
-        prdBranch: start.prdBranch
+        prdBranch: start.prdBranch,
+        prdRunMode: resolvedMode
       }
     });
     if (outcome.selected === null && outcome.code === "drained") {
@@ -14812,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: []
@@ -14833,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
       });
@@ -14854,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: []
@@ -14878,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: []
@@ -14902,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: []
@@ -14933,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"
   });
@@ -14963,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],
     {
@@ -15093,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"
   });
@@ -15110,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"
   });
@@ -15130,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"
   });
@@ -15150,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],
     {
@@ -15177,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}`],
     {
@@ -15230,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}: ${[
@@ -15242,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"
   });
@@ -15273,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"
   });
@@ -15289,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"
   });
@@ -15333,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(join19(tmpdir(), "pourkit-planning-"));
+  const worktreePath = mkdtempSync(join21(tmpdir(), "pourkit-planning-"));
   try {
     runGitOrThrow(repoRoot2, ["fetch", "origin", "dev"], "fetch origin/dev");
     runGitOrThrow(
@@ -15354,9 +16615,9 @@ async function ensurePlanningBranchPublished(repoRoot2, branchName, changedFiles
       "create planning branch"
     );
     for (const changedFile of changedFiles) {
-      const sourcePath = join19(repoRoot2, changedFile);
-      const targetPath = join19(worktreePath, changedFile);
-      mkdirSync10(dirname5(targetPath), { recursive: true });
+      const sourcePath = join21(repoRoot2, changedFile);
+      const targetPath = join21(worktreePath, changedFile);
+      mkdirSync11(dirname5(targetPath), { recursive: true });
       cpSync(sourcePath, targetPath, { recursive: true });
     }
     runGitOrThrow(
@@ -15370,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}`],
     {
@@ -15512,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}`],
       {
@@ -15538,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"
   });
@@ -15592,12 +16853,12 @@ function collectGitChangedFiles(repoRoot2, ignoredPrdRunRecordRef) {
     changedFiles: Array.from(new Set(changedFiles))
   };
 }
-function collectObservedReconciliationPlanningDiff(options) {
-  const statusResult = spawnSync2("git", ["status", "--porcelain=v1", "-uall"], {
+function collectObservedReconciliationDirtyPaths(options) {
+  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"
   });
@@ -15625,37 +16886,19 @@ function collectObservedReconciliationPlanningDiff(options) {
       )
     )
   );
-  const intrinsicallyRejectedPaths = candidatePaths.filter(
-    (path9) => !isAllowedPlanningPath(path9) || isBlockedPlanningPath(path9) || hasDirectoryTraversal(path9)
-  );
-  const allowedCandidatePaths = candidatePaths.filter(
-    (path9) => !intrinsicallyRejectedPaths.includes(path9)
-  );
-  const validation = validateChangedPlanningPaths(allowedCandidatePaths, {
-    repoRoot: options.worktreeCwd,
-    gitStatusShortLines,
-    gitDiffNameStatusLines
-  });
-  const rejectedPaths = Array.from(
-    /* @__PURE__ */ new Set([
-      ...intrinsicallyRejectedPaths,
-      ...validation.ok ? [] : validation.rejected ?? []
-    ])
-  ).sort();
   return {
     ok: true,
-    changedPlanningPaths: allowedCandidatePaths.filter((path9) => !rejectedPaths.includes(path9)).sort(),
-    rejectedPaths
+    dirtyPaths: candidatePaths.sort()
   };
 }
 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"
   });
@@ -15670,7 +16913,7 @@ function parseGitStatusLine(line) {
   return { status, path: path9.replace(/^"|"$/g, "") };
 }
 function validateManifestArtifactExistence(repoRoot2, manifest) {
-  const missingPaths = listManifestArtifactPaths(repoRoot2, manifest).filter((path9) => !existsSync16(path9)).map((path9) => toRepoRelativePath2(repoRoot2, path9));
+  const missingPaths = listManifestArtifactPaths(repoRoot2, manifest).filter((path9) => !existsSync17(path9)).map((path9) => toRepoRelativePath2(repoRoot2, path9));
   if (missingPaths.length > 0) {
     return {
       ok: false,
@@ -16086,7 +17329,7 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
 }
 
 // commands/init.ts
-import { existsSync as existsSync17, statSync } from "fs";
+import { existsSync as existsSync18, statSync } from "fs";
 import {
   copyFile,
   mkdir as mkdir5,
@@ -16589,7 +17832,7 @@ async function computeFileChecksum(filePath) {
   return createHash3("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
-  return existsSync17(path5.join(root, name));
+  return existsSync18(path5.join(root, name));
 }
 function detectPackageManager(root) {
   if (lockfileExists(root, "pnpm-lock.yaml")) return "pnpm";
@@ -16633,7 +17876,7 @@ async function discoverLocalSource(sourcePath) {
 async function discoverReadme(root) {
   for (const name of ["README.md", "readme.md"]) {
     const p = path5.join(root, name);
-    if (existsSync17(p)) {
+    if (existsSync18(p)) {
       return p;
     }
   }
@@ -16643,7 +17886,7 @@ async function discoverAgentFiles(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md"]) {
     const p = path5.join(root, name);
-    if (existsSync17(p)) {
+    if (existsSync18(p)) {
       files.push(p);
     }
   }
@@ -16651,7 +17894,7 @@ async function discoverAgentFiles(root) {
 }
 async function discoverMerlleState(root) {
   const p = path5.join(root, ".pourkit", "state.json");
-  return existsSync17(p) ? p : null;
+  return existsSync18(p) ? p : null;
 }
 async function discoverAgentSkills(root) {
   const dirs = [
@@ -16660,7 +17903,7 @@ async function discoverAgentSkills(root) {
   ];
   const found = [];
   for (const d of dirs) {
-    if (existsSync17(d)) {
+    if (existsSync18(d)) {
       found.push(d);
     }
   }
@@ -16670,12 +17913,12 @@ async function discoverRootDomainDocs(root) {
   const docs = [];
   for (const name of ["CONTEXT.md", "CONTEXT-MAP.md"]) {
     const p = path5.join(root, name);
-    if (existsSync17(p)) {
+    if (existsSync18(p)) {
       docs.push(p);
     }
   }
   const adrDir = path5.join(root, "docs", "adr");
-  if (existsSync17(adrDir)) {
+  if (existsSync18(adrDir)) {
     const entries = await readdir(adrDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -16818,7 +18061,7 @@ async function planInit(options) {
       for (const file of skillFiles) {
         const relPath = path5.relative(s, file);
         const destPath = path5.join(targetRoot, ".agents", "skills", relPath);
-        if (!existsSync17(destPath)) {
+        if (!existsSync18(destPath)) {
           operations.push({
             kind: "copy",
             sourcePath: file,
@@ -16881,7 +18124,7 @@ async function planInit(options) {
     });
   }
   if (sourceRoot) {
-    if (!existsSync17(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
+    if (!existsSync18(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
       warnings.push(
         `--from-local path does not exist or is not a directory: ${sourceRoot}`
       );
@@ -17000,7 +18243,7 @@ async function planInit(options) {
             requiresConfirmation: false,
             destructive: false
           });
-        } else if (existsSync17(destPath)) {
+        } else if (existsSync18(destPath)) {
           operations.push({
             kind: "skip",
             path: destPath,
@@ -17058,7 +18301,7 @@ async function planInit(options) {
         }
       }
       const contextPath = path5.join(targetRoot, ".pourkit", "CONTEXT.md");
-      if (!existsSync17(contextPath) && !merleDestPaths.has(contextPath)) {
+      if (!existsSync18(contextPath) && !merleDestPaths.has(contextPath)) {
         operations.push({
           kind: "create",
           path: contextPath,
@@ -17076,7 +18319,7 @@ async function planInit(options) {
         "adr",
         ".gitkeep"
       );
-      if (!existsSync17(adrGitkeep)) {
+      if (!existsSync18(adrGitkeep)) {
         operations.push({
           kind: "create",
           path: adrGitkeep,
@@ -17088,7 +18331,7 @@ async function planInit(options) {
       }
       const srcDocAgents = path5.join(sourceRoot, ".pourkit", "docs", "agents");
       const tgtDocAgents = path5.join(targetRoot, ".pourkit", "docs", "agents");
-      if (existsSync17(srcDocAgents) && !existsSync17(tgtDocAgents)) {
+      if (existsSync18(srcDocAgents) && !existsSync18(tgtDocAgents)) {
         const docFiles = await walkDir(srcDocAgents);
         for (const file of docFiles) {
           const relPath = path5.relative(srcDocAgents, file);
@@ -17121,7 +18364,7 @@ async function planInit(options) {
       }
       const srcPrompts = path5.join(sourceRoot, ".pourkit", "prompts");
       const tgtPrompts = path5.join(targetRoot, ".pourkit", "prompts");
-      if (existsSync17(srcPrompts) && !existsSync17(tgtPrompts)) {
+      if (existsSync18(srcPrompts) && !existsSync18(tgtPrompts)) {
         const promptFiles = await walkDir(srcPrompts);
         for (const file of promptFiles) {
           const relPath = path5.relative(srcPrompts, file);
@@ -17148,7 +18391,7 @@ async function planInit(options) {
         ".sandcastle",
         "Dockerfile"
       );
-      if (existsSync17(tgtSandboxDockerfile)) {
+      if (existsSync18(tgtSandboxDockerfile)) {
         operations.push({
           kind: "skip",
           path: tgtSandboxDockerfile,
@@ -17157,7 +18400,7 @@ async function planInit(options) {
           requiresConfirmation: false,
           destructive: false
         });
-      } else if (existsSync17(srcSandboxDockerfile)) {
+      } else if (existsSync18(srcSandboxDockerfile)) {
         const checksum = await computeFileChecksum(srcSandboxDockerfile);
         operations.push({
           kind: "copy",
@@ -17171,7 +18414,7 @@ async function planInit(options) {
         });
       }
       const configTsPath = path5.join(targetRoot, "pourkit.config.ts");
-      if (!existsSync17(configTsPath)) {
+      if (!existsSync18(configTsPath)) {
         const verifyCommands = inferVerificationCommands(
           packageScripts,
           pm || "npm"
@@ -17208,7 +18451,7 @@ async function planInit(options) {
       const hasExistingAgents = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("AGENTS.md")
       );
-      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync17(path5.join(targetRoot, "AGENTS.md"))) {
+      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync18(path5.join(targetRoot, "AGENTS.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "AGENTS.md"),
@@ -17224,7 +18467,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       const hasExistingClaude = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("CLAUDE.md")
       );
-      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync17(path5.join(targetRoot, "CLAUDE.md"))) {
+      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync18(path5.join(targetRoot, "CLAUDE.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "CLAUDE.md"),
@@ -17239,7 +18482,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       }
       const gitignoreTarget = path5.join(targetRoot, ".gitignore");
       const gitignoreContent = generateGitignoreBlock();
-      if (!existsSync17(gitignoreTarget)) {
+      if (!existsSync18(gitignoreTarget)) {
         operations.push({
           kind: "create",
           path: gitignoreTarget,
@@ -17263,7 +18506,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         });
       }
       const openCodePath = path5.join(targetRoot, "opencode.json");
-      if (!existsSync17(openCodePath)) {
+      if (!existsSync18(openCodePath)) {
         operations.push({
           kind: "create",
           path: openCodePath,
@@ -17320,7 +18563,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         }
       }
       const manifestPath = path5.join(targetRoot, ".pourkit", "manifest.json");
-      if (existsSync17(manifestPath)) {
+      if (existsSync18(manifestPath)) {
         operations.push({
           kind: "skip",
           path: manifestPath,
@@ -17639,7 +18882,7 @@ async function updateManagedBlock(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync17(filePath)) {
+  if (!existsSync18(filePath)) {
     const dir = path5.dirname(filePath);
     await mkdir5(dir, { recursive: true });
     await writeFileAtomic(filePath, blockContent);
@@ -17668,7 +18911,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     if (op.requiresConfirmation) continue;
     const relPath = path5.relative(plan.targetRoot, op.path);
     if (relPath === ".pourkit/manifest.json") continue;
-    if (existsSync17(op.path)) {
+    if (existsSync18(op.path)) {
       const sha256 = await computeFileChecksum(op.path);
       assets[relPath] = {
         ownership: op.ownership || "managed",
@@ -17713,7 +18956,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync17(op.path) && !op.destructive) {
+          if (existsSync18(op.path) && !op.destructive) {
             skipped++;
             continue;
           }
@@ -17728,7 +18971,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync17(op.path)) {
+          if (existsSync18(op.path)) {
             skipped++;
             continue;
           }
@@ -17757,7 +19000,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync17(op.path)) {
+          if (existsSync18(op.path)) {
             skipped++;
             continue;
           }
@@ -17897,7 +19140,7 @@ async function applyInitFromSource(options) {
     if (!manifestSkipped) {
       const agentFiles = [];
       for (const name of ["AGENTS.md", "CLAUDE.md"]) {
-        if (existsSync17(path5.join(targetRoot, name))) {
+        if (existsSync18(path5.join(targetRoot, name))) {
           agentFiles.push(path5.join(targetRoot, name));
         }
       }
@@ -18716,8 +19959,8 @@ function formatChecks2(checks) {
 init_common();
 
 // execution/sandcastle-execution.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync7 } from "fs";
-import { join as join21 } 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";
 
@@ -18726,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 join20 } from "path";
+import { dirname as dirname6, join as join22 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join20(worktreePath, artifact.path);
+    const filePath = join22(worktreePath, artifact.path);
     await ensureDir(dirname6(filePath));
     await writeFile3(filePath, artifact.content, "utf-8");
   }
@@ -18741,17 +19984,17 @@ import path7 from "path";
 
 // execution/sandbox-image.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync18, readFileSync as readFileSync16 } 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";
   const sanitized = dirName.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
   const baseName = sanitized || "local";
   const dockerfilePath = path6.join(repoRoot2, ".sandcastle", "Dockerfile");
-  if (!existsSync18(dockerfilePath)) {
+  if (!existsSync19(dockerfilePath)) {
     return `sandcastle:${baseName}`;
   }
-  const fingerprint = createHash4("sha256").update(readFileSync16(dockerfilePath)).digest("hex").slice(0, 8);
+  const fingerprint = createHash4("sha256").update(readFileSync18(dockerfilePath)).digest("hex").slice(0, 8);
   return `sandcastle:${baseName}-${fingerprint}`;
 }
 
@@ -18901,11 +20144,7 @@ var SandcastleExecutionSession = class {
           type: "file",
           path: logPath,
           onAgentStreamEvent: (event) => {
-            if (event.type === "text") {
-              logger.raw(event.message);
-            } else if (event.type === "toolCall") {
-              logger.raw(`${event.name}(${event.formattedArgs})`);
-            }
+            logger.raw(formatAgentStreamEvent(event));
           }
         },
         completionSignal: "<promise>COMPLETE</promise>",
@@ -18990,14 +20229,74 @@ function resolveSandboxProvider(provider, dockerFactory) {
 function sanitizeBranch(branchName) {
   return branchName.replace(/[^A-Za-z0-9._-]/g, "-");
 }
+function formatAgentStreamEvent(event) {
+  if (event.type === "text") {
+    return JSON.stringify({ type: "text", textCount: event.message.length });
+  }
+  const parsedArgs = parseToolCallArgs(event.formattedArgs);
+  if (!parsedArgs.ok) {
+    return JSON.stringify({
+      type: "toolCall",
+      name: event.name,
+      argsTextCount: event.formattedArgs.length
+    });
+  }
+  return JSON.stringify({
+    type: "toolCall",
+    name: event.name,
+    args: summarizeToolCallArgs(event.name, parsedArgs.value)
+  });
+}
+function parseToolCallArgs(formattedArgs) {
+  try {
+    return { ok: true, value: JSON.parse(formattedArgs) };
+  } catch {
+    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;
+  }
+  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)) {
+    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;
+  }
+  return summarizedArgs;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join21(repoRoot2, ".pourkit", ".tmp", "prompts");
-  mkdirSync11(promptsDir, { recursive: true });
+  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 = join21(promptsDir, filename);
-  writeFileSync7(filePath, prompt, "utf-8");
+  const filePath = join23(promptsDir, filename);
+  writeFileSync9(filePath, prompt, "utf-8");
 }
 
 // cli.ts
@@ -19066,6 +20365,35 @@ function createCliProgram(version) {
   const program = new Command();
   program.name("pourkit").version(version).exitOverride().description("AI-driven issue-to-PR workflow for GitHub repositories.");
   const issueCommand = program.command("issue");
+  program.command("run-verification").description("Run configured verification commands for a target").option("--target <name>", "target name").option("--cwd <path>", "target repository directory").action(async (options) => {
+    const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
+    const logPath = path8.join(
+      targetRepoRoot,
+      ".pourkit",
+      "logs",
+      "run-verification.log"
+    );
+    const logger = createLogger("pourkit", logPath);
+    let failed = false;
+    try {
+      const config = await loadRepoConfig(targetRepoRoot);
+      const target = resolveTarget(config, options.target);
+      const result = await runVerificationCommands({
+        target,
+        cwd: targetRepoRoot,
+        logger
+      });
+      console.log(JSON.stringify(result, null, 2));
+      failed = !result.ok;
+    } catch (error) {
+      await handleError(logger, error);
+    } finally {
+      await logger.close();
+    }
+    if (failed) {
+      process.exit(1);
+    }
+  });
   program.command("validate-artifact").description("Validate an agent handoff artifact").argument(
     "<kind>",
     "artifact kind: reviewer, refactor, finalizer, conflict-resolution, failure-resolution, reconciliation, planning-manifest, local-prd, local-issue, local-triage, or local-prepare"
@@ -19841,11 +21169,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260607223610")) {
-    return "0.0.0-next-20260607223610";
+  if (isPackageVersion("0.0.0-next-20260608221925")) {
+    return "0.0.0-next-20260608221925";
   }
-  if (isReleaseVersion("0.0.0-next-20260607223610")) {
-    return "0.0.0-next-20260607223610";
+  if (isReleaseVersion("0.0.0-next-20260608221925")) {
+    return "0.0.0-next-20260608221925";
   }
   try {
     const root = repoRoot();