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

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,24 @@ 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" };
+  }
+  const configMode = target.strategy.prdRun?.mode;
+  if (configMode) {
+    return { mode: configMode, source: "target-config" };
+  }
+  return { mode: "github", source: "default" };
+}
 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 +1155,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 +1352,7 @@ function buildRunContextMarkdown(options) {
   if (sections.includes("verification-commands")) {
     parts.push(
       ...renderCommandList(
+        target,
         getVerificationCommands(target),
         "Verification Commands"
       )
@@ -1289,13 +1374,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 +2177,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 +2713,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 +4977,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 +5679,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 +5951,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,6 +6152,293 @@ function persistGeneratedArtifactEffect(worktreePath, output, fs) {
   });
 }
 
+// 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";
+
+// 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 };
+}
+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 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(),
+        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 });
+}
+
+// prd-run/local-merge-coordinator.ts
+function getLocalStorePath(repoRoot2, prdId) {
+  return join13(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+}
+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;
+  }
+}
+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
@@ -6786,44 +7171,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 +7284,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 +7832,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 +7860,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 +8303,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,
+  readFileSync as readFileSync16,
   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 { dirname as dirname5, join as join20, 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({
@@ -7946,12 +8469,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 +8488,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 +8498,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 +8514,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 +8554,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 +8563,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 +8576,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 +8718,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 +8729,7 @@ function parseFinalReviewArtifact(artifactPath) {
   }
   let content;
   try {
-    content = readFileSync13(artifactPath, "utf-8");
+    content = readFileSync14(artifactPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -8386,8 +8909,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 +8943,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 +8962,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 +9007,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 +9143,14 @@ 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 };
-}
-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 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(),
-        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 });
-}
-
-// prd-run/local-final-review.ts
-function getLocalStorePath2(repoRoot2, prdId) {
-  return join16(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+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 getFinalReviewReceiptPath(repoRoot2, prdId) {
-  return join16(getLocalStorePath2(repoRoot2, prdId), "final-review-receipt.json");
+  return join17(getLocalStorePath3(repoRoot2, prdId), "final-review-receipt.json");
 }
 async function runLocalFinalReview(prdId, options) {
   const root = options?.repoRoot ?? process.cwd();
@@ -8767,8 +9207,8 @@ async function runLocalFinalReview(prdId, options) {
     branch
   };
   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 +9222,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 +9235,7 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
     return;
   }
   try {
-    execFileSync2(
+    execFileSync3(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
       {
@@ -8808,18 +9248,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 +9267,7 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
       return;
     } catch {
     }
-    execFileSync2(
+    execFileSync3(
       "git",
       ["commit", "-m", `Squash merge ${retouchBranch} into ${targetBranch}`],
       {
@@ -8846,53 +9286,53 @@ async function squashFinalReviewRetouch(prdId, repoRoot2) {
 }
 
 // prd-run/local-reconciliation.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync14,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync5,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { join as join17 } from "path";
-function getLocalStorePath3(repoRoot2, prdId) {
-  return join17(repoRoot2, ".pourkit", "local-prd-runs", prdId);
+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`);
+  return join18(repoRoot2, ".pourkit", ".tmp", "reconciliation", `${prdId}.json`);
 }
 function getCompletionsDir(repoRoot2, prdId) {
-  const initiativesRoot = join17(
+  const initiativesRoot = join18(
     repoRoot2,
     ".pourkit",
     "architecture",
     "initiatives"
   );
-  if (existsSync14(initiativesRoot)) {
-    const dirs = readdirSync5(initiativesRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join17(initiativesRoot, e.name));
+  if (existsSync15(initiativesRoot)) {
+    const dirs = readdirSync5(initiativesRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join18(initiativesRoot, e.name));
     for (const dir of dirs) {
-      const prdsDir = join17(dir, "prds");
-      if (!existsSync14(prdsDir)) continue;
+      const prdsDir = join18(dir, "prds");
+      if (!existsSync15(prdsDir)) continue;
       const prdDirs = readdirSync5(prdsDir, { withFileTypes: true }).filter(
         (e) => e.isDirectory() && e.name.startsWith(prdId.toLowerCase())
       );
-      if (prdDirs.length > 0) return join17(dir, "completions");
+      if (prdDirs.length > 0) return join18(dir, "completions");
     }
   }
-  return join17(getLocalStorePath3(repoRoot2, prdId), "completions");
+  return join18(getLocalStorePath4(repoRoot2, prdId), "completions");
 }
 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 +9340,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 +9356,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 {
@@ -8942,11 +9382,11 @@ async function runLocalReconciliation(prdId, options) {
   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")) : [];
+      mkdirSync10(completionsDir, { recursive: true });
+      const existing = existsSync15(completionsDir) ? readdirSync5(completionsDir).filter((f) => f.endsWith(".md")) : [];
       const nextNum = String(existing.length + 1).padStart(3, "0");
       const filename = `${nextNum}-prd-${prdId.replace("PRD-", "").toLowerCase()}-reconciliation-completion.md`;
-      const filepath = join17(completionsDir, filename);
+      const filepath = join18(completionsDir, filename);
       const changedPaths = Array.isArray(handoff.changedPlanningPaths) ? handoff.changedPlanningPaths : [];
       const summary = typeof handoff.summary === "string" ? handoff.summary : "";
       const lines = [
@@ -8962,13 +9402,13 @@ async function runLocalReconciliation(prdId, options) {
         lines.push("- (none)");
       }
       lines.push("");
-      writeFileSync6(filepath, lines.join("\n"), "utf-8");
-      execFileSync3("git", ["add", filepath], {
+      writeFileSync7(filepath, lines.join("\n"), "utf-8");
+      execFileSync4("git", ["add", filepath], {
         cwd: root,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execFileSync3(
+      execFileSync4(
         "git",
         ["commit", "-m", `docs: ${prdId} reconciliation completion`],
         { cwd: root, encoding: "utf8", stdio: "pipe" }
@@ -8985,7 +9425,7 @@ async function runLocalReconciliation(prdId, options) {
     try {
       const targetBranch = getLocalPrdBranchName(prdId);
       try {
-        execFileSync3(
+        execFileSync4(
           "git",
           ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
           { cwd: root, encoding: "utf8", stdio: "pipe" }
@@ -8997,14 +9437,14 @@ async function runLocalReconciliation(prdId, options) {
           message: "Squash merge into local PRD Branch failed."
         };
       }
-      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}`],
           {
@@ -9020,19 +9460,19 @@ async function runLocalReconciliation(prdId, options) {
           message: "Squash merge into local PRD Branch failed."
         };
       }
-      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" }
@@ -9051,8 +9491,8 @@ async function runLocalReconciliation(prdId, options) {
     reconciledAt: (/* @__PURE__ */ new Date()).toISOString(),
     branch
   };
-  mkdirSync9(getLocalStorePath3(root, prdId), { recursive: true });
-  writeFileSync6(
+  mkdirSync10(getLocalStorePath4(root, prdId), { recursive: true });
+  writeFileSync7(
     getReconciliationReceiptPath(root, prdId),
     JSON.stringify(receipt, null, 2),
     "utf-8"
@@ -9061,8 +9501,8 @@ async function runLocalReconciliation(prdId, options) {
 }
 
 // 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 +9520,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",
@@ -9507,6 +9947,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 +9959,8 @@ function runOneQueueIssueEffect(options) {
         force,
         logger,
         repoRoot: repoRoot2,
-        ...baseBranchOverride ? { baseBranchOverride } : {}
+        ...baseBranchOverride ? { baseBranchOverride } : {},
+        ...prdRunMode ? { prdRunMode } : {}
       }),
       catch: (e) => {
         if (e instanceof Error) return e;
@@ -9529,6 +9971,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 +10034,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 +10164,7 @@ function validateChangedPlanningPaths(paths, options) {
       continue;
     }
     if (options?.repoRoot) {
-      const fullPath = join19(options.repoRoot, p);
+      const fullPath = join20(options.repoRoot, p);
       try {
         if (lstatSync(fullPath).isSymbolicLink()) {
           rejected.push(p);
@@ -9742,7 +10189,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 +10200,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."
     ]
   };
 }
@@ -9893,7 +10331,7 @@ function canRetryFinalReviewBlock(record) {
 }
 function loadFinalReviewPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  return existsSync16(promptPath) ? readFileSync15(promptPath, "utf-8") : promptTemplate;
+  return existsSync17(promptPath) ? readFileSync16(promptPath, "utf-8") : promptTemplate;
 }
 function formatVerificationCommands(commands) {
   if (commands.length === 0) return "No verification commands configured.";
@@ -9906,12 +10344,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 +10378,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 join20(repoRoot2, ".sandcastle", "worktrees", branchName);
 }
 function reconciliationReceiptWorktreePath(branchName) {
   return `.sandcastle/worktrees/${branchName}`;
@@ -9957,7 +10397,7 @@ function buildFinalReviewBranchName(prdRef) {
   return `pourkit/${normalizePrdRunRef2(prdRef).toLowerCase()}-final-review`;
 }
 function finalReviewWorktreePath(repoRoot2, branchName) {
-  return join19(
+  return join20(
     repoRoot2,
     ".sandcastle",
     "worktrees",
@@ -10012,7 +10452,7 @@ function buildFinalReviewFinalizerPrompt(options) {
     options.repoRoot,
     options.promptTemplate
   );
-  const promptBody = existsSync16(promptPath) ? readFileSync15(promptPath, "utf-8") : options.promptTemplate;
+  const promptBody = existsSync17(promptPath) ? readFileSync16(promptPath, "utf-8") : options.promptTemplate;
   return [
     "# Final Review Retouch PR Finalizer",
     "",
@@ -10046,7 +10486,7 @@ function buildFinalReviewFinalizerPrompt(options) {
 }
 async function runFinalReviewPrFinalizer(options) {
   const finalizer = options.target.strategy.finalize.prDescriptionAgent;
-  const artifactPathInWorktree = join19(
+  const artifactPathInWorktree = join20(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -10120,14 +10560,14 @@ 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 });
+  mkdirSync11(dirname5(worktreePath), { recursive: true });
   const branchResult = spawnSync2(
     "git",
     ["branch", "-f", options.branchName, `origin/${options.checkoutBase}`],
@@ -10182,7 +10622,7 @@ async function createOrReuseFinalReviewRetouchPr(options) {
   if (existingPr && existingPr.state === "OPEN") {
     return existingPr;
   }
-  const worktreePath = mkdtempSync(join19(tmpdir(), "pourkit-retouch-"));
+  const worktreePath = mkdtempSync(join20(tmpdir(), "pourkit-retouch-"));
   try {
     runGitOrThrow(
       options.repoRoot,
@@ -10200,9 +10640,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 = join20(options.sourceWorktreePath, changedFile);
+      const targetPath = join20(worktreePath, changedFile);
+      mkdirSync11(dirname5(targetPath), { recursive: true });
       cpSync(sourcePath, targetPath, { recursive: true });
     }
     runGitOrThrow(
@@ -10556,6 +10996,7 @@ async function runPrdRunFinalReviewCommand(options) {
       prompt: buildFinalReviewPrompt({
         repoRoot: options.repoRoot,
         promptTemplate: finalReviewConfig.promptTemplate,
+        targetName,
         evidencePacket,
         verificationCommands
       }),
@@ -10631,7 +11072,7 @@ async function runPrdRunFinalReviewCommand(options) {
     };
   }
   const resolvedWorktreePath = executionResult.worktreePath;
-  const artifactPath = join19(
+  const artifactPath = join20(
     resolvedWorktreePath,
     ".pourkit/final-review-artifact.json"
   );
@@ -11215,7 +11656,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 : join20(options.repoRoot, ".pourkit", "final-review-artifact.json");
   const artifact = parseFinalReviewArtifact(artifactPath);
   if (!artifact.ok) {
     return {
@@ -11523,7 +11964,7 @@ 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}`
@@ -11544,7 +11985,7 @@ async function runReconcilePreflightAndSetup(options) {
     );
     return { ok: false, diagnostics, branchAction: "blocked" };
   }
-  mkdirSync10(dirname5(worktreePath), { recursive: true });
+  mkdirSync11(dirname5(worktreePath), { recursive: true });
   const addResult = spawnSync2(
     "git",
     ["worktree", "add", worktreePath, reconciliationBranchName],
@@ -11599,7 +12040,7 @@ function buildReconciliationPrBody(options) {
 function commitAndPushReconciliationChanges(options) {
   const diagnostics = [];
   const existingPaths = options.changedPlanningPaths.filter((p) => {
-    return existsSync16(join19(options.worktreeCwd, p));
+    return existsSync17(join20(options.worktreeCwd, p));
   });
   if (existingPaths.length === 0) {
     diagnostics.push(
@@ -11742,7 +12183,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 ? join20(options.repoRoot, preflightResult.worktreePath) : options.repoRoot;
   const staleSucceededRecovery = assessStaleSucceededReconciliationReceipt({
     receipt: record?.reconciliation,
     worktreeCwd,
@@ -12044,7 +12485,7 @@ async function runPrdRunReconcileCommand(options) {
       baseRef: prdBranch,
       checkoutBase,
       reviewBase: mergeBase,
-      worktreePath: join19(options.repoRoot, preflightResult.worktreePath),
+      worktreePath: join20(options.repoRoot, preflightResult.worktreePath),
       sandbox: options.config.sandbox,
       artifactPath,
       logger: options.logger
@@ -12145,7 +12586,7 @@ async function runPrdRunReconcileCommand(options) {
       offendingPaths: []
     };
   }
-  const fullArtifactPath = join19(executionResult.worktreePath, artifactPath);
+  const fullArtifactPath = join20(executionResult.worktreePath, artifactPath);
   let artifactContent;
   try {
     artifactContent = JSON.parse(retryResult.artifact.value);
@@ -12267,11 +12708,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 +12749,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(", ")}`
@@ -13156,26 +13613,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 = join20(repoRoot2, PRD_047_PRD_MIRROR_PATH);
+  const completionsDir = join20(repoRoot2, dirname5(PRD_047_ESCAPE_HATCH_PATH));
   let escapeHatchPresent = false;
-  if (existsSync16(completionsDir)) {
+  if (existsSync17(completionsDir)) {
     const files = readdirSync6(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(join20(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 = readFileSync16(prdMirrorPath, "utf-8");
     const hasReconcileCommand = mirrorContent.includes("prd-run reconcile");
     const hasEscapeHatch = mirrorContent.includes("escape hatch");
     if (!hasReconcileCommand) {
@@ -13189,16 +13646,16 @@ function auditPrd047Implementation(repoRoot2, prdRef) {
       );
     }
   }
-  const childIssueDir = join19(repoRoot2, PRD_047_CHILD_ISSUE_DIR);
-  const childIssuesExist = existsSync16(childIssueDir);
+  const childIssueDir = join20(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 = join20(repoRoot2, PRD_047_MANIFEST_PATH);
+  if (existsSync17(manifestPath)) {
+    const manifestContent = readFileSync16(manifestPath, "utf-8");
     if (!manifestContent.includes("ready_for_prepare")) {
       nonBlockers.push(
         "Planning Artifact Manifest is not marked as ready_for_prepare."
@@ -13446,13 +13903,13 @@ async function runPrdRunLaunchCommand(options) {
   let finalReviewResult;
   if (!skipped.includes("final-review")) {
     attempted.push("final-review");
-    const localStorePath = join19(
+    const localStorePath = join20(
       options.repoRoot,
       ".pourkit",
       "local-prd-runs",
       prdRef
     );
-    if (existsSync16(localStorePath)) {
+    if (existsSync17(localStorePath)) {
       const targetConfig = options.config?.targets?.find(
         (t) => t.name === options.targetName
       );
@@ -14751,6 +15208,13 @@ 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;
+  }
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status: "running",
@@ -14760,8 +15224,8 @@ async function processStartResult(startResult, options) {
     manifestPath: existingRecord.record?.manifestPath,
     planning: existingRecord.record?.planning
   });
-  const localStorePath = join19(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
-  if (existsSync16(localStorePath)) {
+  const localStorePath = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
+  if (existsSync17(localStorePath)) {
     const localIssues = await getRunnableLocalIssues(prdRef, repoRoot2);
     start.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
     start.queueProcessedCount = localIssues.length;
@@ -14795,7 +15259,8 @@ async function processStartResult(startResult, options) {
       prdRef,
       queueRunContext: {
         prdRef,
-        prdBranch: start.prdBranch
+        prdBranch: start.prdBranch,
+        prdRunMode: resolvedMode
       }
     });
     if (outcome.selected === null && outcome.code === "drained") {
@@ -15340,7 +15805,7 @@ async function ensurePlanningBranchPublished(repoRoot2, branchName, changedFiles
   if (remoteResult.status !== 0) {
     return;
   }
-  const worktreePath = mkdtempSync(join19(tmpdir(), "pourkit-planning-"));
+  const worktreePath = mkdtempSync(join20(tmpdir(), "pourkit-planning-"));
   try {
     runGitOrThrow(repoRoot2, ["fetch", "origin", "dev"], "fetch origin/dev");
     runGitOrThrow(
@@ -15354,9 +15819,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 = join20(repoRoot2, changedFile);
+      const targetPath = join20(worktreePath, changedFile);
+      mkdirSync11(dirname5(targetPath), { recursive: true });
       cpSync(sourcePath, targetPath, { recursive: true });
     }
     runGitOrThrow(
@@ -15592,7 +16057,7 @@ function collectGitChangedFiles(repoRoot2, ignoredPrdRunRecordRef) {
     changedFiles: Array.from(new Set(changedFiles))
   };
 }
-function collectObservedReconciliationPlanningDiff(options) {
+function collectObservedReconciliationDirtyPaths(options) {
   const statusResult = spawnSync2("git", ["status", "--porcelain=v1", "-uall"], {
     cwd: options.worktreeCwd,
     encoding: "utf8"
@@ -15625,27 +16090,9 @@ 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) {
@@ -15670,7 +16117,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 +16533,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 +17036,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 +17080,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 +17090,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 +17098,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 +17107,7 @@ async function discoverAgentSkills(root) {
   ];
   const found = [];
   for (const d of dirs) {
-    if (existsSync17(d)) {
+    if (existsSync18(d)) {
       found.push(d);
     }
   }
@@ -16670,12 +17117,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 +17265,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 +17328,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 +17447,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 +17505,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 +17523,7 @@ async function planInit(options) {
         "adr",
         ".gitkeep"
       );
-      if (!existsSync17(adrGitkeep)) {
+      if (!existsSync18(adrGitkeep)) {
         operations.push({
           kind: "create",
           path: adrGitkeep,
@@ -17088,7 +17535,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 +17568,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 +17595,7 @@ async function planInit(options) {
         ".sandcastle",
         "Dockerfile"
       );
-      if (existsSync17(tgtSandboxDockerfile)) {
+      if (existsSync18(tgtSandboxDockerfile)) {
         operations.push({
           kind: "skip",
           path: tgtSandboxDockerfile,
@@ -17157,7 +17604,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 +17618,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 +17655,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 +17671,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 +17686,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 +17710,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 +17767,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 +18086,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 +18115,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 +18160,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync17(op.path) && !op.destructive) {
+          if (existsSync18(op.path) && !op.destructive) {
             skipped++;
             continue;
           }
@@ -17728,7 +18175,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync17(op.path)) {
+          if (existsSync18(op.path)) {
             skipped++;
             continue;
           }
@@ -17757,7 +18204,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync17(op.path)) {
+          if (existsSync18(op.path)) {
             skipped++;
             continue;
           }
@@ -17897,7 +18344,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 +19163,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 writeFileSync8 } from "fs";
+import { join as join22 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
@@ -18726,10 +19173,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 join21 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join20(worktreePath, artifact.path);
+    const filePath = join21(worktreePath, artifact.path);
     await ensureDir(dirname6(filePath));
     await writeFile3(filePath, artifact.content, "utf-8");
   }
@@ -18741,17 +19188,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 readFileSync17 } 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(readFileSync17(dockerfilePath)).digest("hex").slice(0, 8);
   return `sandcastle:${baseName}-${fingerprint}`;
 }
 
@@ -18901,11 +19348,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 +19433,59 @@ 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 };
+  }
+}
+function summarizeToolCallArgs(name, args) {
+  if (!isPlainObject(args)) {
+    return args;
+  }
+  if (name.toLowerCase() !== "write") {
+    return args;
+  }
+  const summarizedArgs = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (key === "content" && typeof value === "string") {
+      summarizedArgs.contentCount = 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 = join22(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 = join22(promptsDir, filename);
+  writeFileSync8(filePath, prompt, "utf-8");
 }
 
 // cli.ts
@@ -19066,6 +19554,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 +20358,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-20260608072322")) {
+    return "0.0.0-next-20260608072322";
   }
-  if (isReleaseVersion("0.0.0-next-20260607223610")) {
-    return "0.0.0-next-20260607223610";
+  if (isReleaseVersion("0.0.0-next-20260608072322")) {
+    return "0.0.0-next-20260608072322";
   }
   try {
     const root = repoRoot();