@pourkit/cli 0.0.0-next-20260625073725 → 0.0.0-next-20260627024509

package/dist/cli.js

@@ -58,20 +58,20 @@ function createLogger(name, filePath) {
       );
     },
     async close() {
-      await new Promise((resolve5) => {
+      await new Promise((resolve6) => {
         if (!fileStream) {
-          resolve5();
+          resolve6();
           return;
         }
         const timer = setTimeout(() => {
           if (!fileStream.destroyed) {
             fileStream.destroy();
           }
-          resolve5();
+          resolve6();
         }, 2e3);
         fileStream.end(() => {
           clearTimeout(timer);
-          resolve5();
+          resolve6();
         });
       });
     }
@@ -266,7 +266,7 @@ async function execJson(command, args, options = {}) {
   return JSON.parse(result.stdout);
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function execCaptureWithRetry(command, args, options = {}) {
   const retries = options.retries ?? 3;
@@ -914,8 +914,8 @@ async function loadRepoConfig(repoRoot2, _configFileName) {
       `No Pourkit config found at ${CANONICAL_CONFIG_PATH}. Run pourkit init or create ${CANONICAL_CONFIG_PATH} with "$schema": "./schema/pourkit.schema.json".`
     );
   }
-  const { readFile: readFile7 } = await import("fs/promises");
-  const raw = await readFile7(configPath, "utf-8");
+  const { readFile: readFile8 } = await import("fs/promises");
+  const raw = await readFile8(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -926,10 +926,10 @@ async function loadRepoConfig(repoRoot2, _configFileName) {
   return parseConfig(parsed);
 }
 async function loadConfig(configPath) {
-  const { readFile: readFile7 } = await import("fs/promises");
+  const { readFile: readFile8 } = await import("fs/promises");
   const ext = configPath.split(".").pop()?.toLowerCase();
   if (ext === "json") {
-    const raw = await readFile7(configPath, "utf-8");
+    const raw = await readFile8(configPath, "utf-8");
     return parseConfig(JSON.parse(raw));
   }
   if (ext === "mjs" || ext === "js" || ext === "ts") {
@@ -1086,10 +1086,10 @@ async function removeStaleWorktree(candidate, repoRoot2, logger) {
   }
 }
 async function removeExpiredFiles(dirPath, retentionDays) {
-  const { readdir: readdir4, stat, unlink, access: access2 } = await import("fs/promises");
+  const { readdir: readdir5, stat, unlink, access: access2 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir4(dirPath);
+    entries = await readdir5(dirPath);
   } catch {
     return;
   }
@@ -1152,8 +1152,8 @@ async function cleanupRepository(options) {
 
 // commands/artifact-validation.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
+import { isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "path";
 
 // pr/review-verdict.ts
 var ReviewVerdictProtocolError = class extends Error {
@@ -3237,6 +3237,13 @@ var ISSUE_FINAL_REVIEW_SCOPE_VERDICTS = [
   "incidental",
   "out-of-scope"
 ];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeChildRef(value) {
+  const match = value.match(/^I-0*(\d+)$/i);
+  return match ? `I-${match[1].padStart(2, "0")}` : value.toUpperCase();
+}
 function invalid(options, reason, diagnostics = []) {
   return {
     ok: false,
@@ -3586,11 +3593,177 @@ function validateIssueFinalReviewArtifact(parsed, options) {
   }
   return { ok: true, verdict: parsed.verdict };
 }
+function validatePrdPlanWorkspace(options) {
+  const workspacePath = options.workspace || options.artifactPath;
+  const prdRef = options.prdRef;
+  if (!prdRef) {
+    return invalid(options, "PRD plan workspace validation requires --prd-ref");
+  }
+  const diagnostics = [];
+  const prdPath = join7(workspacePath, "PRD.md");
+  if (!existsSync7(prdPath)) {
+    return invalid(options, `PRD plan workspace missing PRD.md at ${prdPath}`);
+  }
+  let prdContent;
+  try {
+    prdContent = readFileSync7(prdPath, "utf-8");
+  } catch {
+    return invalid(options, `Cannot read PRD.md at ${prdPath}`);
+  }
+  const prdFirstLine = prdContent.split("\n")[0];
+  const prdHeadingMatch = prdFirstLine.match(/^# (PRD-\d{4}):.*$/i);
+  if (!prdFirstLine.startsWith("# ") || !prdHeadingMatch) {
+    return invalid(
+      options,
+      "PRD.md must start with a heading: # PRD-NNNN: Title"
+    );
+  }
+  if (prdHeadingMatch[1].toUpperCase() !== prdRef.toUpperCase()) {
+    return invalid(
+      options,
+      `PRD.md heading ${prdHeadingMatch[1].toUpperCase()} does not match --prd-ref ${prdRef}`
+    );
+  }
+  diagnostics.push(`PRD title: ${prdFirstLine.slice(2).trim()}`);
+  const issuesDir = join7(workspacePath, "issues");
+  if (!existsSync7(issuesDir)) {
+    return invalid(
+      options,
+      `PRD plan workspace missing issues/ directory at ${issuesDir}`
+    );
+  }
+  let childFiles;
+  const CHILD_FILE_PATTERN2 = /^I-0*(\d+)-.+\.md$/i;
+  try {
+    childFiles = readdirSync3(issuesDir).filter(
+      (f) => CHILD_FILE_PATTERN2.test(f) && !f.startsWith(".")
+    );
+  } catch {
+    return invalid(options, `Cannot read issues/ directory at ${issuesDir}`);
+  }
+  childFiles.sort((a, b) => {
+    const aMatch = a.match(CHILD_FILE_PATTERN2);
+    const bMatch = b.match(CHILD_FILE_PATTERN2);
+    if (!aMatch || !bMatch) return 0;
+    return Number(aMatch[1]) - Number(bMatch[1]);
+  });
+  if (childFiles.length === 0) {
+    return invalid(
+      options,
+      `PRD plan workspace must contain at least one issues/I-0N-*.md child Issue`
+    );
+  }
+  const children = [];
+  const CHILD_REF_PATTERN2 = /^\s*(I-0*\d+)\s*$/i;
+  const BLOCKED_BY_SECTION_REGEX2 = /## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i;
+  const PARENT_SECTION_REGEX2 = /## Parent\s*\n([\s\S]*?)(?=\n## |$)/i;
+  for (const childFile of childFiles) {
+    const childPath = join7(issuesDir, childFile);
+    let childContent;
+    try {
+      childContent = readFileSync7(childPath, "utf-8");
+    } catch {
+      diagnostics.push(`${childFile}: cannot read`);
+      continue;
+    }
+    const childFileMatch = childFile.match(CHILD_FILE_PATTERN2);
+    if (!childFileMatch) continue;
+    const childRef = `I-${childFileMatch[1].padStart(2, "0")}`;
+    const firstChildLine = childContent.split("\n")[0];
+    if (!firstChildLine.startsWith("# ") || !new RegExp(`^# ${prdRef} / ${childRef}:`).test(firstChildLine)) {
+      return invalid(
+        options,
+        `${childFile}: expected heading: # ${prdRef} / ${childRef}: Title`
+      );
+    }
+    const parentSection = childContent.match(PARENT_SECTION_REGEX2)?.[1];
+    const parentPrdRegex = new RegExp(`\\b${escapeRegExp(prdRef)}\\b`, "i");
+    if (!parentSection || !parentPrdRegex.test(parentSection)) {
+      return invalid(
+        options,
+        `${childFile}: missing ## Parent section pointing to ${prdRef}`
+      );
+    }
+    const section = childContent.match(BLOCKED_BY_SECTION_REGEX2)?.[1];
+    const blockedByRefs = [];
+    if (section) {
+      for (const rawLine of section.split("\n")) {
+        const line = rawLine.trim();
+        if (!line) continue;
+        for (const part of line.split(",")) {
+          const trimmed = part.trim();
+          const match = trimmed.match(CHILD_REF_PATTERN2);
+          if (match) {
+            blockedByRefs.push(match[1].toUpperCase());
+          }
+        }
+      }
+    }
+    children.push({ childRef, blockedByRefs, sourcePath: childFile });
+    diagnostics.push(`${childFile}: ${childRef}`);
+  }
+  const validChildRefs = new Set(children.map((c) => c.childRef));
+  for (const child of children) {
+    for (const blockedRef of child.blockedByRefs) {
+      if (!validChildRefs.has(blockedRef.toUpperCase())) {
+        return invalid(
+          options,
+          `Child ${child.childRef} references nonexistent child ${blockedRef} in Blocked by section`,
+          [child.sourcePath]
+        );
+      }
+    }
+  }
+  diagnostics.push(`children: ${children.length} total`);
+  return valid(options, diagnostics);
+}
+function validatePrdPlan(content, options) {
+  const firstLine = content.split("\n")[0];
+  if (!firstLine.startsWith("# ") || !/^# PRD-\d{4}:/.test(firstLine)) {
+    return invalid(
+      options,
+      "PRD plan must start with a heading: # PRD-NNNN: Title"
+    );
+  }
+  const title = firstLine.slice(2).trim();
+  return valid(options, [`title: ${title}`]);
+}
+function validatePrdChildIssue(content, options) {
+  const firstLine = content.split("\n")[0];
+  const match = firstLine.match(/^# (PRD-\d{4}) \/ (I-\d+):/);
+  if (!firstLine.startsWith("# ") || !match) {
+    return invalid(
+      options,
+      "Child issue must start with a heading: # PRD-NNNN / I-0N: Title"
+    );
+  }
+  if (options.childId) {
+    const normalizedHeadingChildId = normalizeChildRef(match[2]);
+    const normalizedChildId = normalizeChildRef(options.childId);
+    if (normalizedHeadingChildId !== normalizedChildId) {
+      return invalid(
+        options,
+        `Child issue heading ${normalizedHeadingChildId} does not match --child-id ${normalizedChildId}`
+      );
+    }
+  }
+  const title = firstLine.slice(2).trim();
+  return valid(options, [`title: ${title}`]);
+}
 function validateAgentArtifact(options) {
+  if (options.kind === "prd-plan-workspace") {
+    return validatePrdPlanWorkspace(options);
+  }
   const artifact = readArtifact(options);
   if (!artifact.ok) return artifact.result;
   try {
     switch (options.kind) {
+      case "prd-plan": {
+        return validatePrdPlan(artifact.content, options);
+      }
+      case "prd-child-issue": {
+        return validatePrdChildIssue(artifact.content, options);
+      }
       case "reviewer": {
         const iteration = options.iteration ?? 1;
         const verdict = parseReviewVerdict(artifact.content);
@@ -3697,10 +3870,12 @@ function validateAgentArtifact(options) {
 function runValidateArtifactCommand(options) {
   const artifactPath = resolve2(options.repoRoot, options.artifactPath);
   const latestReviewArtifactPath = options.latestReviewArtifactPath ? resolve2(options.repoRoot, options.latestReviewArtifactPath) : void 0;
+  const workspace = options.workspace ? resolve2(options.repoRoot, options.workspace) : void 0;
   return validateAgentArtifact({
     ...options,
     artifactPath,
     latestReviewArtifactPath,
+    workspace,
     worktreePath: options.repoRoot,
     baseRef: options.baseRef
   });
@@ -3878,15 +4053,15 @@ function invalidateAfterBaseRefresh(state) {
 
 // shared/attempt-log.ts
 import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname4, join as join8 } from "path";
 var ATTEMPT_LOG_PATH = ".pourkit/attempt-log.jsonl";
 function writeAttemptLog(worktreePath, entry) {
-  const logPath = join7(worktreePath, ATTEMPT_LOG_PATH);
+  const logPath = join8(worktreePath, ATTEMPT_LOG_PATH);
   mkdirSync6(dirname4(logPath), { recursive: true });
   appendFileSync(logPath, JSON.stringify(entry) + "\n", "utf-8");
 }
 function readAttemptLog(worktreePath) {
-  const logPath = join7(worktreePath, ATTEMPT_LOG_PATH);
+  const logPath = join8(worktreePath, ATTEMPT_LOG_PATH);
   if (!existsSync8(logPath)) {
     return [];
   }
@@ -4010,12 +4185,12 @@ async function runBaseRefreshAttempt(options) {
 
 // commands/conflict-resolution.ts
 import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 init_common();
 var CONFLICT_MARKER_PATTERN2 = /<<<<<<<|=======|>>>>>>>/m;
 async function hasUnresolvedConflictMarkers(worktreePath, files) {
   for (const file of files) {
-    const filePath = join8(worktreePath, file);
+    const filePath = join9(worktreePath, file);
     try {
       const content = readFileSync9(filePath, "utf-8");
       if (CONFLICT_MARKER_PATTERN2.test(content)) {
@@ -4029,7 +4204,7 @@ async function hasUnresolvedConflictMarkers(worktreePath, files) {
 
 // failure-resolution/failure-resolution-agent.ts
 import { readFileSync as readFileSync10 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // failure-resolution/recovery-policy.ts
 function isSecuritySensitiveFailure(failure) {
@@ -4105,7 +4280,7 @@ async function runFailureResolutionAgent(options) {
   } = options;
   const frConfig = target.strategy.failureResolution;
   const artifactPath = packet.artifactTarget;
-  const fullArtifactPath = join9(worktreePath, artifactPath);
+  const fullArtifactPath = join10(worktreePath, artifactPath);
   const fingerprint = computeFailureFingerprint(packet.stageName, failure._tag);
   const prompt = [
     `# Failure Resolution: ${packet.failureType}`,
@@ -4731,7 +4906,7 @@ async function canReachMcp(url) {
       return true;
     } catch {
       if (attempt < 9) {
-        await new Promise((resolve5) => setTimeout(resolve5, 100));
+        await new Promise((resolve6) => setTimeout(resolve6, 100));
       }
     }
   }
@@ -4958,11 +5133,11 @@ async function assertCanonicalBaseAncestor(options) {
 
 // issues/pr-description-agent.ts
 import { existsSync as existsSync12, readFileSync as readFileSync13 } from "fs";
-import { isAbsolute as isAbsolute4, join as join12 } from "path";
+import { isAbsolute as isAbsolute4, join as join13 } from "path";
 
 // pr/pr-description-context.ts
 init_common();
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { readFile } from "fs/promises";
 import { Effect as Effect6 } from "effect";
 function collectFinalizerContextEffect(options) {
@@ -5027,7 +5202,7 @@ function remoteTargetBase(targetBase) {
   return targetBase.includes("/") ? targetBase : `origin/${targetBase}`;
 }
 function buildFinalizerPrompt(context, promptTemplate) {
-  const artifactPathInWorktree = join10(
+  const artifactPathInWorktree = join11(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -5082,9 +5257,9 @@ Before handoff, run: pourkit validate-artifact finalizer ${artifactPathInWorktre
 
 // issues/issue-final-review.ts
 import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
-import { isAbsolute as isAbsolute3, join as join11, relative as relative2, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute3, join as join12, relative as relative2, sep as sep2 } from "path";
 init_common();
-var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join11(
+var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join12(
   ".pourkit",
   ".tmp",
   "issue-final-review",
@@ -5102,7 +5277,7 @@ async function runIssueFinalReview(options) {
     logger
   } = options;
   const artifactPathInWorktree = ISSUE_FINAL_REVIEW_ARTIFACT_PATH;
-  const artifactPath = join11(worktreePath, artifactPathInWorktree);
+  const artifactPath = join12(worktreePath, artifactPathInWorktree);
   const ifrFromState = options.worktreeState?.issueFinalReview;
   if (ifrFromState?.completed && ifrFromState.verdict === "pass") {
     if (!ifrFromState.artifactPath) {
@@ -5110,7 +5285,7 @@ async function runIssueFinalReview(options) {
         "Issue Final Review state is incomplete: missing artifactPath"
       );
     }
-    const cachedArtifactPath = isAbsolute3(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join11(worktreePath, ifrFromState.artifactPath);
+    const cachedArtifactPath = isAbsolute3(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join12(worktreePath, ifrFromState.artifactPath);
     const validation2 = validateAgentArtifact({
       kind: "issue-final-review",
       artifactPath: cachedArtifactPath,
@@ -5505,20 +5680,20 @@ function loadFinalizerPromptEffect(repoRoot2, promptTemplate, fs) {
 }
 function persistGeneratedArtifactEffect(worktreePath, output, fs) {
   return Effect7.gen(function* () {
-    const dir = join12(worktreePath, ".pourkit", ".tmp", "finalizer");
+    const dir = join13(worktreePath, ".pourkit", ".tmp", "finalizer");
     yield* fs.mkdir(dir).pipe(Effect7.catchAll(() => Effect7.void));
-    yield* fs.writeFile(join12(dir, "generated.md"), output).pipe(Effect7.catchAll(() => Effect7.void));
+    yield* fs.writeFile(join13(dir, "generated.md"), output).pipe(Effect7.catchAll(() => Effect7.void));
   });
 }
 function runPrDescriptionAgent(options) {
   const { executionProvider } = options;
-  const artifactPathInWorktree = join12(
+  const artifactPathInWorktree = join13(
     ".pourkit",
     ".tmp",
     "finalizer",
     "agent-output.md"
   );
-  const artifactPath = join12(options.worktreePath, artifactPathInWorktree);
+  const artifactPath = join13(options.worktreePath, artifactPathInWorktree);
   const finalizerFromState = options.worktreeState?.finalizer?.completed ? options.worktreeState.finalizer : null;
   if (finalizerFromState) {
     return Effect7.gen(function* () {
@@ -5529,7 +5704,7 @@ function runPrDescriptionAgent(options) {
           })
         );
       }
-      const resolvedArtifactPath = isAbsolute4(finalizerFromState.artifactPath) ? finalizerFromState.artifactPath : join12(options.worktreePath, finalizerFromState.artifactPath);
+      const resolvedArtifactPath = isAbsolute4(finalizerFromState.artifactPath) ? finalizerFromState.artifactPath : join13(options.worktreePath, finalizerFromState.artifactPath);
       if (!existsSync12(resolvedArtifactPath)) {
         return yield* Effect7.fail(
           new FinalizerFailure({
@@ -5651,7 +5826,7 @@ function runPrDescriptionAgent(options) {
   );
 }
 function runPrDescriptionFinalizerCore(options) {
-  const artifactPath = join12(
+  const artifactPath = join13(
     options.worktreePath,
     options.artifactPathInWorktree
   );
@@ -5752,7 +5927,7 @@ function runPrDescriptionFinalizerCore(options) {
 // issues/github-issue-publication.ts
 init_common();
 import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
-import { isAbsolute as isAbsolute5, join as join13 } from "path";
+import { isAbsolute as isAbsolute5, join as join14 } from "path";
 
 // issues/issue-transitions.ts
 function createIssueTransitions(deps, labels) {
@@ -5810,6 +5985,42 @@ function createIssueTransitions(deps, labels) {
   };
 }
 
+// beads/client.ts
+init_common();
+async function runBd(options) {
+  return execCapture("bd", options.args, {
+    cwd: options.repoRoot,
+    logger: options.logger,
+    label: options.label
+  });
+}
+async function runBdJson(options) {
+  return execJson("bd", options.args, {
+    cwd: options.repoRoot,
+    logger: options.logger,
+    label: options.label
+  });
+}
+
+// beads/prd-completion.ts
+async function closeBeadsPrdChild(options) {
+  const { repoRoot: repoRoot2, childId, reason, logger } = options;
+  if (!childId || childId.trim().length === 0) {
+    throw new Error(
+      "childId is required and must be a non-empty Beads ID string"
+    );
+  }
+  if (!reason || reason.trim().length === 0) {
+    throw new Error("reason is required and must be a non-empty string");
+  }
+  const response = await runBdJson({
+    repoRoot: repoRoot2,
+    args: ["close", childId, "--reason", reason, "--json"],
+    logger
+  });
+  return { ok: true, childId, response };
+}
+
 // issues/stacked-issue.ts
 var BODY_PARENT_SECTION_REGEX = /## Parent\s*\n([\s\S]*?)(?=\n## |$)/i;
 var AFFECTED_CODE_PATHS_SECTION_REGEX = /## Affected code paths\s*\n([\s\S]*?)(?=\n## |$)/i;
@@ -6227,7 +6438,7 @@ function readIssueFinalReviewArtifact(worktreeState, worktreePath) {
   if (!configuredPath) {
     return null;
   }
-  const artifactPath = isAbsolute5(configuredPath) ? configuredPath : join13(worktreePath, configuredPath);
+  const artifactPath = isAbsolute5(configuredPath) ? configuredPath : join14(worktreePath, configuredPath);
   if (!existsSync13(artifactPath)) return null;
   let parsed;
   try {
@@ -6334,19 +6545,56 @@ function formatTableCell(value) {
   return typeof value === "string" && value.trim() !== "" ? value.trim().replace(/\s+/g, " ").replace(/\|/g, "\\|") : "Unknown";
 }
 async function performCleanupAndClosure(options, pr) {
-  await options.issueProvider.removeLabel(
-    options.issue.number,
-    options.labels.agentInProgress
-  );
-  await options.issueProvider.removeLabel(
-    options.issue.number,
-    options.labels.prOpenAwaitingMerge
-  );
+  if (options.beadsCompletion) {
+    await closeBeadsPrdChild({
+      repoRoot: options.repoRoot,
+      childId: options.beadsCompletion.childId,
+      reason: `Issue #${options.issue.number} merged`,
+      logger: options.logger
+    });
+  }
+  try {
+    await options.issueProvider.removeLabel(
+      options.issue.number,
+      options.labels.agentInProgress
+    );
+  } catch (error) {
+    if (options.beadsCompletion) {
+      throw new Error(
+        `Projection failure after Beads close: GitHub Issue #${options.issue.number} label ${options.labels.agentInProgress} removal failed (Beads child ${options.beadsCompletion.childId} remains completed). ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    options.logger.step(
+      "warn",
+      `Failed to remove ${options.labels.agentInProgress} label (cleanup): ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    await options.issueProvider.removeLabel(
+      options.issue.number,
+      options.labels.prOpenAwaitingMerge
+    );
+  } catch (error) {
+    if (options.beadsCompletion) {
+      throw new Error(
+        `Projection failure after Beads close: GitHub Issue #${options.issue.number} label ${options.labels.prOpenAwaitingMerge} removal failed (Beads child ${options.beadsCompletion.childId} remains completed). ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    options.logger.step(
+      "warn",
+      `Failed to remove ${options.labels.prOpenAwaitingMerge} label (cleanup): ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
   let childCloseSucceeded = false;
   try {
     await options.issueProvider.closeIssue(options.issue.number);
     childCloseSucceeded = true;
   } catch (error) {
+    if (options.beadsCompletion) {
+      throw new Error(
+        `Projection failure after Beads close: GitHub Issue #${options.issue.number} close failed (Beads child ${options.beadsCompletion.childId} remains completed). ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
     options.logger.step(
       "warn",
       `Issue #${options.issue.number} could not be closed: ${error instanceof Error ? error.message : String(error)}`
@@ -6545,7 +6793,7 @@ async function runFinalCommit(options) {
 
 // issues/issue-worktree-resolution.ts
 init_common();
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   const worktreeList = await execCapture(
     "git",
@@ -6603,7 +6851,7 @@ async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   return { mode: "new", branchName, baseRef };
 }
 function issueWorktreePath(root, branchName) {
-  return join14(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
+  return join15(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
 }
 function resolveRegisteredIssueWorktreePath(worktreeListPorcelain, root, branchName) {
   const branchWorktreePath = parseWorktreeListPorcelain(
@@ -6996,7 +7244,9 @@ async function completeIssueRun(options) {
       blocked: config.labels.blocked
     },
     checkWaitOptions,
-    secretLikeContentDetectionEnabled: true
+    secretLikeContentDetectionEnabled: true,
+    repoRoot: ROOT,
+    beadsCompletion: options.beadsIssueRunContext
   });
   return {
     branchName,
@@ -7399,141 +7649,994 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
   };
 }
 
-// commands/prd-run.ts
-import { lstatSync, realpathSync } from "fs";
-import { join as join16 } from "path";
-
-// prd-run/state.ts
-import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync15,
-  readdirSync as readdirSync3,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { join as join15 } from "path";
-import { z as z2 } from "zod";
+// commands/prd-plan-workspace-publish.ts
+init_common();
+import { isAbsolute as isAbsolute6, relative as relative3, resolve as resolve3 } from "path";
 
-// prd-run/repair-guidance.ts
-import { z } from "zod";
-var PrdRunRepairAttemptSchema = z.object({
-  attemptedAt: z.string().min(1),
-  outcome: z.enum(["blocked", "projection-failed", "unsupported-state"]),
-  failureCode: z.string().min(1),
-  summary: z.string().min(1)
-}).strict();
-var PrdRunRepairGuidanceSchema = z.object({
-  createdAt: z.string().min(1),
-  updatedAt: z.string().min(1),
-  blockedGate: z.enum([
-    "receipt-check",
-    "branch-state",
-    "git",
-    "queue",
-    "final-review"
-  ]),
-  blockedStage: z.string().min(1),
-  failureCode: z.string().regex(
-    /^[a-z][a-z0-9-]*$/,
-    "failureCode must be kebab-case (lowercase letters, digits, hyphens)"
-  ),
-  humanReadableReason: z.string().min(1),
-  repairability: z.enum([
-    "automatic-retry-safe",
-    "operator-action",
-    "unsupported-state"
-  ]),
-  nextAction: z.string().min(1),
-  nextRecommendedCommand: z.string().min(1),
-  diagnostics: z.array(z.string()).optional(),
-  offendingPaths: z.array(z.string()).optional(),
-  issue: z.object({
-    number: z.number().int().positive(),
-    title: z.string().optional(),
-    branch: z.string().optional(),
-    worktreePath: z.string().optional()
-  }).strict().optional(),
-  pr: z.object({
-    number: z.number().int().positive().optional(),
-    url: z.string().url().optional()
-  }).strict().optional(),
-  attemptHistory: z.array(PrdRunRepairAttemptSchema).optional(),
-  targetName: z.string().min(1).optional(),
-  baseBranch: z.string().min(1).optional()
-}).strict();
-function buildPrdRunRepairGuidance(input) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return PrdRunRepairGuidanceSchema.parse({
-    createdAt: now,
-    updatedAt: now,
-    blockedGate: input.blockedGate,
-    blockedStage: input.blockedStage,
-    failureCode: input.failureCode,
-    humanReadableReason: input.humanReadableReason,
-    repairability: input.repairability,
-    nextAction: input.nextAction,
-    nextRecommendedCommand: input.nextRecommendedCommand,
-    diagnostics: input.diagnostics,
-    offendingPaths: input.offendingPaths,
-    issue: input.issue,
-    pr: input.pr,
-    targetName: input.targetName,
-    baseBranch: input.baseBranch,
-    attemptHistory: void 0
-  });
+// prd-plan-workspace/parser.ts
+import { readFile as readFile4, readdir } from "fs/promises";
+import { join as join16 } from "path";
+var CHILD_FILE_PATTERN = /^I-0*(\d+)-.+\.md$/i;
+var CHILD_REF_PATTERN = /^\s*(I-0*\d+)\s*$/i;
+var BLOCKED_BY_SECTION_REGEX = /## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i;
+var PARENT_SECTION_REGEX = /## Parent\s*\n([\s\S]*?)(?=\n## |$)/i;
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function derivePrdBeadsId(prdRef) {
+  const match = prdRef.match(/^PRD-0*(\d+)$/i);
+  if (!match) {
+    return prdRef.toLowerCase();
+  }
+  return `bd-${match[1].padStart(4, "0")}`;
 }
-function appendPrdRunRepairAttempt(guidance, attempt) {
-  const newAttempt = {
-    attemptedAt: attempt.attemptedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    outcome: attempt.outcome,
-    failureCode: attempt.failureCode,
-    summary: attempt.summary
-  };
-  const history = [...guidance.attemptHistory ?? [], newAttempt].slice(-5);
-  return PrdRunRepairGuidanceSchema.parse({
-    ...guidance,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    attemptHistory: history
-  });
+function deriveChildBeadsId(prdRef, childRef) {
+  const prdMatch = prdRef.match(/^PRD-0*(\d+)$/i);
+  const childMatch = childRef.match(/^I-0*(\d+)$/i);
+  if (!prdMatch || !childMatch) {
+    return `${prdRef.toLowerCase()}.${childRef.toLowerCase()}`;
+  }
+  return `bd-${prdMatch[1].padStart(4, "0")}.${childMatch[1]}`;
 }
-function validateActivePrdRunRepairGuidance(record) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (record.repairGuidance) {
-    const parsed = PrdRunRepairGuidanceSchema.safeParse(record.repairGuidance);
-    if (parsed.success) {
-      return { ok: true, guidance: parsed.data };
-    }
-    return {
-      ok: false,
-      guidance: {
-        createdAt: now,
-        updatedAt: now,
-        blockedGate: record.blockedGate ?? "queue",
-        blockedStage: "unknown",
-        failureCode: "malformed-repair-guidance",
-        humanReadableReason: "Repair guidance state is malformed or invalid. Inspect the PRD Run record.",
-        repairability: "unsupported-state",
-        nextAction: "inspect-prd-run-state",
-        nextRecommendedCommand: `pourkit prd-run status ${record.prdRef}`,
-        diagnostics: [
-          `Validation error: ${parsed.error?.message ?? "Unknown schema error"}`
-        ]
+function parseChildRefsFromBody(body) {
+  const section = body.match(BLOCKED_BY_SECTION_REGEX)?.[1];
+  if (!section) return [];
+  const refs = [];
+  for (const rawLine of section.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const parts = line.split(",");
+    for (const part of parts) {
+      const trimmed = part.trim();
+      const match = trimmed.match(CHILD_REF_PATTERN);
+      if (match) {
+        refs.push(match[1].toUpperCase());
       }
-    };
-  }
-  return {
-    ok: false,
-    guidance: {
-      createdAt: now,
-      updatedAt: now,
-      blockedGate: record.blockedGate ?? "queue",
-      blockedStage: "unknown",
-      failureCode: "missing-repair-guidance",
-      humanReadableReason: "No active repair guidance found for a blocked or unresolved record.",
-      repairability: "unsupported-state",
-      nextAction: "inspect-prd-run-state",
-      nextRecommendedCommand: `pourkit prd-run status ${record.prdRef}`,
-      diagnostics: record.diagnostics ? [...record.diagnostics] : []
+    }
+  }
+  return refs;
+}
+function extractTitleBody(content) {
+  const firstLine = content.split("\n")[0];
+  const title = firstLine.startsWith("# ") ? firstLine.slice(2).trim() : "";
+  const body = content.slice(firstLine.length).trim();
+  return { title, body };
+}
+function hasParentSectionPointingToPrd(content, prdRef) {
+  const section = content.match(PARENT_SECTION_REGEX)?.[1];
+  if (!section) return false;
+  return new RegExp(`\\b${escapeRegExp2(prdRef)}\\b`, "i").test(section);
+}
+async function parsePrdPlanWorkspace(options) {
+  const { workspacePath, prdRef } = options;
+  const diagnostics = [];
+  const prdPath = join16(workspacePath, "PRD.md");
+  const issuesDir = join16(workspacePath, "issues");
+  let prdContent;
+  try {
+    prdContent = await readFile4(prdPath, "utf-8");
+  } catch {
+    diagnostics.push({
+      severity: "error",
+      message: `Missing PRD.md in workspace`,
+      sourcePath: prdPath
+    });
+    return { ok: false, diagnostics };
+  }
+  const prdFile = extractTitleBody(prdContent);
+  const prdHeadingMatch = prdFile.title.match(/^(PRD-\d{4}):/i);
+  if (!prdHeadingMatch) {
+    diagnostics.push({
+      severity: "error",
+      message: "PRD.md must start with a heading: # PRD-NNNN: Title",
+      sourcePath: prdPath
+    });
+  } else if (prdHeadingMatch[1].toUpperCase() !== prdRef.toUpperCase()) {
+    diagnostics.push({
+      severity: "error",
+      message: `PRD.md heading ${prdHeadingMatch[1].toUpperCase()} does not match ${prdRef}`,
+      sourcePath: prdPath
+    });
+  }
+  const parent = {
+    prdRef,
+    title: prdFile.title,
+    body: prdFile.body,
+    sourcePath: prdPath,
+    beadsId: derivePrdBeadsId(prdRef)
+  };
+  let childFiles;
+  try {
+    childFiles = (await readdir(issuesDir)).filter(
+      (f) => CHILD_FILE_PATTERN.test(f) && !f.startsWith(".")
+    );
+  } catch {
+    diagnostics.push({
+      severity: "error",
+      message: `Missing issues/ directory`,
+      sourcePath: issuesDir
+    });
+    return { ok: false, diagnostics };
+  }
+  childFiles.sort((a, b) => {
+    const aMatch = a.match(CHILD_FILE_PATTERN);
+    const bMatch = b.match(CHILD_FILE_PATTERN);
+    if (!aMatch || !bMatch) return 0;
+    return Number(aMatch[1]) - Number(bMatch[1]);
+  });
+  const children = [];
+  for (const childFile of childFiles) {
+    const childPath = join16(issuesDir, childFile);
+    const childContent = await readFile4(childPath, "utf-8");
+    const childFileData = extractTitleBody(childContent);
+    const childRefMatch = childFile.match(CHILD_FILE_PATTERN);
+    const childRef = childRefMatch ? `I-${childRefMatch[1].padStart(2, "0")}` : "";
+    const childNumber = childRefMatch ? Number(childRefMatch[1]) : 0;
+    const blockedByRefs = parseChildRefsFromBody(childContent);
+    if (!childFileData.title.match(
+      new RegExp(`^${escapeRegExp2(prdRef)} / ${escapeRegExp2(childRef)}:`)
+    )) {
+      diagnostics.push({
+        severity: "error",
+        message: `${childFile}: expected heading: # ${prdRef} / ${childRef}: Title`,
+        sourcePath: childPath
+      });
+    }
+    if (!hasParentSectionPointingToPrd(childContent, prdRef)) {
+      diagnostics.push({
+        severity: "error",
+        message: `${childFile}: missing ## Parent section pointing to ${prdRef}`,
+        sourcePath: childPath
+      });
+    }
+    children.push({
+      childRef,
+      childNumber,
+      title: childFileData.title,
+      body: childFileData.body,
+      sourcePath: childPath,
+      beadsId: deriveChildBeadsId(prdRef, childRef),
+      blockedByRefs
+    });
+  }
+  const validChildRefs = new Set(children.map((c) => c.childRef));
+  for (const child of children) {
+    for (const blockedRef of child.blockedByRefs) {
+      if (!validChildRefs.has(blockedRef.toUpperCase())) {
+        diagnostics.push({
+          severity: "error",
+          message: `Child ${child.childRef} references nonexistent child ${blockedRef} in Blocked by`,
+          sourcePath: child.sourcePath
+        });
+      }
+    }
+  }
+  const model = {
+    prdRef,
+    workspacePath,
+    parent,
+    children,
+    diagnostics
+  };
+  if (diagnostics.length > 0) {
+    return { ok: false, diagnostics };
+  }
+  return { ok: true, workspace: model };
+}
+
+// prd-plan-workspace/publish-receipt.ts
+import { mkdir as mkdir4, writeFile } from "fs/promises";
+import { dirname as dirname5, join as join17 } from "path";
+function yamlEntry(key, value, indent) {
+  const pad = " ".repeat(indent);
+  if (value === null || value === void 0) {
+    return `${pad}${key}: ~`;
+  }
+  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return `${pad}${key}: ${value}`;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return `${pad}${key}: []`;
+    }
+    const itemPad = " ".repeat(indent + 2);
+    const innerIndent = indent + 4;
+    const lines = value.map((item) => {
+      if (typeof item === "object" && item !== null) {
+        const entries = Object.entries(item);
+        const firstLine = `${itemPad}- ${entries[0][0]}: ${entries[0][1]}`;
+        const restLines = entries.slice(1).map(([k, v]) => yamlEntry(k, v, innerIndent));
+        return [firstLine, ...restLines].join("\n");
+      }
+      return `${itemPad}- ${String(item)}`;
+    });
+    return `${pad}${key}:
+${lines.join("\n")}`;
+  }
+  if (typeof value === "object") {
+    const inner = Object.entries(value).map(([k, v]) => yamlEntry(k, v, indent + 2)).join("\n");
+    return `${pad}${key}:
+${inner}`;
+  }
+  return `${pad}${key}: ${String(value)}`;
+}
+function renderPrdPublishReceipt(options) {
+  const data = {
+    workspace: options.workspacePath,
+    route: "prd",
+    parent: {
+      prd_ref: options.parent.prdRef,
+      beads_id: options.parent.beadsId,
+      number: options.parent.githubIssue.number,
+      url: options.parent.githubIssue.url
+    },
+    children: options.children.map((c) => ({
+      child_ref: c.childRef,
+      beads_id: c.beadsId,
+      number: c.githubIssue.number,
+      url: c.githubIssue.url,
+      source_file: c.sourceFile
+    })),
+    dependency_mappings: options.dependencyMappings.map((d) => ({
+      from: d.from,
+      to: d.to,
+      beads_edge_type: d.beadsEdgeType
+    })),
+    publication_timestamp: options.publicationTimestamp,
+    authored_bodies_mutated: false,
+    warnings: options.warnings
+  };
+  return Object.entries(data).map(([k, v]) => yamlEntry(k, v, 0)).join("\n") + "\n";
+}
+async function writePrdPublishReceipt(options) {
+  const receipt = renderPrdPublishReceipt(options);
+  const publishPath = join17(options.workspaceRoot, "PUBLISH.md");
+  await mkdir4(dirname5(publishPath), { recursive: true });
+  await writeFile(publishPath, receipt, "utf-8");
+  return publishPath;
+}
+
+// beads/preflight.ts
+init_common();
+async function checkBeadsAvailability(options) {
+  try {
+    await execCapture("which", ["bd"], {
+      cwd: options.repoRoot,
+      logger: options.logger
+    });
+  } catch {
+    return {
+      available: false,
+      error: "bd CLI is not installed or not on PATH",
+      repairGuidance: "Install Beads CLI (bd), then run your workflow again."
+    };
+  }
+  try {
+    await runBd({
+      repoRoot: options.repoRoot,
+      args: ["ready", "--json"],
+      logger: options.logger
+    });
+  } catch {
+    return {
+      available: false,
+      error: "Beads repository state is unusable",
+      repairGuidance: "Run 'bd init' in the repository root to initialize Beads state, then run your workflow again."
+    };
+  }
+  return { available: true };
+}
+
+// beads/prd-publication.ts
+function isMissingIssueMessage(value) {
+  return /no issues? found matching/i.test(value);
+}
+function parentMetadata(options) {
+  return {
+    pourkit: {
+      prdRef: options.workspace.prdRef,
+      workspacePath: options.workspace.workspacePath,
+      sourcePath: options.workspace.parent.sourcePath,
+      ...options.githubIssue ? {
+        githubIssueNumber: options.githubIssue.number,
+        githubIssueUrl: options.githubIssue.url
+      } : {}
+    }
+  };
+}
+function childMetadata(options) {
+  return {
+    pourkit: {
+      prdRef: options.workspace.prdRef,
+      childRef: options.child.childRef,
+      workspacePath: options.workspace.workspacePath,
+      sourcePath: options.child.sourcePath,
+      ...options.githubIssue ? {
+        githubIssueNumber: options.githubIssue.number,
+        githubIssueUrl: options.githubIssue.url
+      } : {}
+    }
+  };
+}
+async function beadExists(options) {
+  try {
+    const result = await runBdJson({
+      repoRoot: options.repoRoot,
+      args: ["show", options.beadsId, "--json"],
+      logger: options.logger
+    });
+    if (result?.error) {
+      if (isMissingIssueMessage(result.error)) return false;
+      throw new Error(result.error);
+    }
+    if (result?.id !== options.beadsId) {
+      throw new Error(
+        `Expected Beads issue ${options.beadsId}, but bd show returned ${result?.id ?? "no id"}.`
+      );
+    }
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (isMissingIssueMessage(message)) return false;
+    throw error;
+  }
+}
+function assertExpectedBeadId(options) {
+  if (options.response?.id !== options.expectedId) {
+    throw new Error(
+      `${options.action} returned ${options.response?.id ?? "no id"}; expected ${options.expectedId}.`
+    );
+  }
+}
+async function createOrUpdateParent(options) {
+  const exists = await beadExists({
+    repoRoot: options.repoRoot,
+    beadsId: options.workspace.parent.beadsId,
+    logger: options.logger
+  });
+  const response = await runBdJson({
+    repoRoot: options.repoRoot,
+    args: exists ? [
+      "update",
+      options.workspace.parent.beadsId,
+      "--title",
+      options.workspace.parent.title,
+      "--description",
+      options.workspace.parent.body,
+      "-t",
+      "epic",
+      "--metadata",
+      JSON.stringify(parentMetadata({ workspace: options.workspace })),
+      "--json"
+    ] : [
+      "create",
+      "--id",
+      options.workspace.parent.beadsId,
+      "--title",
+      options.workspace.parent.title,
+      "-t",
+      "epic",
+      "--description",
+      options.workspace.parent.body,
+      "--metadata",
+      JSON.stringify(parentMetadata({ workspace: options.workspace })),
+      "--json"
+    ],
+    logger: options.logger
+  });
+  if (!exists) {
+    assertExpectedBeadId({
+      expectedId: options.workspace.parent.beadsId,
+      response,
+      action: "bd create parent"
+    });
+  }
+}
+async function createOrUpdateChild(options) {
+  const exists = await beadExists({
+    repoRoot: options.repoRoot,
+    beadsId: options.child.beadsId,
+    logger: options.logger
+  });
+  const response = await runBdJson({
+    repoRoot: options.repoRoot,
+    args: exists ? [
+      "update",
+      options.child.beadsId,
+      "--title",
+      options.child.title,
+      "--description",
+      options.child.body,
+      "--parent",
+      options.workspace.parent.beadsId,
+      "--metadata",
+      JSON.stringify(
+        childMetadata({
+          workspace: options.workspace,
+          child: options.child
+        })
+      ),
+      "--json"
+    ] : [
+      "create",
+      "--parent",
+      options.workspace.parent.beadsId,
+      "--title",
+      options.child.title,
+      "--description",
+      options.child.body,
+      "--metadata",
+      JSON.stringify(
+        childMetadata({
+          workspace: options.workspace,
+          child: options.child
+        })
+      ),
+      "--json"
+    ],
+    logger: options.logger
+  });
+  if (!exists) {
+    assertExpectedBeadId({
+      expectedId: options.child.beadsId,
+      response,
+      action: "bd create child"
+    });
+  }
+}
+async function registerPrdWorkspaceInBeads(options) {
+  const { repoRoot: repoRoot2, workspace, logger } = options;
+  const preflight = await checkBeadsAvailability({ repoRoot: repoRoot2, logger });
+  if (!preflight.available) {
+    throw new Error(
+      `Beads is not available: ${preflight.error}. ${preflight.repairGuidance}`
+    );
+  }
+  await createOrUpdateParent({
+    repoRoot: repoRoot2,
+    workspace,
+    logger
+  });
+  const children = [];
+  const dependencyMappings = [];
+  for (const child of workspace.children) {
+    await createOrUpdateChild({
+      repoRoot: repoRoot2,
+      workspace,
+      child,
+      logger
+    });
+    children.push({
+      childRef: child.childRef,
+      beadsId: child.beadsId,
+      sourcePath: child.sourcePath
+    });
+  }
+  for (const child of workspace.children) {
+    for (const blockedRef of child.blockedByRefs) {
+      const blocker = workspace.children.find((c) => c.childRef === blockedRef);
+      if (!blocker) continue;
+      await runBdJson({
+        repoRoot: repoRoot2,
+        args: ["dep", "add", child.beadsId, blocker.beadsId, "--json"],
+        logger
+      });
+      dependencyMappings.push({
+        from: child.childRef,
+        to: blocker.childRef,
+        beadsEdgeType: "blocks"
+      });
+    }
+  }
+  return {
+    parent: {
+      prdRef: workspace.prdRef,
+      beadsId: workspace.parent.beadsId
+    },
+    children,
+    dependencyMappings
+  };
+}
+async function backfillPrdWorkspaceBeadsGithubMetadata(options) {
+  const childIssueByRef = new Map(
+    options.childGithubIssues.map((child) => [
+      child.childRef,
+      child.githubIssue
+    ])
+  );
+  await runBdJson({
+    repoRoot: options.repoRoot,
+    args: [
+      "update",
+      options.workspace.parent.beadsId,
+      "--metadata",
+      JSON.stringify(
+        parentMetadata({
+          workspace: options.workspace,
+          githubIssue: options.parentGithubIssue
+        })
+      ),
+      "--json"
+    ],
+    logger: options.logger
+  });
+  for (const child of options.workspace.children) {
+    const githubIssue = childIssueByRef.get(child.childRef);
+    if (!githubIssue) {
+      throw new Error(
+        `Missing GitHub issue projection for Beads child ${child.beadsId} (${child.childRef}).`
+      );
+    }
+    await runBdJson({
+      repoRoot: options.repoRoot,
+      args: [
+        "update",
+        child.beadsId,
+        "--metadata",
+        JSON.stringify(
+          childMetadata({
+            workspace: options.workspace,
+            child,
+            githubIssue
+          })
+        ),
+        "--json"
+      ],
+      logger: options.logger
+    });
+  }
+}
+
+// commands/prd-plan-workspace-publish.ts
+var DEFAULT_LABELS = {
+  readyForAgent: "ready-for-agent",
+  blocked: "blocked",
+  needsTriage: "needs-triage"
+};
+function normalizePrdRef(prdRef) {
+  const match = prdRef.trim().toUpperCase().match(/^PRD-(\d+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid PRD ref "${prdRef}". Expected format: PRD-<number> (e.g., PRD-0078)`
+    );
+  }
+  return `PRD-${match[1].padStart(4, "0")}`;
+}
+function repoRelativePath(repoRoot2, absolutePath) {
+  const rel = relative3(repoRoot2, absolutePath).replace(/\\/g, "/");
+  if (rel === "") return ".";
+  if (rel === ".." || rel.startsWith("../") || isAbsolute6(rel)) {
+    throw new Error(`Path is outside the repository: ${absolutePath}`);
+  }
+  return rel;
+}
+function resolveWorkspaceRoot(options) {
+  const workspaceRoot = isAbsolute6(options.workspacePath) ? options.workspacePath : resolve3(options.repoRoot, options.workspacePath);
+  const workspaceRelPath = repoRelativePath(options.repoRoot, workspaceRoot);
+  if (!workspaceRelPath.startsWith(".pourkit/plans/")) {
+    throw new Error(
+      `PRD Plan Workspace must be under .pourkit/plans/: ${workspaceRelPath}`
+    );
+  }
+  return { workspaceRoot, workspaceRelPath };
+}
+function relativizeWorkspaceModel(options) {
+  return {
+    ...options.workspace,
+    workspacePath: repoRelativePath(
+      options.repoRoot,
+      resolve3(options.workspace.workspacePath)
+    ),
+    parent: {
+      ...options.workspace.parent,
+      sourcePath: repoRelativePath(
+        options.repoRoot,
+        resolve3(options.workspace.parent.sourcePath)
+      )
+    },
+    children: options.workspace.children.map((child) => ({
+      ...child,
+      sourcePath: repoRelativePath(options.repoRoot, resolve3(child.sourcePath))
+    }))
+  };
+}
+function formatValidationFailure(result) {
+  const diagnostics = result.diagnostics.length ? ` Diagnostics: ${result.diagnostics.join("; ")}` : "";
+  return `PRD Plan Workspace Publication Gate failed: ${result.reason}.${diagnostics}`;
+}
+function extractTypeLabels(body) {
+  const labelsLine = body.match(/^Labels:\s*(.+)$/im)?.[1];
+  if (!labelsLine) return [];
+  const backtickLabels = Array.from(labelsLine.matchAll(/`([^`]+)`/g)).map(
+    (match) => match[1].trim()
+  );
+  const labels = backtickLabels.length > 0 ? backtickLabels : labelsLine.split(/[\s,]+/).map((label) => label.trim());
+  return labels.filter(
+    (label) => TYPE_LABELS.includes(label)
+  );
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function logStep(logger, level, message) {
+  logger?.step?.(level, message);
+}
+function childLabels(options) {
+  const typeLabels = extractTypeLabels(options.body);
+  let typeLabel = typeLabels[0];
+  if (!typeLabel) {
+    typeLabel = "type:feature";
+    options.warnings.push(
+      `${options.childRef}: no type:* label found; defaulted to type:feature.`
+    );
+  } else if (typeLabels.length > 1) {
+    options.warnings.push(
+      `${options.childRef}: multiple type:* labels found; kept ${typeLabel}.`
+    );
+  }
+  return unique([
+    options.labels.readyForAgent,
+    typeLabel,
+    ...options.blocked ? [options.labels.blocked] : []
+  ]);
+}
+async function syncManagedLabels(options) {
+  const desired = new Set(options.desiredLabels);
+  const managed = /* @__PURE__ */ new Set([
+    options.labels.readyForAgent,
+    options.labels.blocked,
+    options.labels.needsTriage,
+    ...TYPE_LABELS
+  ]);
+  for (const label of options.existingLabels) {
+    if (managed.has(label) && !desired.has(label)) {
+      await options.issueProvider.removeLabel(options.issueNumber, label);
+    }
+  }
+  const existing = new Set(options.existingLabels);
+  const missing = options.desiredLabels.filter((label) => !existing.has(label));
+  if (missing.length > 0) {
+    await options.issueProvider.addLabels(options.issueNumber, missing);
+  }
+}
+async function upsertGithubIssue(options) {
+  const existing = await options.issueProvider.resolveIssueByCanonicalRef(
+    options.canonicalRef
+  );
+  if (existing) {
+    const updated = await options.issueProvider.updateIssue(existing.number, {
+      title: options.title,
+      body: options.body
+    });
+    await syncManagedLabels({
+      issueProvider: options.issueProvider,
+      issueNumber: existing.number,
+      existingLabels: existing.labels,
+      desiredLabels: options.labels,
+      labels: options.publishLabels
+    });
+    return { ...updated, labels: options.labels };
+  }
+  const created = await options.issueProvider.createIssue({
+    title: options.title,
+    body: options.body,
+    labels: options.labels
+  });
+  return { ...created, labels: options.labels };
+}
+async function publishWorkspaceToGithub(options) {
+  const parent = await upsertGithubIssue({
+    issueProvider: options.issueProvider,
+    canonicalRef: options.workspace.prdRef,
+    title: options.workspace.parent.title,
+    body: options.workspace.parent.body,
+    labels: [options.labels.needsTriage],
+    publishLabels: options.labels
+  });
+  const children = [];
+  for (const child of options.workspace.children) {
+    const labels = childLabels({
+      body: child.body,
+      blocked: child.blockedByRefs.length > 0,
+      labels: options.labels,
+      warnings: options.warnings,
+      childRef: child.childRef
+    });
+    const githubIssue = await upsertGithubIssue({
+      issueProvider: options.issueProvider,
+      canonicalRef: `${options.workspace.prdRef} / ${child.childRef}`,
+      title: child.title,
+      body: child.body,
+      labels,
+      publishLabels: options.labels
+    });
+    children.push({ childRef: child.childRef, githubIssue });
+  }
+  return { parent, children };
+}
+async function runPrdPlanWorkspacePublishCommand(options) {
+  const prdRef = normalizePrdRef(options.prdRef);
+  const labels = { ...DEFAULT_LABELS, ...options.labels };
+  const { workspaceRoot, workspaceRelPath } = resolveWorkspaceRoot({
+    repoRoot: options.repoRoot,
+    workspacePath: options.workspacePath
+  });
+  logStep(
+    options.logger,
+    "info",
+    `Publishing PRD Plan Workspace ${workspaceRelPath} for ${prdRef}.`
+  );
+  logStep(
+    options.logger,
+    "info",
+    `Running PRD Plan Workspace Publication Gate for ${prdRef}.`
+  );
+  const validation = runValidateArtifactCommand({
+    repoRoot: options.repoRoot,
+    kind: "prd-plan-workspace",
+    artifactPath: workspaceRoot,
+    workspace: workspaceRoot,
+    prdRef
+  });
+  if (!validation.ok) {
+    throw new Error(formatValidationFailure(validation));
+  }
+  const parsed = await parsePrdPlanWorkspace({
+    workspacePath: workspaceRoot,
+    prdRef
+  });
+  if (!parsed.ok) {
+    throw new Error(
+      `PRD Plan Workspace parse failed: ${parsed.diagnostics.map((d) => d.message).join("; ")}`
+    );
+  }
+  if (parsed.workspace.children.length === 0) {
+    throw new Error(
+      "PRD Plan Workspace must contain at least one child Issue."
+    );
+  }
+  const workspace = relativizeWorkspaceModel({
+    repoRoot: options.repoRoot,
+    workspace: parsed.workspace
+  });
+  logStep(
+    options.logger,
+    "info",
+    `Publication gate passed for ${prdRef}: ${workspace.children.length} child Issue(s).`
+  );
+  logStep(
+    options.logger,
+    "info",
+    `Registering Beads Work Graph for ${prdRef}: ${workspace.parent.beadsId}.`
+  );
+  const beadsPublication = await registerPrdWorkspaceInBeads({
+    repoRoot: options.repoRoot,
+    workspace,
+    logger: options.logger
+  });
+  logStep(
+    options.logger,
+    "info",
+    `Registered Beads Work Graph for ${prdRef}: ${beadsPublication.children.length} child bead(s), ${beadsPublication.dependencyMappings.length} dependency edge(s).`
+  );
+  const warnings = [];
+  logStep(options.logger, "info", `Projecting ${prdRef} to GitHub Issues.`);
+  const githubPublication = await publishWorkspaceToGithub({
+    workspace,
+    issueProvider: options.issueProvider,
+    labels,
+    warnings
+  });
+  logStep(
+    options.logger,
+    "info",
+    `Projected ${prdRef} to GitHub: parent #${githubPublication.parent.number}, ${githubPublication.children.length} child Issue(s).`
+  );
+  logStep(
+    options.logger,
+    "info",
+    `Backfilling Beads metadata for ${prdRef} with GitHub Issue numbers and URLs.`
+  );
+  await backfillPrdWorkspaceBeadsGithubMetadata({
+    repoRoot: options.repoRoot,
+    workspace,
+    parentGithubIssue: githubPublication.parent,
+    childGithubIssues: githubPublication.children.map((child) => ({
+      childRef: child.childRef,
+      githubIssue: child.githubIssue
+    })),
+    logger: options.logger
+  });
+  logStep(options.logger, "info", `Backfilled Beads metadata for ${prdRef}.`);
+  const children = workspace.children.map((child) => {
+    const githubChild = githubPublication.children.find(
+      (published) => published.childRef === child.childRef
+    );
+    if (!githubChild) {
+      throw new Error(
+        `Missing GitHub publication result for ${child.childRef}.`
+      );
+    }
+    return {
+      childRef: child.childRef,
+      beadsId: child.beadsId,
+      githubIssue: githubChild.githubIssue,
+      sourceFile: child.sourcePath
+    };
+  });
+  const publishPath = await writePrdPublishReceipt({
+    workspaceRoot,
+    workspacePath: workspace.workspacePath,
+    parent: {
+      prdRef,
+      beadsId: beadsPublication.parent.beadsId,
+      githubIssue: githubPublication.parent
+    },
+    children,
+    dependencyMappings: beadsPublication.dependencyMappings,
+    publicationTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    authoredBodiesMutated: false,
+    warnings
+  });
+  logStep(
+    options.logger,
+    "info",
+    `Wrote PRD publication receipt for ${prdRef}: ${publishPath}.`
+  );
+  return {
+    status: "published",
+    prdRef,
+    workspacePath: workspace.workspacePath,
+    parent: {
+      prdRef,
+      beadsId: beadsPublication.parent.beadsId,
+      githubIssue: githubPublication.parent
+    },
+    children,
+    dependencyMappings: beadsPublication.dependencyMappings,
+    publishPath,
+    warnings
+  };
+}
+
+// commands/prd-run.ts
+import { lstatSync, realpathSync } from "fs";
+import { join as join19 } from "path";
+
+// prd-run/state.ts
+import {
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync4,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { join as join18 } from "path";
+import { z as z2 } from "zod";
+
+// prd-run/repair-guidance.ts
+import { z } from "zod";
+var PrdRunRepairAttemptSchema = z.object({
+  attemptedAt: z.string().min(1),
+  outcome: z.enum(["blocked", "projection-failed", "unsupported-state"]),
+  failureCode: z.string().min(1),
+  summary: z.string().min(1)
+}).strict();
+var PrdRunRepairGuidanceSchema = z.object({
+  createdAt: z.string().min(1),
+  updatedAt: z.string().min(1),
+  blockedGate: z.enum([
+    "receipt-check",
+    "branch-state",
+    "git",
+    "queue",
+    "final-review"
+  ]),
+  blockedStage: z.string().min(1),
+  failureCode: z.string().regex(
+    /^[a-z][a-z0-9-]*$/,
+    "failureCode must be kebab-case (lowercase letters, digits, hyphens)"
+  ),
+  humanReadableReason: z.string().min(1),
+  repairability: z.enum([
+    "automatic-retry-safe",
+    "operator-action",
+    "unsupported-state"
+  ]),
+  nextAction: z.string().min(1),
+  nextRecommendedCommand: z.string().min(1),
+  diagnostics: z.array(z.string()).optional(),
+  offendingPaths: z.array(z.string()).optional(),
+  issue: z.object({
+    number: z.number().int().positive(),
+    title: z.string().optional(),
+    branch: z.string().optional(),
+    worktreePath: z.string().optional(),
+    beadsChildId: z.string().min(1).optional(),
+    beadsChildRef: z.string().min(1).optional(),
+    beadsChildClosed: z.boolean().optional()
+  }).strict().optional(),
+  pr: z.object({
+    number: z.number().int().positive().optional(),
+    url: z.string().url().optional()
+  }).strict().optional(),
+  attemptHistory: z.array(PrdRunRepairAttemptSchema).optional(),
+  targetName: z.string().min(1).optional(),
+  baseBranch: z.string().min(1).optional()
+}).strict();
+function buildPrdRunRepairGuidance(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return PrdRunRepairGuidanceSchema.parse({
+    createdAt: now,
+    updatedAt: now,
+    blockedGate: input.blockedGate,
+    blockedStage: input.blockedStage,
+    failureCode: input.failureCode,
+    humanReadableReason: input.humanReadableReason,
+    repairability: input.repairability,
+    nextAction: input.nextAction,
+    nextRecommendedCommand: input.nextRecommendedCommand,
+    diagnostics: input.diagnostics,
+    offendingPaths: input.offendingPaths,
+    issue: input.issue,
+    pr: input.pr,
+    targetName: input.targetName,
+    baseBranch: input.baseBranch,
+    attemptHistory: void 0
+  });
+}
+function appendPrdRunRepairAttempt(guidance, attempt) {
+  const newAttempt = {
+    attemptedAt: attempt.attemptedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    outcome: attempt.outcome,
+    failureCode: attempt.failureCode,
+    summary: attempt.summary
+  };
+  const history = [...guidance.attemptHistory ?? [], newAttempt].slice(-5);
+  return PrdRunRepairGuidanceSchema.parse({
+    ...guidance,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    attemptHistory: history
+  });
+}
+function validateActivePrdRunRepairGuidance(record) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (record.repairGuidance) {
+    const parsed = PrdRunRepairGuidanceSchema.safeParse(record.repairGuidance);
+    if (parsed.success) {
+      return { ok: true, guidance: parsed.data };
+    }
+    return {
+      ok: false,
+      guidance: {
+        createdAt: now,
+        updatedAt: now,
+        blockedGate: record.blockedGate ?? "queue",
+        blockedStage: "unknown",
+        failureCode: "malformed-repair-guidance",
+        humanReadableReason: "Repair guidance state is malformed or invalid. Inspect the PRD Run record.",
+        repairability: "unsupported-state",
+        nextAction: "inspect-prd-run-state",
+        nextRecommendedCommand: `pourkit prd-run status ${record.prdRef}`,
+        diagnostics: [
+          `Validation error: ${parsed.error?.message ?? "Unknown schema error"}`
+        ]
+      }
+    };
+  }
+  return {
+    ok: false,
+    guidance: {
+      createdAt: now,
+      updatedAt: now,
+      blockedGate: record.blockedGate ?? "queue",
+      blockedStage: "unknown",
+      failureCode: "missing-repair-guidance",
+      humanReadableReason: "No active repair guidance found for a blocked or unresolved record.",
+      repairability: "unsupported-state",
+      nextAction: "inspect-prd-run-state",
+      nextRecommendedCommand: `pourkit prd-run status ${record.prdRef}`,
+      diagnostics: record.diagnostics ? [...record.diagnostics] : []
     }
   };
 }
@@ -7716,17 +8819,17 @@ function readPrdRun(repoRoot2, prdRef) {
   }
 }
 function listPrdRuns(repoRoot2) {
-  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join18(repoRoot2, PRD_RUN_STATE_DIR);
   if (!existsSync14(stateDir)) {
     return { records: [], diagnostics: [] };
   }
   const records = [];
   const diagnostics = [];
-  for (const entry of readdirSync3(stateDir, { withFileTypes: true }).sort(
+  for (const entry of readdirSync4(stateDir, { withFileTypes: true }).sort(
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const recordPath = join15(stateDir, entry.name);
+    const recordPath = join18(stateDir, entry.name);
     try {
       const record = PrdRunRecordSchema.parse(
         JSON.parse(readFileSync15(recordPath, "utf-8"))
@@ -7743,13 +8846,13 @@ function listPrdRuns(repoRoot2) {
 function writePrdRunRecord(repoRoot2, record) {
   const normalized = normalizePrdRunRef(record.prdRef);
   const parsed = PrdRunRecordSchema.parse({ ...record, prdRef: normalized });
-  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join18(repoRoot2, PRD_RUN_STATE_DIR);
   const recordPath = getRecordPath(repoRoot2, normalized);
   mkdirSync7(stateDir, { recursive: true });
   writeFileSync4(recordPath, JSON.stringify(parsed, null, 2), "utf-8");
 }
 function getRecordPath(repoRoot2, prdRef) {
-  return join15(
+  return join18(
     repoRoot2,
     PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef(prdRef)}.json`
@@ -7919,9 +9022,11 @@ async function anyBlockerStillOpen(refs, getIssueState) {
 // commands/queue.ts
 var QueueProviderError = class extends Error {
   _tag = "QueueProviderError";
-  constructor(message) {
+  issue;
+  constructor(message, issue) {
     super(message);
     this.name = "QueueProviderError";
+    this.issue = issue;
   }
 };
 function issueDataToCandidate(issue) {
@@ -8154,11 +9259,14 @@ function runOneQueueIssueEffect(options) {
       catch: (e) => {
         if (e instanceof Error && e.name === "HumanHandoffStop") {
           return new QueueProviderError(
-            `Issue Final Review requires human handoff: ${e.message}`
+            `Issue Final Review requires human handoff: ${e.message}`,
+            selectedIssue
           );
         }
-        if (e instanceof Error) return e;
-        throw e;
+        return new QueueProviderError(
+          e instanceof Error ? e.message : String(e),
+          selectedIssue
+        );
       }
     });
     logger.raw("Issue completed successfully:");
@@ -8247,6 +9355,26 @@ async function runQueueCommand(options) {
   }
   return runEffectAndMapExit(runQueueLoop(queueOptions));
 }
+async function runClaimedPrdIssueCommand(options) {
+  const baseBranchOverride = options.queueRunContext.prdBranch;
+  const runResult = await runIssueCommand({
+    issueNumber: options.issue.number,
+    targetName: options.targetName,
+    config: options.config,
+    issueProvider: options.issueProvider,
+    prProvider: options.prProvider,
+    executionProvider: options.executionProvider,
+    force: options.force,
+    logger: options.logger,
+    repoRoot: options.repoRoot,
+    ...baseBranchOverride ? { baseBranchOverride } : {},
+    ...options.queueRunContext.beadsChild ? { beadsIssueRunContext: options.queueRunContext.beadsChild } : {}
+  });
+  return {
+    selected: options.issue,
+    runResult
+  };
+}
 
 // prd-run/evidence.ts
 function validatePrdRunStartEvidence(record, context) {
@@ -8459,6 +9587,185 @@ function validatePrdRunTerminalEvidence(record, context) {
   return { ok: true };
 }
 
+// beads/prd-ready.ts
+function derivePrdEpicId(prdRef) {
+  const trimmed = prdRef.trim().toUpperCase();
+  const match = trimmed.match(/^(?:PRD-)?(\d+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid PRD ref "${prdRef}". Expected format: PRD-<number> (e.g., PRD-0078)`
+    );
+  }
+  const padded = match[1].padStart(4, "0");
+  return `bd-${padded}`;
+}
+async function claimReadyPrdChild(options) {
+  const epicId = derivePrdEpicId(options.prdRef);
+  const result = await runBdJson({
+    repoRoot: options.repoRoot,
+    args: ["ready", "--parent", epicId, "--claim", "--json"],
+    logger: options.logger
+  });
+  if (!result || !result.id) {
+    return { ok: false, epicId, reason: "no-ready-child" };
+  }
+  return {
+    ok: true,
+    epicId,
+    child: {
+      id: result.id,
+      title: result.title,
+      metadata: result.metadata
+    }
+  };
+}
+function isMissingIssueMessage2(value) {
+  return /no issues? found matching/i.test(value);
+}
+function getPourkitPrdRef(metadata) {
+  if (!metadata || typeof metadata !== "object") return void 0;
+  const pourkit = metadata.pourkit;
+  if (!pourkit || typeof pourkit !== "object") return void 0;
+  const prdRef = pourkit.prdRef;
+  return typeof prdRef === "string" ? prdRef : void 0;
+}
+async function checkPrdBeadsEpicPresence(options) {
+  const expectedPrdRef = options.prdRef.trim().toUpperCase();
+  const epicId = derivePrdEpicId(expectedPrdRef);
+  let result;
+  try {
+    result = await runBdJson({
+      repoRoot: options.repoRoot,
+      args: ["show", epicId, "--json"],
+      logger: options.logger
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (isMissingIssueMessage2(message)) {
+      return { ok: true, epicId, exists: false, reason: "missing-epic" };
+    }
+    return { ok: false, epicId, reason: message };
+  }
+  if (!result) {
+    return {
+      ok: false,
+      epicId,
+      reason: `bd show ${epicId} returned no result.`
+    };
+  }
+  if (result.error) {
+    if (isMissingIssueMessage2(result.error)) {
+      return { ok: true, epicId, exists: false, reason: "missing-epic" };
+    }
+    return { ok: false, epicId, reason: result.error };
+  }
+  if (result.id !== epicId) {
+    return {
+      ok: false,
+      epicId,
+      reason: `Expected Beads epic ${epicId}, but bd show returned ${result.id ?? "no id"}.`
+    };
+  }
+  const metadataPrdRef = getPourkitPrdRef(result.metadata)?.toUpperCase();
+  if (metadataPrdRef !== expectedPrdRef) {
+    return {
+      ok: false,
+      epicId,
+      reason: `Beads epic ${epicId} is missing matching pourkit.prdRef metadata for ${expectedPrdRef}.`
+    };
+  }
+  return { ok: true, epicId, exists: true };
+}
+
+// beads/issue-context.ts
+function parsePourkitBeadsMetadata(metadata) {
+  if (typeof metadata !== "object" || metadata === null) {
+    return { ok: false, reason: "metadata must be an object" };
+  }
+  const obj = metadata;
+  if (typeof obj.pourkit !== "object" || obj.pourkit === null) {
+    return {
+      ok: false,
+      reason: "metadata must contain top-level pourkit object"
+    };
+  }
+  const pourkit = obj.pourkit;
+  if (typeof pourkit.prdRef !== "string" || pourkit.prdRef.trim() === "") {
+    return { ok: false, reason: "pourkit.prdRef must be a non-empty string" };
+  }
+  if (typeof pourkit.childRef !== "string" || !/^I-\d+$/.test(pourkit.childRef)) {
+    return { ok: false, reason: "pourkit.childRef must be an I-0N string" };
+  }
+  if (typeof pourkit.githubIssueNumber !== "number" || !Number.isInteger(pourkit.githubIssueNumber) || pourkit.githubIssueNumber <= 0) {
+    return {
+      ok: false,
+      reason: "pourkit.githubIssueNumber must be a positive integer"
+    };
+  }
+  if (pourkit.workspacePath !== void 0 && typeof pourkit.workspacePath !== "string") {
+    return {
+      ok: false,
+      reason: "pourkit.workspacePath must be a string when present"
+    };
+  }
+  if (pourkit.sourcePath !== void 0 && typeof pourkit.sourcePath !== "string") {
+    return {
+      ok: false,
+      reason: "pourkit.sourcePath must be a string when present"
+    };
+  }
+  if (pourkit.githubIssueUrl !== void 0 && typeof pourkit.githubIssueUrl !== "string") {
+    return {
+      ok: false,
+      reason: "pourkit.githubIssueUrl must be a string when present"
+    };
+  }
+  return {
+    ok: true,
+    prdRef: pourkit.prdRef,
+    childRef: pourkit.childRef,
+    githubIssueNumber: pourkit.githubIssueNumber,
+    workspacePath: pourkit.workspacePath,
+    sourcePath: pourkit.sourcePath,
+    githubIssueUrl: pourkit.githubIssueUrl
+  };
+}
+async function buildIssueContextFromBeadsChild(options) {
+  const parsed = parsePourkitBeadsMetadata(options.child.metadata);
+  if (!parsed.ok) {
+    return { ok: false, reason: parsed.reason };
+  }
+  if (options.expectedPrdRef !== void 0 && parsed.prdRef !== options.expectedPrdRef) {
+    return {
+      ok: false,
+      reason: `PRD ref mismatch: expected "${options.expectedPrdRef}", got "${parsed.prdRef}"`
+    };
+  }
+  try {
+    const issue = await options.issueProvider.fetchIssue(
+      parsed.githubIssueNumber
+    );
+    return {
+      ok: true,
+      issue,
+      beads: {
+        prdRef: parsed.prdRef,
+        childRef: parsed.childRef,
+        childId: options.child.id,
+        workspacePath: parsed.workspacePath,
+        sourcePath: parsed.sourcePath,
+        githubIssueNumber: parsed.githubIssueNumber,
+        githubIssueUrl: parsed.githubIssueUrl
+      }
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `Failed to fetch GitHub issue #${parsed.githubIssueNumber}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
 // prd-run/coordinator.ts
 function canRetryFinalReviewBlock(record) {
   if (record.status !== "blocked" || record.blockedGate !== "final-review") {
@@ -9252,6 +10559,44 @@ function validateRecordedIssueResumeEvidence(options) {
     baseBranch: guidance.baseBranch
   });
 }
+var QUEUE_FAILURE_CODES_WITHOUT_SELECTED_ISSUE = /* @__PURE__ */ new Set([
+  "missing-github-providers",
+  "missing-config",
+  "zero-processed",
+  "queue-blocked",
+  "queue-exception",
+  "missing-drain-evidence",
+  "missing-queue-started-at",
+  "missing-queue-command",
+  "missing-queue-drained-at",
+  "missing-queue-processed-count",
+  "prd-branch-mismatch",
+  "missing-child-finalization-evidence"
+]);
+function canRetryQueueGuidanceWithoutIssue(options) {
+  const { guidance, startReceipt } = options;
+  if (guidance.blockedGate !== "queue") return false;
+  if (QUEUE_FAILURE_CODES_WITHOUT_SELECTED_ISSUE.has(guidance.failureCode)) {
+    return true;
+  }
+  return guidance.failureCode === "missing-issue-identity" && !startReceipt?.queueStartedAt;
+}
+function extractIssueFromQueueError(error) {
+  if (!error || typeof error !== "object" || !("issue" in error)) {
+    return void 0;
+  }
+  const issue = error.issue;
+  if (!issue || typeof issue !== "object") return void 0;
+  const number = issue.number;
+  if (typeof number !== "number" || !Number.isInteger(number) || number <= 0) {
+    return void 0;
+  }
+  const title = issue.title;
+  return {
+    number,
+    ...typeof title === "string" ? { title } : {}
+  };
+}
 async function attemptRecordedIssueLabelProjection(options, prdRef, resumeIssueNumber, originalGuidance) {
   if (resumeIssueNumber === void 0) return true;
   try {
@@ -9277,8 +10622,109 @@ async function attemptRecordedIssueLabelProjection(options, prdRef, resumeIssueN
         });
       }
     }
-    return false;
+    return false;
+  }
+}
+function repairGuidanceRequiresOpenBeadsChild(guidance) {
+  return Boolean(
+    guidance?.issue?.beadsChildId && guidance.issue.beadsChildClosed !== true
+  );
+}
+function logCoordinatorStep(logger, level, message) {
+  logger?.step?.(level, message);
+}
+async function selectPrdRunCoordinatorMode(options) {
+  const preflight = await checkBeadsAvailability({
+    repoRoot: options.repoRoot,
+    logger: options.logger
+  });
+  if (!preflight.available) {
+    if (!options.requiresBeads) {
+      logCoordinatorStep(
+        options.logger,
+        "info",
+        `PRD Run ${options.prdRef} queue drain mode: GitHub-compatible (Beads unavailable: ${preflight.error}).`
+      );
+      return { mode: "github" };
+    }
+    logCoordinatorStep(
+      options.logger,
+      "warn",
+      `PRD Run ${options.prdRef} queue drain blocked: active Beads child state requires Beads, but Beads is unavailable (${preflight.error}).`
+    );
+    return {
+      mode: "blocked",
+      guidance: buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "beads-unavailable",
+        humanReadableReason: `Beads is not available: ${preflight.error}. ${preflight.repairGuidance}`,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: `pourkit prd-run status ${options.prdRef}`,
+        diagnostics: [preflight.error, preflight.repairGuidance]
+      })
+    };
+  }
+  const epicPresence = await checkPrdBeadsEpicPresence({
+    repoRoot: options.repoRoot,
+    prdRef: options.prdRef,
+    logger: options.logger
+  });
+  if (epicPresence.ok && epicPresence.exists) {
+    logCoordinatorStep(
+      options.logger,
+      "info",
+      `PRD Run ${options.prdRef} queue drain mode: Beads-backed (found epic ${epicPresence.epicId}).`
+    );
+    return { mode: "beads" };
+  }
+  if (epicPresence.ok && !epicPresence.exists) {
+    if (!options.requiresBeads) {
+      logCoordinatorStep(
+        options.logger,
+        "info",
+        `PRD Run ${options.prdRef} queue drain mode: GitHub-compatible (Beads epic ${epicPresence.epicId} not found).`
+      );
+      return { mode: "github" };
+    }
+    logCoordinatorStep(
+      options.logger,
+      "warn",
+      `PRD Run ${options.prdRef} queue drain blocked: Beads epic ${epicPresence.epicId} is missing but active Beads child state prevents GitHub fallback.`
+    );
+    return {
+      mode: "blocked",
+      guidance: buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "beads-epic-missing",
+        humanReadableReason: `Beads epic ${epicPresence.epicId} for ${options.prdRef} is missing, but this PRD Run has active Beads child state and cannot safely fall back to GitHub selection.`,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: `pourkit prd-run status ${options.prdRef}`,
+        diagnostics: [`Missing Beads epic: ${epicPresence.epicId}`]
+      })
+    };
   }
+  logCoordinatorStep(
+    options.logger,
+    "warn",
+    `PRD Run ${options.prdRef} queue drain blocked: failed to verify Beads epic ${epicPresence.epicId} (${epicPresence.reason}).`
+  );
+  return {
+    mode: "blocked",
+    guidance: buildPrdRunRepairGuidance({
+      blockedGate: "queue",
+      blockedStage: "queue-drain",
+      failureCode: "beads-epic-check-failed",
+      humanReadableReason: `Failed to verify Beads epic for ${options.prdRef}: ${epicPresence.reason}`,
+      repairability: "operator-action",
+      nextAction: "inspect-and-retry",
+      nextRecommendedCommand: `pourkit prd-run status ${options.prdRef}`,
+      diagnostics: [epicPresence.reason]
+    })
+  };
 }
 async function launchPrdRun(options) {
   const prdRef = normalizePrdRunRef(options.prdRef);
@@ -9502,7 +10948,10 @@ async function launchPrdRun(options) {
     }
     if (validation.guidance.issue?.number) {
       resumeIssueNumber = validation.guidance.issue.number;
-    } else {
+    } else if (!canRetryQueueGuidanceWithoutIssue({
+      guidance: validation.guidance,
+      startReceipt
+    })) {
       return buildLaunchBlockedOutcome(
         options.repoRoot,
         prdRef,
@@ -9537,7 +10986,37 @@ async function launchPrdRun(options) {
     start: startReceipt,
     repairGuidance: currentRecord?.repairGuidance
   });
-  return await launchGithubQueueDrain(
+  const modeSelection = await selectPrdRunCoordinatorMode({
+    repoRoot: options.repoRoot,
+    prdRef,
+    logger: options.logger,
+    requiresBeads: repairGuidanceRequiresOpenBeadsChild(
+      currentRecord?.repairGuidance
+    )
+  });
+  if (modeSelection.mode === "blocked") {
+    return buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      modeSelection.guidance,
+      plan,
+      startOutcome,
+      targetName,
+      startReceipt
+    );
+  }
+  if (modeSelection.mode === "github") {
+    return await launchGithubQueueDrain(
+      options,
+      prdRef,
+      startReceipt,
+      targetName,
+      plan,
+      startOutcome,
+      resumeIssueNumber
+    );
+  }
+  return await launchBeadsQueueDrain(
     options,
     prdRef,
     startReceipt,
@@ -9556,21 +11035,299 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       buildPrdRunRepairGuidance({
         blockedGate: "queue",
         blockedStage: "queue-drain",
-        failureCode: "missing-github-providers",
-        humanReadableReason: reason,
+        failureCode: "missing-github-providers",
+        humanReadableReason: reason,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: "pourkit prd-run launch --with-providers",
+        diagnostics: [
+          "Missing one or more required providers for GitHub-backed mode."
+        ]
+      }),
+      plan,
+      startOutcome,
+      targetName,
+      startReceipt
+    );
+  }
+  if (!startReceipt) {
+    return buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "branch-state",
+        blockedStage: "start-validation",
+        failureCode: "missing-start-receipt",
+        humanReadableReason: `PRD Run ${prdRef} is missing start receipt before GitHub queue drain.`,
+        repairability: "automatic-retry-safe",
+        nextAction: "rerun-prd-run-launch",
+        nextRecommendedCommand: "pourkit prd-run launch"
+      }),
+      plan,
+      startOutcome,
+      targetName
+    );
+  }
+  if (!options.config) {
+    const reason = `PRD Run ${prdRef} requires config for GitHub-backed queue drain.`;
+    return buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "missing-config",
+        humanReadableReason: reason,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: "pourkit prd-run launch --with-config",
+        diagnostics: ["Missing config for GitHub-backed mode."]
+      }),
+      plan,
+      startOutcome,
+      targetName,
+      startReceipt
+    );
+  }
+  const issueProvider = options.issueProvider;
+  const prProvider = options.prProvider;
+  const executionProvider = options.executionProvider;
+  const logger = options.logger;
+  const originalGuidance = readPrdRun(options.repoRoot, prdRef).record?.repairGuidance;
+  logCoordinatorStep(
+    logger,
+    "info",
+    `Starting GitHub-compatible PRD queue drain for ${prdRef}.`
+  );
+  try {
+    const outcome = await runQueueCommand({
+      targetName,
+      config: options.config,
+      issueProvider,
+      prProvider,
+      executionProvider,
+      force: false,
+      loop: true,
+      logger,
+      repoRoot: options.repoRoot,
+      prdRef,
+      queueRunContext: {
+        prdRef,
+        prdBranch: startReceipt.prdBranch,
+        ...resumeIssueNumber !== void 0 ? { resumeIssueNumber } : {}
+      }
+    });
+    if (outcome.selected === null && outcome.code === "drained") {
+      if (outcome.processedCount === 0) {
+        const diagnostics = [
+          "Queue drained without processing issues. No PRD-scoped candidates or runnable Issues."
+        ];
+        const result2 = buildLaunchBlockedOutcome(
+          options.repoRoot,
+          prdRef,
+          buildPrdRunRepairGuidance({
+            blockedGate: "queue",
+            blockedStage: "queue-drain",
+            failureCode: "zero-processed",
+            humanReadableReason: diagnostics[0],
+            repairability: "automatic-retry-safe",
+            nextAction: "rerun-prd-run-launch",
+            nextRecommendedCommand: "pourkit prd-run launch",
+            diagnostics
+          }),
+          plan,
+          startOutcome,
+          targetName,
+          startReceipt
+        );
+        const projectionOk2 = await attemptRecordedIssueLabelProjection(
+          options,
+          prdRef,
+          resumeIssueNumber,
+          originalGuidance
+        );
+        if (!projectionOk2 && originalGuidance) {
+          const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
+          return {
+            kind: "blocked",
+            prdRef,
+            guidance: updatedRecord.repairGuidance,
+            start: startOutcome,
+            resume: plan
+          };
+        }
+        return result2;
+      }
+      startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
+      startReceipt.queueProcessedCount = outcome.processedCount;
+      const prdBranch = startReceipt.prdBranch ?? prdRef;
+      writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
+      const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
+      if (drainRecord) {
+        const drainContext = {
+          prdRef,
+          baseBranch: startReceipt.startBaseBranch,
+          prdBranch,
+          allChildIssuesFinalizedIntoPrdBranch: outcome.allProcessedIssuesFinalizedIntoPrdBranch === true
+        };
+        const terminalEvidence = validatePrdRunTerminalEvidence(
+          drainRecord,
+          drainContext
+        );
+        if (!terminalEvidence.ok) {
+          return buildLaunchBlockedOutcome(
+            options.repoRoot,
+            prdRef,
+            terminalEvidence.guidance,
+            plan,
+            startOutcome,
+            targetName,
+            startReceipt
+          );
+        }
+      }
+      writeTerminalRecord(
+        options.repoRoot,
+        prdRef,
+        "completed_prd_branch",
+        targetName,
+        startReceipt,
+        prdBranch
+      );
+      return {
+        kind: "completed",
+        prdRef,
+        status: "completed_prd_branch",
+        prdBranch,
+        diagnostics: [
+          `PRD Run completed on branch ${prdBranch}. Next: checkout ${prdBranch} for human review, or use release promotion workflow when ready.`
+        ],
+        start: startOutcome,
+        resume: plan
+      };
+    }
+    if (outcome.selected === null) {
+      const diagnostics = [outcome.reason];
+      const result2 = buildLaunchBlockedOutcome(
+        options.repoRoot,
+        prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "queue-blocked",
+          humanReadableReason: outcome.reason,
+          repairability: "automatic-retry-safe",
+          nextAction: "rerun-prd-run-launch",
+          nextRecommendedCommand: "pourkit prd-run launch",
+          diagnostics
+        }),
+        plan,
+        startOutcome,
+        targetName,
+        startReceipt
+      );
+      const projectionOk2 = await attemptRecordedIssueLabelProjection(
+        options,
+        prdRef,
+        resumeIssueNumber,
+        originalGuidance
+      );
+      if (!projectionOk2 && originalGuidance) {
+        const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
+        return {
+          kind: "blocked",
+          prdRef,
+          guidance: updatedRecord.repairGuidance,
+          start: startOutcome,
+          resume: plan
+        };
+      }
+      return result2;
+    }
+    const outcomeReason = `Unexpected queue outcome: selected issue ${outcome.selected.number}`;
+    const outcomeDiagnostics = [outcomeReason];
+    const result = buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "unexpected-queue-outcome",
+        humanReadableReason: outcomeReason,
         repairability: "operator-action",
         nextAction: "inspect-and-retry",
-        nextRecommendedCommand: "pourkit prd-run launch --with-providers",
-        diagnostics: [
-          "Missing one or more required providers for GitHub-backed mode."
-        ]
+        nextRecommendedCommand: "pourkit prd-run launch",
+        diagnostics: outcomeDiagnostics,
+        issue: {
+          number: outcome.selected.number,
+          title: outcome.selected.title
+        }
+      }),
+      plan,
+      startOutcome,
+      targetName,
+      startReceipt
+    );
+    const projectionOk = await attemptRecordedIssueLabelProjection(
+      options,
+      prdRef,
+      resumeIssueNumber,
+      originalGuidance
+    );
+    if (!projectionOk && originalGuidance) {
+      const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
+      return {
+        kind: "blocked",
+        prdRef,
+        guidance: updatedRecord.repairGuidance,
+        start: startOutcome,
+        resume: plan
+      };
+    }
+    return result;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const diagnostics = [msg];
+    const issue = extractIssueFromQueueError(error);
+    const result = buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "queue-exception",
+        humanReadableReason: msg,
+        repairability: "automatic-retry-safe",
+        nextAction: "rerun-prd-run-launch",
+        nextRecommendedCommand: "pourkit prd-run launch",
+        diagnostics,
+        issue
       }),
       plan,
       startOutcome,
       targetName,
       startReceipt
     );
+    const projectionOk = await attemptRecordedIssueLabelProjection(
+      options,
+      prdRef,
+      resumeIssueNumber,
+      originalGuidance
+    );
+    if (!projectionOk && originalGuidance) {
+      const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
+      return {
+        kind: "blocked",
+        prdRef,
+        guidance: updatedRecord.repairGuidance,
+        start: startOutcome,
+        resume: plan
+      };
+    }
+    return result;
   }
+}
+async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName, plan, startOutcome, resumeIssueNumber) {
   if (!startReceipt) {
     return buildLaunchBlockedOutcome(
       options.repoRoot,
@@ -9579,7 +11336,7 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
         blockedGate: "branch-state",
         blockedStage: "start-validation",
         failureCode: "missing-start-receipt",
-        humanReadableReason: `PRD Run ${prdRef} is missing start receipt before GitHub queue drain.`,
+        humanReadableReason: `PRD Run ${prdRef} is missing start receipt before Beads queue drain.`,
         repairability: "automatic-retry-safe",
         nextAction: "rerun-prd-run-launch",
         nextRecommendedCommand: "pourkit prd-run launch"
@@ -9590,7 +11347,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
     );
   }
   if (!options.config) {
-    const reason = `PRD Run ${prdRef} requires config for GitHub-backed queue drain.`;
     return buildLaunchBlockedOutcome(
       options.repoRoot,
       prdRef,
@@ -9598,11 +11354,54 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
         blockedGate: "queue",
         blockedStage: "queue-drain",
         failureCode: "missing-config",
-        humanReadableReason: reason,
+        humanReadableReason: `PRD Run ${prdRef} requires config for Beads-backed queue drain.`,
         repairability: "operator-action",
         nextAction: "inspect-and-retry",
         nextRecommendedCommand: "pourkit prd-run launch --with-config",
-        diagnostics: ["Missing config for GitHub-backed mode."]
+        diagnostics: ["Missing config for Beads-backed mode."]
+      }),
+      plan,
+      startOutcome,
+      targetName,
+      startReceipt
+    );
+  }
+  if (!options.issueProvider) {
+    return buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "missing-issue-provider",
+        humanReadableReason: `PRD Run ${prdRef} requires issueProvider for Beads-backed queue drain.`,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: "pourkit prd-run launch --with-providers",
+        diagnostics: ["Missing issueProvider for Beads-backed mode."]
+      }),
+      plan,
+      startOutcome,
+      targetName,
+      startReceipt
+    );
+  }
+  if (!options.prProvider || !options.executionProvider || !options.logger) {
+    const reason = `PRD Run ${prdRef} requires prProvider, executionProvider, and logger for Beads-backed queue drain.`;
+    return buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "missing-providers",
+        humanReadableReason: reason,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: "pourkit prd-run launch --with-providers",
+        diagnostics: [
+          "Missing one or more required providers for Beads-backed mode."
+        ]
       }),
       plan,
       startOutcome,
@@ -9614,166 +11413,262 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
   const prProvider = options.prProvider;
   const executionProvider = options.executionProvider;
   const logger = options.logger;
+  const processedResults = [];
   const originalGuidance = readPrdRun(options.repoRoot, prdRef).record?.repairGuidance;
-  try {
-    const outcome = await runQueueCommand({
+  logCoordinatorStep(
+    logger,
+    "info",
+    `Starting Beads-backed PRD queue drain for ${prdRef}.`
+  );
+  const preflight = await checkBeadsAvailability({
+    repoRoot: options.repoRoot,
+    logger
+  });
+  if (!preflight.available) {
+    return buildLaunchBlockedOutcome(
+      options.repoRoot,
+      prdRef,
+      buildPrdRunRepairGuidance({
+        blockedGate: "queue",
+        blockedStage: "queue-drain",
+        failureCode: "beads-unavailable",
+        humanReadableReason: `Beads is not available: ${preflight.error}. ${preflight.repairGuidance}`,
+        repairability: "operator-action",
+        nextAction: "inspect-and-retry",
+        nextRecommendedCommand: `pourkit prd-run status ${prdRef}`,
+        diagnostics: [preflight.error, preflight.repairGuidance]
+      }),
+      plan,
+      startOutcome,
       targetName,
-      config: options.config,
-      issueProvider,
-      prProvider,
-      executionProvider,
-      force: false,
-      loop: true,
-      logger,
-      repoRoot: options.repoRoot,
+      startReceipt
+    );
+  }
+  if (resumeIssueNumber !== void 0) {
+    const resumeIssue = originalGuidance?.issue;
+    const resumeBeadsContext = resumeIssue?.beadsChildId && resumeIssue.beadsChildRef && !resumeIssue.beadsChildClosed ? {
       prdRef,
-      queueRunContext: {
+      childRef: resumeIssue.beadsChildRef,
+      childId: resumeIssue.beadsChildId,
+      githubIssueNumber: resumeIssueNumber
+    } : void 0;
+    let fetchedIssue;
+    try {
+      fetchedIssue = await issueProvider.fetchIssue(resumeIssueNumber);
+    } catch (error) {
+      return buildLaunchBlockedOutcome(
+        options.repoRoot,
         prdRef,
-        prdBranch: startReceipt.prdBranch,
-        ...resumeIssueNumber !== void 0 ? { resumeIssueNumber } : {}
-      }
-    });
-    if (outcome.selected === null && outcome.code === "drained") {
-      if (outcome.processedCount === 0) {
-        const diagnostics = [
-          "Queue drained without processing issues. No PRD-scoped candidates or runnable Issues."
-        ];
-        const result2 = buildLaunchBlockedOutcome(
-          options.repoRoot,
-          prdRef,
-          buildPrdRunRepairGuidance({
-            blockedGate: "queue",
-            blockedStage: "queue-drain",
-            failureCode: "zero-processed",
-            humanReadableReason: diagnostics[0],
-            repairability: "automatic-retry-safe",
-            nextAction: "rerun-prd-run-launch",
-            nextRecommendedCommand: "pourkit prd-run launch",
-            diagnostics
-          }),
-          plan,
-          startOutcome,
-          targetName,
-          startReceipt
-        );
-        const projectionOk2 = await attemptRecordedIssueLabelProjection(
-          options,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "resume-fetch-failed",
+          humanReadableReason: `Failed to fetch resume issue #${resumeIssueNumber} from Beads metadata.`,
+          repairability: "automatic-retry-safe",
+          nextAction: "rerun-prd-run-launch",
+          nextRecommendedCommand: "pourkit prd-run launch",
+          diagnostics: [error instanceof Error ? error.message : String(error)]
+        }),
+        plan,
+        startOutcome,
+        targetName,
+        startReceipt
+      );
+    }
+    try {
+      const runResult = await runClaimedPrdIssueCommand({
+        targetName,
+        config: options.config,
+        issueProvider,
+        prProvider,
+        executionProvider,
+        force: false,
+        logger,
+        repoRoot: options.repoRoot,
+        issue: fetchedIssue,
+        queueRunContext: {
           prdRef,
-          resumeIssueNumber,
-          originalGuidance
-        );
-        if (!projectionOk2 && originalGuidance) {
-          const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
-          return {
-            kind: "blocked",
-            prdRef,
-            guidance: updatedRecord.repairGuidance,
-            start: startOutcome,
-            resume: plan
-          };
+          prdBranch: startReceipt.prdBranch,
+          ...resumeBeadsContext ? { beadsChild: resumeBeadsContext } : {}
         }
-        return result2;
-      }
+      });
+      processedResults.push({
+        beadsChildId: resumeIssue?.beadsChildId ?? "resumed",
+        issueNumber: runResult.selected.number,
+        publicationStatus: runResult.runResult.publicationStatus
+      });
       startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
-      startReceipt.queueProcessedCount = outcome.processedCount;
-      const prdBranch = startReceipt.prdBranch ?? prdRef;
-      writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
-      const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
-      if (drainRecord) {
-        const drainContext = {
-          prdRef,
-          baseBranch: startReceipt.startBaseBranch,
-          prdBranch,
-          allChildIssuesFinalizedIntoPrdBranch: outcome.allProcessedIssuesFinalizedIntoPrdBranch === true
-        };
-        const terminalEvidence = validatePrdRunTerminalEvidence(
-          drainRecord,
-          drainContext
+      startReceipt.queueProcessedCount = processedResults.length;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return buildLaunchBlockedOutcome(
+        options.repoRoot,
+        prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "resume-issue-failed",
+          humanReadableReason: msg,
+          repairability: "automatic-retry-safe",
+          nextAction: "rerun-prd-run-launch",
+          nextRecommendedCommand: "pourkit prd-run launch",
+          diagnostics: [msg],
+          issue: resumeIssue ? {
+            number: fetchedIssue.number,
+            title: fetchedIssue.title,
+            beadsChildId: resumeIssue.beadsChildId,
+            beadsChildRef: resumeIssue.beadsChildRef,
+            beadsChildClosed: resumeIssue.beadsChildClosed || msg.startsWith("Projection failure after Beads close")
+          } : void 0
+        }),
+        plan,
+        startOutcome,
+        targetName,
+        startReceipt
+      );
+    }
+  }
+  let beadsClaimAttempted = false;
+  while (true) {
+    const claimResult = await claimReadyPrdChild({
+      repoRoot: options.repoRoot,
+      prdRef,
+      logger
+    });
+    if (!claimResult.ok) {
+      if (claimResult.reason === "no-ready-child") {
+        logCoordinatorStep(
+          logger,
+          "info",
+          `Beads-backed PRD queue drain for ${prdRef} found no additional ready child work.`
         );
-        if (!terminalEvidence.ok) {
-          return buildLaunchBlockedOutcome(
-            options.repoRoot,
-            prdRef,
-            terminalEvidence.guidance,
-            plan,
-            startOutcome,
-            targetName,
-            startReceipt
-          );
-        }
+        break;
       }
-      writeTerminalRecord(
+      return buildLaunchBlockedOutcome(
         options.repoRoot,
         prdRef,
-        "completed_prd_branch",
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "beads-claim-failed",
+          humanReadableReason: `Beads claim failed for PRD ${prdRef} epic ${claimResult.epicId}.`,
+          repairability: "operator-action",
+          nextAction: "inspect-and-retry",
+          nextRecommendedCommand: `pourkit prd-run status ${prdRef}`,
+          diagnostics: [`Beads claim error for epic ${claimResult.epicId}.`]
+        }),
+        plan,
+        startOutcome,
         targetName,
-        startReceipt,
-        prdBranch
+        startReceipt
       );
-      return {
-        kind: "completed",
+    }
+    beadsClaimAttempted = true;
+    logCoordinatorStep(
+      logger,
+      "info",
+      `Claimed Beads child ${claimResult.child.id} for ${prdRef}; mapping to GitHub Issue context.`
+    );
+    const contextResult = await buildIssueContextFromBeadsChild({
+      child: claimResult.child,
+      issueProvider,
+      expectedPrdRef: prdRef
+    });
+    if (!contextResult.ok) {
+      return buildLaunchBlockedOutcome(
+        options.repoRoot,
         prdRef,
-        status: "completed_prd_branch",
-        prdBranch,
-        diagnostics: [
-          `PRD Run completed on branch ${prdBranch}. Next: checkout ${prdBranch} for human review, or use release promotion workflow when ready.`
-        ],
-        start: startOutcome,
-        resume: plan
-      };
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "beads-context-mapping-failed",
+          humanReadableReason: `Failed to map Beads child ${claimResult.child.id} to Issue context: ${contextResult.reason}`,
+          repairability: "operator-action",
+          nextAction: "inspect-and-retry",
+          nextRecommendedCommand: `pourkit prd-run status ${prdRef}`,
+          diagnostics: [contextResult.reason]
+        }),
+        plan,
+        startOutcome,
+        targetName,
+        startReceipt
+      );
     }
-    if (outcome.selected === null) {
-      const diagnostics = [outcome.reason];
-      const result2 = buildLaunchBlockedOutcome(
+    try {
+      logCoordinatorStep(
+        logger,
+        "info",
+        `Running GitHub Issue #${contextResult.issue.number} from Beads child ${contextResult.beads.childId}.`
+      );
+      const runResult = await runClaimedPrdIssueCommand({
+        targetName,
+        config: options.config,
+        issueProvider,
+        prProvider,
+        executionProvider,
+        force: false,
+        logger,
+        repoRoot: options.repoRoot,
+        issue: contextResult.issue,
+        queueRunContext: {
+          prdRef,
+          prdBranch: startReceipt.prdBranch,
+          beadsChild: contextResult.beads
+        }
+      });
+      processedResults.push({
+        beadsChildId: claimResult.child.id,
+        issueNumber: runResult.selected.number,
+        publicationStatus: runResult.runResult.publicationStatus
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      const beadsChildClosed = msg.startsWith(
+        "Projection failure after Beads close"
+      );
+      return buildLaunchBlockedOutcome(
         options.repoRoot,
         prdRef,
         buildPrdRunRepairGuidance({
           blockedGate: "queue",
           blockedStage: "queue-drain",
-          failureCode: "queue-blocked",
-          humanReadableReason: outcome.reason,
+          failureCode: "beads-issue-run-failed",
+          humanReadableReason: msg,
           repairability: "automatic-retry-safe",
           nextAction: "rerun-prd-run-launch",
           nextRecommendedCommand: "pourkit prd-run launch",
-          diagnostics
+          diagnostics: [msg],
+          issue: {
+            number: contextResult.issue.number,
+            title: contextResult.issue.title,
+            beadsChildId: contextResult.beads.childId,
+            beadsChildRef: contextResult.beads.childRef,
+            beadsChildClosed
+          }
         }),
         plan,
         startOutcome,
         targetName,
         startReceipt
       );
-      const projectionOk2 = await attemptRecordedIssueLabelProjection(
-        options,
-        prdRef,
-        resumeIssueNumber,
-        originalGuidance
-      );
-      if (!projectionOk2 && originalGuidance) {
-        const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
-        return {
-          kind: "blocked",
-          prdRef,
-          guidance: updatedRecord.repairGuidance,
-          start: startOutcome,
-          resume: plan
-        };
-      }
-      return result2;
     }
-    const outcomeReason = `Unexpected queue outcome: selected issue ${outcome.selected.number}`;
-    const outcomeDiagnostics = [outcomeReason];
+  }
+  if (processedResults.length === 0 && !beadsClaimAttempted) {
+    const diagnostics = [
+      "Beads-backed PRD drain found no ready children. Zero child work is not terminal completion evidence."
+    ];
     const result = buildLaunchBlockedOutcome(
       options.repoRoot,
       prdRef,
       buildPrdRunRepairGuidance({
         blockedGate: "queue",
         blockedStage: "queue-drain",
-        failureCode: "unexpected-queue-outcome",
-        humanReadableReason: outcomeReason,
-        repairability: "operator-action",
-        nextAction: "inspect-and-retry",
+        failureCode: "zero-processed",
+        humanReadableReason: diagnostics[0],
+        repairability: "automatic-retry-safe",
+        nextAction: "rerun-prd-run-launch",
         nextRecommendedCommand: "pourkit prd-run launch",
-        diagnostics: outcomeDiagnostics
+        diagnostics
       }),
       plan,
       startOutcome,
@@ -9797,45 +11692,54 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       };
     }
     return result;
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    const diagnostics = [msg];
-    const result = buildLaunchBlockedOutcome(
-      options.repoRoot,
-      prdRef,
-      buildPrdRunRepairGuidance({
-        blockedGate: "queue",
-        blockedStage: "queue-drain",
-        failureCode: "queue-exception",
-        humanReadableReason: msg,
-        repairability: "automatic-retry-safe",
-        nextAction: "rerun-prd-run-launch",
-        nextRecommendedCommand: "pourkit prd-run launch",
-        diagnostics
-      }),
-      plan,
-      startOutcome,
-      targetName,
-      startReceipt
-    );
-    const projectionOk = await attemptRecordedIssueLabelProjection(
-      options,
+  }
+  startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
+  startReceipt.queueProcessedCount = processedResults.length;
+  const prdBranch = startReceipt.prdBranch ?? prdRef;
+  writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
+  const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
+  if (drainRecord) {
+    const drainContext = {
       prdRef,
-      resumeIssueNumber,
-      originalGuidance
+      baseBranch: startReceipt.startBaseBranch,
+      prdBranch,
+      allChildIssuesFinalizedIntoPrdBranch: processedResults.length > 0 && processedResults.every((r) => r.publicationStatus === "merged")
+    };
+    const terminalEvidence = validatePrdRunTerminalEvidence(
+      drainRecord,
+      drainContext
     );
-    if (!projectionOk && originalGuidance) {
-      const updatedRecord = readPrdRun(options.repoRoot, prdRef).record;
-      return {
-        kind: "blocked",
+    if (!terminalEvidence.ok) {
+      return buildLaunchBlockedOutcome(
+        options.repoRoot,
         prdRef,
-        guidance: updatedRecord.repairGuidance,
-        start: startOutcome,
-        resume: plan
-      };
+        terminalEvidence.guidance,
+        plan,
+        startOutcome,
+        targetName,
+        startReceipt
+      );
     }
-    return result;
   }
+  writeTerminalRecord(
+    options.repoRoot,
+    prdRef,
+    "completed_prd_branch",
+    targetName,
+    startReceipt,
+    prdBranch
+  );
+  return {
+    kind: "completed",
+    prdRef,
+    status: "completed_prd_branch",
+    prdBranch,
+    diagnostics: [
+      `PRD Run completed on branch ${prdBranch}. Next: checkout ${prdBranch} for human review, or use release promotion workflow when ready.`
+    ],
+    start: startOutcome,
+    resume: plan
+  };
 }
 
 // prd-run/final-review-validation.ts
@@ -10365,11 +12269,11 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
 import { existsSync as existsSync16, statSync } from "fs";
 import {
   copyFile,
-  mkdir as mkdir4,
-  readFile as readFile4,
-  readdir,
+  mkdir as mkdir5,
+  readFile as readFile5,
+  readdir as readdir2,
   rename,
-  writeFile
+  writeFile as writeFile2
 } from "fs/promises";
 import { createHash, randomUUID } from "crypto";
 import path5 from "path";
@@ -10674,6 +12578,50 @@ icm --db .pourkit/icm/memories.db topics                                # list a
 <!-- icm:end -->`;
 }
 
+// shared/managed-block.ts
+var MANAGED_BLOCK_BEGIN = "<!-- BEGIN POURKIT MANAGED BLOCK -->";
+var MANAGED_BLOCK_END = "<!-- END POURKIT MANAGED BLOCK -->";
+var MANAGED_BLOCK_PATTERN = new RegExp(
+  `${escapeRegExp3(MANAGED_BLOCK_BEGIN)}\\r?\\n[\\s\\S]*?${escapeRegExp3(
+    MANAGED_BLOCK_END
+  )}[ \\t]*(?:\\r?\\n)?`,
+  "g"
+);
+function escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildManagedBlock(content) {
+  const body = content.endsWith("\n") ? content : `${content}
+`;
+  return `${MANAGED_BLOCK_BEGIN}
+${body}${MANAGED_BLOCK_END}
+`;
+}
+function upsertManagedBlock(existing, content) {
+  const blockContent = buildManagedBlock(content);
+  const matches = [...existing.matchAll(MANAGED_BLOCK_PATTERN)];
+  if (matches.length === 0) {
+    if (existing.length === 0) {
+      return blockContent;
+    }
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    return `${existing}${separator}${blockContent}`;
+  }
+  let next = "";
+  let cursor = 0;
+  for (const [index, match] of matches.entries()) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    next += existing.slice(cursor, start);
+    if (index === 0) {
+      next += blockContent;
+    }
+    cursor = end;
+  }
+  next += existing.slice(cursor);
+  return next;
+}
+
 // commands/init.ts
 var execFileAsync2 = promisify2(execFile2);
 var __filename2 = fileURLToPath2(import.meta.url);
@@ -11020,7 +12968,7 @@ function generateGitignoreBlock() {
 }
 async function walkDir(dir) {
   const files = [];
-  const entries = await readdir(dir, { withFileTypes: true });
+  const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
     const full = path5.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -11032,7 +12980,7 @@ async function walkDir(dir) {
   return files;
 }
 async function computeFileChecksum(filePath) {
-  const content = await readFile4(filePath);
+  const content = await readFile5(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
@@ -11121,7 +13069,7 @@ async function discoverOpenCodeAgentFiles(sourceRoot) {
     (candidate) => existsSync16(candidate) && statSync(candidate).isDirectory()
   );
   if (!agentsDir) return [];
-  const entries = await readdir(agentsDir, { withFileTypes: true });
+  const entries = await readdir2(agentsDir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path5.join(agentsDir, entry.name));
 }
 async function discoverRootDomainDocs(root) {
@@ -11134,7 +13082,7 @@ async function discoverRootDomainDocs(root) {
   }
   const adrDir = path5.join(root, "docs", "adr");
   if (existsSync16(adrDir)) {
-    const entries = await readdir(adrDir, { withFileTypes: true });
+    const entries = await readdir2(adrDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
         docs.push(path5.join(adrDir, entry.name));
@@ -11449,7 +13397,7 @@ async function planInit(options) {
           "skills"
         );
         const projectionSkillsDir = path5.join(targetRoot, ".agents", "skills");
-        const entries = await readdir(s, { withFileTypes: true });
+        const entries = await readdir2(s, { withFileTypes: true });
         const skillNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
         const addonManagedDir = path5.join(
           targetRoot,
@@ -11515,7 +13463,7 @@ async function planInit(options) {
               });
               continue;
             }
-            const sourceContent = await readFile4(file, "utf-8");
+            const sourceContent = await readFile5(file, "utf-8");
             const managedSourcePath = isReleaseAddon ? `.pourkit/managed/addons/release/skills/${skillName}/${relPath}` : `.pourkit/managed/skills/${skillName}/${relPath}`;
             operations.push({
               kind: "create",
@@ -11594,7 +13542,7 @@ async function planInit(options) {
       }
       let hasPackageJson = true;
       try {
-        await readFile4(path5.join(targetRoot, "package.json"), "utf-8");
+        await readFile5(path5.join(targetRoot, "package.json"), "utf-8");
       } catch {
         hasPackageJson = false;
       }
@@ -11930,9 +13878,7 @@ Do not edit this file.
           reason: "Init AGENTS.md with Pourkit managed block",
           requiresConfirmation: false,
           destructive: false,
-          content: `${MANAGED_BLOCK_BEGIN}
-${managedAgentContent}${MANAGED_BLOCK_END}
-`
+          content: buildManagedBlock(managedAgentContent)
         });
       }
       const hasExistingClaude = operations.some(
@@ -11946,9 +13892,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
           reason: "Init CLAUDE.md with Pourkit managed block",
           requiresConfirmation: false,
           destructive: false,
-          content: `${MANAGED_BLOCK_BEGIN}
-${managedAgentContent}${MANAGED_BLOCK_END}
-`
+          content: buildManagedBlock(managedAgentContent)
         });
       }
       const gitignoreTarget = path5.join(targetRoot, ".gitignore");
@@ -11961,9 +13905,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
           reason: "Init .gitignore with Pourkit entries",
           requiresConfirmation: false,
           destructive: false,
-          content: `${MANAGED_BLOCK_BEGIN}
-${gitignoreContent}${MANAGED_BLOCK_END}
-`
+          content: buildManagedBlock(gitignoreContent)
         });
       } else {
         operations.push({
@@ -12388,32 +14330,18 @@ async function promptForInitChoices(plan, current) {
 }
 async function writeFileAtomic(filePath, content) {
   const tmpPath = `${filePath}.tmp.${randomUUID()}`;
-  await writeFile(tmpPath, content, "utf-8");
+  await writeFile2(tmpPath, content, "utf-8");
   await rename(tmpPath, filePath);
 }
-var MANAGED_BLOCK_BEGIN = "<!-- BEGIN POURKIT MANAGED BLOCK -->";
-var MANAGED_BLOCK_END = "<!-- END POURKIT MANAGED BLOCK -->";
 async function updateManagedBlock(filePath, content) {
-  const blockContent = `${MANAGED_BLOCK_BEGIN}
-${content}${MANAGED_BLOCK_END}
-`;
   if (!existsSync16(filePath)) {
     const dir = path5.dirname(filePath);
-    await mkdir4(dir, { recursive: true });
-    await writeFileAtomic(filePath, blockContent);
+    await mkdir5(dir, { recursive: true });
+    await writeFileAtomic(filePath, buildManagedBlock(content));
     return;
   }
-  const existing = await readFile4(filePath, "utf-8");
-  const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN);
-  const endIdx = existing.indexOf(MANAGED_BLOCK_END);
-  if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
-    const before = existing.slice(0, beginIdx);
-    const after = existing.slice(endIdx + MANAGED_BLOCK_END.length);
-    await writeFileAtomic(filePath, before + blockContent + after);
-  } else {
-    const suffix = existing.endsWith("\n") ? "" : "\n";
-    await writeFileAtomic(filePath, existing + suffix + blockContent + "\n");
-  }
+  const existing = await readFile5(filePath, "utf-8");
+  await writeFileAtomic(filePath, upsertManagedBlock(existing, content));
 }
 async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
   const manifestDir = path5.join(plan.targetRoot, ".pourkit");
@@ -12451,7 +14379,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     workflowPack: buildWorkflowPackMetadata(plan.enabledAddons ?? []),
     assets
   };
-  await mkdir4(manifestDir, { recursive: true });
+  await mkdir5(manifestDir, { recursive: true });
   await writeFileAtomic(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
   return manifest;
 }
@@ -12477,7 +14405,7 @@ async function applyInitPlan(plan, options) {
             continue;
           }
           const dir = path5.dirname(op.path);
-          await mkdir4(dir, { recursive: true });
+          await mkdir5(dir, { recursive: true });
           await writeFileAtomic(op.path, op.content ?? "");
           applied++;
           break;
@@ -12496,7 +14424,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
           } else {
             const dir = path5.dirname(op.path);
-            await mkdir4(dir, { recursive: true });
+            await mkdir5(dir, { recursive: true });
             await copyFile(op.sourcePath, op.path);
             applied++;
           }
@@ -12521,7 +14449,7 @@ async function applyInitPlan(plan, options) {
             continue;
           }
           const dir = path5.dirname(op.path);
-          await mkdir4(dir, { recursive: true });
+          await mkdir5(dir, { recursive: true });
           await rename(op.sourcePath, op.path);
           applied++;
           break;
@@ -12838,13 +14766,13 @@ Init applied: ${result.applied} operations applied, ${result.skipped} skipped.`
 // commands/memory-init.ts
 import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync5 } from "fs";
 import { execFile as execFile3 } from "child_process";
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile3);
 async function runMemoryInitCommand(options) {
   const cwd = options.cwd ?? process.cwd();
   const execCommand = options.execCommand ?? execFileAsync3;
-  const configPath = join17(cwd, ".pourkit", "config.json");
+  const configPath = join20(cwd, ".pourkit", "config.json");
   if (!existsSync17(configPath)) {
     return {
       ok: false,
@@ -12876,8 +14804,8 @@ async function runMemoryInitCommand(options) {
     const next = { ...raw, memory };
     writeFileSync5(configPath, JSON.stringify(next, null, 2) + "\n");
   }
-  const memoryDir = join17(cwd, ".pourkit", "icm");
-  const memoryDbPath = join17(memoryDir, "memories.db");
+  const memoryDir = join20(cwd, ".pourkit", "icm");
+  const memoryDbPath = join20(memoryDir, "memories.db");
   mkdirSync8(memoryDir, { recursive: true });
   let dbInitialized = false;
   let warning;
@@ -12891,7 +14819,7 @@ async function runMemoryInitCommand(options) {
   } catch {
     warning = "ICM is not available or could not initialize .pourkit/icm/memories.db. Install ICM and run `pourkit doctor` to verify repo-scoped memory setup.";
   }
-  const gitignorePath = join17(cwd, ".gitignore");
+  const gitignorePath = join20(cwd, ".gitignore");
   updateManagedBlockSync(gitignorePath, generateGitignoreBlock());
   const managed = await generateManagedAgentInstructions({
     sourceRoot: cwd,
@@ -12899,14 +14827,14 @@ async function runMemoryInitCommand(options) {
   });
   let updatedAgentFile = false;
   for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
-    const agentPath = join17(cwd, fileName);
+    const agentPath = join20(cwd, fileName);
     if (existsSync17(agentPath)) {
       updateManagedBlockSync(agentPath, managed);
       updatedAgentFile = true;
     }
   }
   if (!updatedAgentFile) {
-    updateManagedBlockSync(join17(cwd, "AGENTS.md"), managed);
+    updateManagedBlockSync(join20(cwd, "AGENTS.md"), managed);
   }
   return {
     ok: true,
@@ -12917,24 +14845,12 @@ async function runMemoryInitCommand(options) {
   };
 }
 function updateManagedBlockSync(filePath, content) {
-  const blockContent = `${MANAGED_BLOCK_BEGIN}
-${content}${MANAGED_BLOCK_END}
-`;
   if (!existsSync17(filePath)) {
-    writeFileSync5(filePath, blockContent);
+    writeFileSync5(filePath, buildManagedBlock(content));
     return;
   }
   const existing = readFileSync17(filePath, "utf8");
-  const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN);
-  const endIdx = existing.indexOf(MANAGED_BLOCK_END);
-  if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
-    const before = existing.slice(0, beginIdx);
-    const after = existing.slice(endIdx + MANAGED_BLOCK_END.length);
-    writeFileSync5(filePath, before + blockContent + after);
-    return;
-  }
-  const suffix = existing.endsWith("\n") ? "" : "\n";
-  writeFileSync5(filePath, `${existing}${suffix}${blockContent}`);
+  writeFileSync5(filePath, upsertManagedBlock(existing, content));
 }
 
 // commands/serena.ts
@@ -13054,17 +14970,17 @@ async function runSerenaStatusCommand(options) {
 
 // commands/config-schema.ts
 import { readFileSync as readFileSync18, existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile2, readdir as readdir2 } from "fs/promises";
-import { resolve as resolve3, dirname as dirname5, relative as relative3 } from "path";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
+import { resolve as resolve4, dirname as dirname6, relative as relative4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import Ajv2 from "ajv";
 init_common();
 var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname5(__filename3);
+var __dirname3 = dirname6(__filename3);
 function resolvePackagedAssetPath2(fileName) {
   const candidates = [
-    resolve3(__dirname3, "schema", fileName),
-    resolve3(__dirname3, "../schema", fileName)
+    resolve4(__dirname3, "schema", fileName),
+    resolve4(__dirname3, "../schema", fileName)
   ];
   return candidates.find((candidate) => existsSync18(candidate)) ?? candidates[0];
 }
@@ -13091,15 +15007,15 @@ function readPackagedHash() {
   return readFileSync18(PACKAGED_HASH_PATH, "utf-8");
 }
 function localSchemaDir(repoRoot2) {
-  return resolve3(repoRoot2, ".pourkit/schema");
+  return resolve4(repoRoot2, ".pourkit/schema");
 }
 var MANAGED_BLOCK_BEGIN2 = "<!-- BEGIN POURKIT MANAGED BLOCK -->\n";
 var MANAGED_BLOCK_BEGIN_MARKER = MANAGED_BLOCK_BEGIN2.trim();
 var MANAGED_BLOCK_END_MARKER = "<!-- END POURKIT MANAGED BLOCK -->";
 var OLD_DOCS_PATH_PATTERN = ".pourkit/docs/agents/";
 function resolvePackagedManagedPath(...segments) {
-  const bundledPath = resolve3(__dirname3, "managed", ...segments);
-  const sourcePath = resolve3(__dirname3, "..", "managed", ...segments);
+  const bundledPath = resolve4(__dirname3, "managed", ...segments);
+  const sourcePath = resolve4(__dirname3, "..", "managed", ...segments);
   const candidates = [bundledPath, sourcePath];
   return candidates.find((candidate) => existsSync18(candidate)) ?? bundledPath;
 }
@@ -13117,21 +15033,21 @@ function resolvePackagedReleaseAddonDocPath(docName) {
 }
 async function readPackagedTextFile(filePath) {
   try {
-    return await readFile5(filePath, "utf-8");
+    return await readFile6(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function isPathContained(parent, child) {
-  const relativePath = relative3(parent, child);
+  const relativePath = relative4(parent, child);
   return !relativePath.startsWith("..") && !relativePath.startsWith("../");
 }
 async function walkDir2(dir) {
   const files = [];
   try {
-    const entries = await readdir2(dir, { withFileTypes: true });
+    const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = resolve3(dir, entry.name);
+      const full = resolve4(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...await walkDir2(full));
       } else {
@@ -13213,7 +15129,7 @@ async function validateWorkflowPack(cwd) {
   const catalog = getWorkflowPackCatalog();
   const baselineSkills = getBaselineManagedSkillNames();
   for (const docName of catalog.docs) {
-    const localPath = resolve3(cwd, `.pourkit/managed/docs/agents/${docName}`);
+    const localPath = resolve4(cwd, `.pourkit/managed/docs/agents/${docName}`);
     if (!existsSync18(localPath)) {
       failures.push({
         severity: "failure",
@@ -13226,9 +15142,9 @@ async function validateWorkflowPack(cwd) {
       const packagedContent = await readPackagedTextFile(packagedPath);
       if (packagedContent !== null) {
         try {
-          const localContent = await readFile5(localPath, "utf-8");
+          const localContent = await readFile6(localPath, "utf-8");
           if (localContent !== packagedContent) {
-            const overridePath = resolve3(
+            const overridePath = resolve4(
               cwd,
               `.pourkit/overrides/docs/agents/${docName}`
             );
@@ -13254,7 +15170,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const skillName of baselineSkills) {
-    const skillDir = resolve3(cwd, `.pourkit/managed/skills/${skillName}`);
+    const skillDir = resolve4(cwd, `.pourkit/managed/skills/${skillName}`);
     if (!existsSync18(skillDir)) {
       failures.push({
         severity: "failure",
@@ -13263,7 +15179,7 @@ async function validateWorkflowPack(cwd) {
         message: `Missing managed skill: ${skillName}`
       });
     } else {
-      const skillSourcePath = resolve3(skillDir, "SKILL.md");
+      const skillSourcePath = resolve4(skillDir, "SKILL.md");
       if (existsSync18(skillSourcePath)) {
         const packagedSkillPath = resolvePackagedManagedPath(
           "skills",
@@ -13273,9 +15189,9 @@ async function validateWorkflowPack(cwd) {
         const packagedContent = await readPackagedTextFile(packagedSkillPath);
         if (packagedContent !== null) {
           try {
-            const localContent = await readFile5(skillSourcePath, "utf-8");
+            const localContent = await readFile6(skillSourcePath, "utf-8");
             if (localContent !== packagedContent) {
-              const overridePath = resolve3(
+              const overridePath = resolve4(
                 cwd,
                 `.pourkit/overrides/skills/${skillName}/SKILL.md`
               );
@@ -13302,7 +15218,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const promptName of catalog.prompts) {
-    const promptPath = resolve3(cwd, `.pourkit/managed/prompts/${promptName}`);
+    const promptPath = resolve4(cwd, `.pourkit/managed/prompts/${promptName}`);
     if (!existsSync18(promptPath)) {
       failures.push({
         severity: "failure",
@@ -13313,7 +15229,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const skillName of baselineSkills) {
-    const projectionDir = resolve3(cwd, `.agents/skills/${skillName}`);
+    const projectionDir = resolve4(cwd, `.agents/skills/${skillName}`);
     if (!existsSync18(projectionDir)) {
       warnings.push({
         severity: "warning",
@@ -13322,7 +15238,7 @@ async function validateWorkflowPack(cwd) {
         message: `Missing skill projection for ${skillName}. Run 'pourkit sync workflow-pack' to regenerate.`
       });
     } else {
-      const projectionPath = resolve3(projectionDir, "SKILL.md");
+      const projectionPath = resolve4(projectionDir, "SKILL.md");
       if (existsSync18(projectionPath)) {
         const managedSourcePath = resolvePackagedManagedPath(
           "skills",
@@ -13332,7 +15248,7 @@ async function validateWorkflowPack(cwd) {
         const packagedContent = await readPackagedTextFile(managedSourcePath);
         if (packagedContent !== null) {
           try {
-            const projectionContent = await readFile5(projectionPath, "utf-8");
+            const projectionContent = await readFile6(projectionPath, "utf-8");
             const managedSourceRelativePath = `.pourkit/managed/skills/${skillName}/SKILL.md`;
             if (projectionContent !== buildOpenCodeSkillProjectionContent(
               managedSourceRelativePath,
@@ -13351,10 +15267,10 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const agentsPath = resolve3(cwd, "AGENTS.md");
+  const agentsPath = resolve4(cwd, "AGENTS.md");
   if (existsSync18(agentsPath)) {
     try {
-      const agentsContent = await readFile5(agentsPath, "utf-8");
+      const agentsContent = await readFile6(agentsPath, "utf-8");
       if (agentsContent.includes(OLD_DOCS_PATH_PATTERN)) {
         failures.push({
           severity: "failure",
@@ -13374,11 +15290,11 @@ async function validateWorkflowPack(cwd) {
     } catch {
     }
   }
-  const overridesDir = resolve3(cwd, ".pourkit/overrides");
+  const overridesDir = resolve4(cwd, ".pourkit/overrides");
   if (existsSync18(overridesDir)) {
     const overrideFiles = await walkDir2(overridesDir);
     for (const file of overrideFiles) {
-      const relPath = relative3(cwd, file);
+      const relPath = relative4(cwd, file);
       if (!warnings.some((w) => w.kind === "overridden" && w.path === relPath)) {
         warnings.push({
           severity: "warning",
@@ -13389,15 +15305,15 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const configPath = resolve3(cwd, ".pourkit/config.json");
+  const configPath = resolve4(cwd, ".pourkit/config.json");
   if (existsSync18(configPath)) {
     try {
-      const configContent = await readFile5(configPath, "utf-8");
+      const configContent = await readFile6(configPath, "utf-8");
       const parsed = JSON.parse(configContent);
       const releaseEnabled = parsed.releaseWorkflow?.enabled === true;
       if (releaseEnabled) {
         for (const skillName of catalog.releaseAddonSkills) {
-          const addonDir = resolve3(
+          const addonDir = resolve4(
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
@@ -13411,7 +15327,7 @@ async function validateWorkflowPack(cwd) {
           }
         }
         for (const docName of catalog.releaseAddonDocs) {
-          const addonDocPath = resolve3(
+          const addonDocPath = resolve4(
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
@@ -13427,7 +15343,7 @@ async function validateWorkflowPack(cwd) {
               resolvePackagedReleaseAddonDocPath(docName)
             );
             if (packagedContent !== null) {
-              const localContent = await readFile5(addonDocPath, "utf-8");
+              const localContent = await readFile6(addonDocPath, "utf-8");
               if (localContent !== packagedContent) {
                 failures.push({
                   severity: "failure",
@@ -13456,7 +15372,7 @@ async function validateWorkflowPack(cwd) {
         }
       } else {
         for (const skillName of catalog.releaseAddonSkills) {
-          const addonDir = resolve3(
+          const addonDir = resolve4(
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
@@ -13470,7 +15386,7 @@ async function validateWorkflowPack(cwd) {
           }
         }
         for (const docName of catalog.releaseAddonDocs) {
-          const addonDocPath = resolve3(
+          const addonDocPath = resolve4(
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
@@ -13487,16 +15403,16 @@ async function validateWorkflowPack(cwd) {
     } catch {
     }
   }
-  const manifestPath = resolve3(cwd, ".pourkit/manifest.json");
+  const manifestPath = resolve4(cwd, ".pourkit/manifest.json");
   if (existsSync18(manifestPath)) {
     try {
-      const manifestContent = await readFile5(manifestPath, "utf-8");
+      const manifestContent = await readFile6(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       const wp = manifest.workflowPack;
       if (wp?.projections) {
         for (const proj of wp.projections) {
           if (proj.path) {
-            const resolved = resolve3(cwd, proj.path);
+            const resolved = resolve4(cwd, proj.path);
             if (!isPathContained(cwd, resolved)) {
               failures.push({
                 severity: "failure",
@@ -13510,7 +15426,7 @@ async function validateWorkflowPack(cwd) {
     } catch {
     }
   }
-  const pathEscapeOverrideDir = resolve3(cwd, ".pourkit/overrides");
+  const pathEscapeOverrideDir = resolve4(cwd, ".pourkit/overrides");
   if (existsSync18(pathEscapeOverrideDir)) {
     const overrideFiles = await walkDir2(pathEscapeOverrideDir);
     for (const file of overrideFiles) {
@@ -13518,20 +15434,20 @@ async function validateWorkflowPack(cwd) {
         failures.push({
           severity: "failure",
           kind: "path_escape",
-          path: relative3(cwd, file),
-          message: `Override file path escapes repository: ${relative3(cwd, file)}`
+          path: relative4(cwd, file),
+          message: `Override file path escapes repository: ${relative4(cwd, file)}`
         });
       }
     }
   }
-  const managedDocsDir = resolve3(cwd, ".pourkit/managed/docs/agents");
+  const managedDocsDir = resolve4(cwd, ".pourkit/managed/docs/agents");
   if (existsSync18(managedDocsDir)) {
     const docFiles = await walkDir2(managedDocsDir);
     for (const file of docFiles) {
       if (!file.endsWith(".md")) continue;
       try {
-        const content = await readFile5(file, "utf-8");
-        const relPath = relative3(cwd, file);
+        const content = await readFile6(file, "utf-8");
+        const relPath = relative4(cwd, file);
         const violations = scanManagedPolicyText(content, relPath);
         for (const v of violations) {
           failures.push({
@@ -13545,16 +15461,16 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const managedSkillsDir = resolve3(cwd, ".pourkit/managed/skills");
+  const managedSkillsDir = resolve4(cwd, ".pourkit/managed/skills");
   if (existsSync18(managedSkillsDir)) {
-    const skillDirs = await readdir2(managedSkillsDir, { withFileTypes: true });
+    const skillDirs = await readdir3(managedSkillsDir, { withFileTypes: true });
     for (const entry of skillDirs) {
       if (!entry.isDirectory()) continue;
-      const skillFile = resolve3(managedSkillsDir, entry.name, "SKILL.md");
+      const skillFile = resolve4(managedSkillsDir, entry.name, "SKILL.md");
       if (!existsSync18(skillFile)) continue;
       try {
-        const content = await readFile5(skillFile, "utf-8");
-        const relPath = relative3(cwd, skillFile);
+        const content = await readFile6(skillFile, "utf-8");
+        const relPath = relative4(cwd, skillFile);
         const violations = scanManagedPolicyText(content, relPath);
         for (const v of violations) {
           failures.push({
@@ -13568,14 +15484,14 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const managedPromptsDir = resolve3(cwd, ".pourkit/managed/prompts");
+  const managedPromptsDir = resolve4(cwd, ".pourkit/managed/prompts");
   if (existsSync18(managedPromptsDir)) {
     for (const promptName of catalog.prompts) {
-      const promptFile = resolve3(managedPromptsDir, promptName);
+      const promptFile = resolve4(managedPromptsDir, promptName);
       if (!existsSync18(promptFile)) continue;
       try {
-        const content = await readFile5(promptFile, "utf-8");
-        const relPath = relative3(cwd, promptFile);
+        const content = await readFile6(promptFile, "utf-8");
+        const relPath = relative4(cwd, promptFile);
         const violations = scanManagedPolicyText(content, relPath);
         for (const v of violations) {
           failures.push({
@@ -13590,14 +15506,14 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const skillName of catalog.releaseAddonSkills) {
-    const addonSkillFile = resolve3(
+    const addonSkillFile = resolve4(
       cwd,
       `.pourkit/managed/addons/release/skills/${skillName}/SKILL.md`
     );
     if (!existsSync18(addonSkillFile)) continue;
     try {
-      const content = await readFile5(addonSkillFile, "utf-8");
-      const relPath = relative3(cwd, addonSkillFile);
+      const content = await readFile6(addonSkillFile, "utf-8");
+      const relPath = relative4(cwd, addonSkillFile);
       const violations = scanManagedPolicyText(content, relPath);
       for (const v of violations) {
         failures.push({
@@ -13611,14 +15527,14 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const docName of catalog.releaseAddonDocs) {
-    const addonDocFile = resolve3(
+    const addonDocFile = resolve4(
       cwd,
       `.pourkit/managed/addons/release/docs/agents/${docName}`
     );
     if (!existsSync18(addonDocFile)) continue;
     try {
-      const content = await readFile5(addonDocFile, "utf-8");
-      const relPath = relative3(cwd, addonDocFile);
+      const content = await readFile6(addonDocFile, "utf-8");
+      const relPath = relative4(cwd, addonDocFile);
       const violations = scanManagedPolicyText(content, relPath);
       for (const v of violations) {
         failures.push({
@@ -13648,7 +15564,7 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     ok: icmPath !== null,
     detail: icmPath !== null ? icmPath : "icm not found on PATH"
   });
-  const gitignorePath = resolve3(cwd, ".gitignore");
+  const gitignorePath = resolve4(cwd, ".gitignore");
   const gitignoreContent = existsSync18(gitignorePath) ? readFileSync18(gitignorePath, "utf-8") : "";
   const hasGitignoreEntry = gitignoreContent.includes(".pourkit/icm/");
   checks.push({
@@ -13656,7 +15572,7 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     ok: hasGitignoreEntry,
     detail: hasGitignoreEntry ? ".gitignore covers .pourkit/icm/" : ".gitignore does not cover .pourkit/icm/"
   });
-  const memoryDbPath = resolve3(cwd, ".pourkit", "icm", "memories.db");
+  const memoryDbPath = resolve4(cwd, ".pourkit", "icm", "memories.db");
   const hasMemoryDb = existsSync18(memoryDbPath);
   checks.push({
     name: "icm-db-exists",
@@ -13670,7 +15586,7 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     detail: shapeValid ? "memory: { enabled: true, provider: icm }" : `invalid memory config: enabled=${memoryConfig.enabled}, provider=${memoryConfig.provider}`
   });
   const staleAgentFiles = ["AGENTS.md", "CLAUDE.md"].filter((fileName) => {
-    const filePath = resolve3(cwd, fileName);
+    const filePath = resolve4(cwd, fileName);
     if (!existsSync18(filePath)) return false;
     const content = readFileSync18(filePath, "utf-8");
     const managedBlock = extractManagedBlockContent(content);
@@ -13706,8 +15622,8 @@ function extractManagedBlockContent(content) {
 async function runDoctorCommand(options) {
   const repoRootPath = options.cwd ?? process.cwd();
   const schemaDir = localSchemaDir(repoRootPath);
-  const localSchemaPath = resolve3(schemaDir, "pourkit.schema.json");
-  const localHashPath = resolve3(schemaDir, "pourkit.schema.hash");
+  const localSchemaPath = resolve4(schemaDir, "pourkit.schema.json");
+  const localHashPath = resolve4(schemaDir, "pourkit.schema.hash");
   const localSchemaExists = existsSync18(localSchemaPath);
   const localHashExists = existsSync18(localHashPath);
   let packagedHash = null;
@@ -13718,14 +15634,14 @@ async function runDoctorCommand(options) {
   let localHashContent = null;
   if (localHashExists) {
     try {
-      localHashContent = await readFile5(localHashPath, "utf-8");
+      localHashContent = await readFile6(localHashPath, "utf-8");
     } catch {
     }
   }
   const schema = !localSchemaExists ? "missing" : !packagedHash || !localHashContent ? "missing" : localHashContent.trim() === packagedHash.trim() ? "fresh" : "stale";
   const hash = !localHashExists ? "missing" : !packagedHash ? "missing" : localHashContent && localHashContent.trim() === packagedHash.trim() ? "fresh" : "stale";
   const overall = schema === "fresh" && hash === "fresh" ? "fresh" : schema === "missing" || hash === "missing" ? "missing" : "stale";
-  const configPath = resolve3(repoRootPath, ".pourkit/config.json");
+  const configPath = resolve4(repoRootPath, ".pourkit/config.json");
   let configValidation;
   let rawMemoryConfig;
   if (existsSync18(configPath)) {
@@ -13763,7 +15679,7 @@ async function runDoctorCommand(options) {
     "pourkit.config.mjs",
     "pourkit.config.js",
     "pourkit.json"
-  ].filter((p) => existsSync18(resolve3(repoRootPath, p)));
+  ].filter((p) => existsSync18(resolve4(repoRootPath, p)));
   const workflowPack = await validateWorkflowPack(repoRootPath);
   const memory = await validateMemoryHealth(repoRootPath, rawMemoryConfig);
   let recommendation = null;
@@ -13806,31 +15722,31 @@ async function runDoctorCommand(options) {
 async function runConfigSyncSchemaCommand(options) {
   const repoRootPath = options.cwd ?? process.cwd();
   const schemaDir = localSchemaDir(repoRootPath);
-  await mkdir5(schemaDir, { recursive: true });
-  const packagedSchema = await readFile5(PACKAGED_SCHEMA_PATH, "utf-8");
-  const packagedHash = await readFile5(PACKAGED_HASH_PATH, "utf-8");
-  const localSchemaPath = resolve3(schemaDir, "pourkit.schema.json");
-  const localHashPath = resolve3(schemaDir, "pourkit.schema.hash");
+  await mkdir6(schemaDir, { recursive: true });
+  const packagedSchema = await readFile6(PACKAGED_SCHEMA_PATH, "utf-8");
+  const packagedHash = await readFile6(PACKAGED_HASH_PATH, "utf-8");
+  const localSchemaPath = resolve4(schemaDir, "pourkit.schema.json");
+  const localHashPath = resolve4(schemaDir, "pourkit.schema.hash");
   let schemaWritten = false;
   let hashWritten = false;
   if (existsSync18(localSchemaPath)) {
-    const existing = await readFile5(localSchemaPath, "utf-8");
+    const existing = await readFile6(localSchemaPath, "utf-8");
     if (existing !== packagedSchema) {
-      await writeFile2(localSchemaPath, packagedSchema, "utf-8");
+      await writeFile3(localSchemaPath, packagedSchema, "utf-8");
       schemaWritten = true;
     }
   } else {
-    await writeFile2(localSchemaPath, packagedSchema, "utf-8");
+    await writeFile3(localSchemaPath, packagedSchema, "utf-8");
     schemaWritten = true;
   }
   if (existsSync18(localHashPath)) {
-    const existing = await readFile5(localHashPath, "utf-8");
+    const existing = await readFile6(localHashPath, "utf-8");
     if (existing !== packagedHash) {
-      await writeFile2(localHashPath, packagedHash, "utf-8");
+      await writeFile3(localHashPath, packagedHash, "utf-8");
       hashWritten = true;
     }
   } else {
-    await writeFile2(localHashPath, packagedHash, "utf-8");
+    await writeFile3(localHashPath, packagedHash, "utf-8");
     hashWritten = true;
   }
   return {
@@ -13841,12 +15757,12 @@ async function runConfigSyncSchemaCommand(options) {
 }
 
 // commands/workflow-pack-sync.ts
-import { existsSync as existsSync19, readdirSync as readdirSync4 } from "fs";
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
-import { resolve as resolve4, dirname as dirname6, relative as relative4, normalize as normalize2 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync5 } from "fs";
+import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile4, readdir as readdir4 } from "fs/promises";
+import { resolve as resolve5, dirname as dirname7, relative as relative5, normalize as normalize2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname6(__filename4);
+var __dirname4 = dirname7(__filename4);
 var PROJECT_OWNED_PATHS = [".pourkit/CONTEXT.md", ".pourkit/CONTEXT-MAP.md"];
 var PROJECT_OWNED_DIRECTORIES = [
   ".pourkit/docs/adr",
@@ -13854,11 +15770,9 @@ var PROJECT_OWNED_DIRECTORIES = [
   ".pourkit/handoffs"
 ];
 var OVERRIDES_DIR = ".pourkit/overrides";
-var MANAGED_BLOCK_BEGIN3 = "<!-- BEGIN POURKIT MANAGED BLOCK -->\n";
-var MANAGED_BLOCK_END2 = "\n<!-- END POURKIT MANAGED BLOCK -->";
 function resolvePackagedManagedPath2(...segments) {
-  const bundledPath = resolve4(__dirname4, "managed", ...segments);
-  const sourcePath = resolve4(__dirname4, "..", "managed", ...segments);
+  const bundledPath = resolve5(__dirname4, "managed", ...segments);
+  const sourcePath = resolve5(__dirname4, "..", "managed", ...segments);
   const candidates = [bundledPath, sourcePath];
   return candidates.find((candidate) => existsSync19(candidate)) ?? bundledPath;
 }
@@ -13882,13 +15796,13 @@ function resolvePackagedManagedPromptPath(promptName) {
 }
 async function readPackagedTextFile2(filePath) {
   try {
-    return await readFile6(filePath, "utf-8");
+    return await readFile7(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function isPathContained2(parent, child) {
-  const relativePath = relative4(parent, child);
+  const relativePath = relative5(parent, child);
   return !relativePath.startsWith("..") && !relativePath.startsWith("../");
 }
 function isProjectOwnedPath(relativePath) {
@@ -13939,9 +15853,9 @@ function checkForPathEscape(cwd, resolvedPath) {
 async function walkDir3(dir) {
   const files = [];
   try {
-    const entries = await readdir3(dir, { withFileTypes: true });
+    const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = resolve4(dir, entry.name);
+      const full = resolve5(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...await walkDir3(full));
       } else {
@@ -13959,28 +15873,28 @@ async function syncFile(cwd, targetRelativePath, sourceContent, errors) {
   if (sourceContent === null) {
     return false;
   }
-  const targetPath = resolve4(cwd, targetRelativePath);
+  const targetPath = resolve5(cwd, targetRelativePath);
   const escapeError = checkForPathEscape(cwd, targetPath);
   if (escapeError) {
     errors.push(escapeError);
     return false;
   }
-  await mkdir6(resolve4(targetPath, ".."), { recursive: true });
+  await mkdir7(resolve5(targetPath, ".."), { recursive: true });
   if (existsSync19(targetPath)) {
-    const existing = await readFile6(targetPath, "utf-8");
+    const existing = await readFile7(targetPath, "utf-8");
     if (existing === sourceContent) {
       return false;
     }
   }
-  await writeFile3(targetPath, sourceContent, "utf-8");
+  await writeFile4(targetPath, sourceContent, "utf-8");
   return true;
 }
 function walkDirSync(dir) {
   const result = [];
   try {
-    const entries = readdirSync4(dir, { withFileTypes: true });
+    const entries = readdirSync5(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = resolve4(dir, entry.name);
+      const full = resolve5(dir, entry.name);
       if (entry.isDirectory()) {
         result.push(...walkDirSync(full));
       } else {
@@ -13992,27 +15906,27 @@ function walkDirSync(dir) {
   return result;
 }
 async function detectOverrides(cwd) {
-  const overridesDir = resolve4(cwd, OVERRIDES_DIR);
+  const overridesDir = resolve5(cwd, OVERRIDES_DIR);
   if (!existsSync19(overridesDir)) {
     return [];
   }
   const files = await walkDir3(overridesDir);
-  return files.map((f) => relative4(cwd, f));
+  return files.map((f) => relative5(cwd, f));
 }
 async function detectProjectOwnedFiles(cwd) {
   const found = [];
   for (const ownedPath of PROJECT_OWNED_PATHS) {
-    const fullPath = resolve4(cwd, ownedPath);
+    const fullPath = resolve5(cwd, ownedPath);
     if (existsSync19(fullPath)) {
       found.push(ownedPath);
     }
   }
   for (const ownedDir of PROJECT_OWNED_DIRECTORIES) {
-    const fullDir = resolve4(cwd, ownedDir);
+    const fullDir = resolve5(cwd, ownedDir);
     if (existsSync19(fullDir)) {
       const files = await walkDir3(fullDir);
       for (const file of files) {
-        found.push(relative4(cwd, file));
+        found.push(relative5(cwd, file));
       }
     }
   }
@@ -14020,8 +15934,8 @@ async function detectProjectOwnedFiles(cwd) {
 }
 async function isReleaseWorkflowEnabled(cwd) {
   try {
-    const configPath = resolve4(cwd, ".pourkit", "config.json");
-    const content = await readFile6(configPath, "utf-8");
+    const configPath = resolve5(cwd, ".pourkit", "config.json");
+    const content = await readFile7(configPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.releaseWorkflow?.enabled === true;
   } catch {
@@ -14150,7 +16064,7 @@ async function runWorkflowPackSyncCommand(options) {
   const schemaResult = await runConfigSyncSchemaCommand({ cwd });
   let configMemory;
   try {
-    const configPath = resolve4(cwd, ".pourkit", "config.json");
+    const configPath = resolve5(cwd, ".pourkit", "config.json");
     const config = await loadConfig(configPath);
     if (config.memory?.enabled === true && config.memory?.provider === "icm") {
       configMemory = config.memory;
@@ -14158,34 +16072,19 @@ async function runWorkflowPackSyncCommand(options) {
   } catch {
   }
   const managedBlockContent = generateManagedBlockContent(configMemory);
-  const fullManagedBlock = `${MANAGED_BLOCK_BEGIN3}${managedBlockContent}${MANAGED_BLOCK_END2}`;
+  const fullManagedBlock = buildManagedBlock(managedBlockContent);
   async function syncManagedAgentFile(fileName, options2) {
-    const filePath = resolve4(cwd, fileName);
+    const filePath = resolve5(cwd, fileName);
     if (!existsSync19(filePath)) {
       if (!options2.createIfMissing) return false;
-      await writeFile3(filePath, fullManagedBlock + "\n", "utf-8");
+      await writeFile4(filePath, fullManagedBlock, "utf-8");
       return true;
     }
-    const existing = await readFile6(filePath, "utf-8");
-    const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN3);
-    const endIdx = existing.indexOf(MANAGED_BLOCK_END2);
-    if (beginIdx !== -1 && endIdx !== -1) {
-      const beforeBlock = existing.slice(0, beginIdx);
-      const afterBlock = existing.slice(endIdx + MANAGED_BLOCK_END2.length);
-      const newContent = `${beforeBlock}${fullManagedBlock}${afterBlock}`;
-      if (newContent !== existing) {
-        await writeFile3(filePath, newContent, "utf-8");
-        return true;
-      }
-    } else {
-      const newContent = `${existing}
-
-${fullManagedBlock}
-`;
-      if (newContent !== existing) {
-        await writeFile3(filePath, newContent, "utf-8");
-        return true;
-      }
+    const existing = await readFile7(filePath, "utf-8");
+    const newContent = upsertManagedBlock(existing, managedBlockContent);
+    if (newContent !== existing) {
+      await writeFile4(filePath, newContent, "utf-8");
+      return true;
     }
     return false;
   }
@@ -14197,11 +16096,11 @@ ${fullManagedBlock}
   }
   const enabledAddons = releaseEnabled ? ["release"] : [];
   const manifestMeta = buildWorkflowPackMetadata(enabledAddons);
-  const manifestPath = resolve4(cwd, ".pourkit", "manifest.json");
+  const manifestPath = resolve5(cwd, ".pourkit", "manifest.json");
   let manifestWritten = false;
   let previousManifestWorkflowPack = void 0;
   try {
-    const existingRaw = await readFile6(manifestPath, "utf-8").catch(() => null);
+    const existingRaw = await readFile7(manifestPath, "utf-8").catch(() => null);
     if (existingRaw) {
       const existing = JSON.parse(existingRaw);
       previousManifestWorkflowPack = existing.workflowPack;
@@ -14210,13 +16109,13 @@ ${fullManagedBlock}
   }
   if (previousManifestWorkflowPack === void 0 || JSON.stringify(previousManifestWorkflowPack) !== JSON.stringify(manifestMeta)) {
     try {
-      const existingRaw = await readFile6(manifestPath, "utf-8").catch(
+      const existingRaw = await readFile7(manifestPath, "utf-8").catch(
         () => null
       );
       let manifest = existingRaw ? JSON.parse(existingRaw) : {};
       manifest.workflowPack = manifestMeta;
-      await mkdir6(resolve4(manifestPath, ".."), { recursive: true });
-      await writeFile3(
+      await mkdir7(resolve5(manifestPath, ".."), { recursive: true });
+      await writeFile4(
         manifestPath,
         JSON.stringify(manifest, null, 2) + "\n",
         "utf-8"
@@ -14265,7 +16164,7 @@ async function syncSkill(skillName, catalog, acc, ctx) {
     return;
   }
   for (const sourceFile of skillFiles) {
-    const relPath = relative4(skillDir, sourceFile);
+    const relPath = relative5(skillDir, sourceFile);
     const targetRelativePath = `.pourkit/managed/skills/${skillName}/${relPath}`;
     if (isProjectOwnedPath(targetRelativePath)) {
       skippedProjectOwned.push(targetRelativePath);
@@ -14341,7 +16240,7 @@ async function syncAddonSkill(skillName, acc, ctx) {
     return;
   }
   for (const sourceFile of skillFiles) {
-    const relPath = relative4(addonSkillDir, sourceFile);
+    const relPath = relative5(addonSkillDir, sourceFile);
     const targetRelativePath = `.pourkit/managed/addons/release/skills/${skillName}/${relPath}`;
     if (isProjectOwnedPath(targetRelativePath)) {
       skippedProjectOwned.push(targetRelativePath);
@@ -14422,6 +16321,16 @@ var GitHubIssueProvider = class {
     });
     return { number: data.number, url: data.html_url, title: data.title };
   }
+  async updateIssue(issueNumber, options) {
+    const { data } = await this.client.octokit.rest.issues.update({
+      owner: this.client.owner,
+      repo: this.client.repo,
+      issue_number: issueNumber,
+      ...options.title !== void 0 ? { title: options.title } : {},
+      ...options.body !== void 0 ? { body: options.body } : {}
+    });
+    return { number: data.number, url: data.html_url, title: data.title };
+  }
   async fetchIssue(number) {
     const { data } = await this.client.octokit.rest.issues.get({
       owner: this.client.owner,
@@ -14944,21 +16853,21 @@ init_common();
 
 // execution/sandcastle-execution.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync9, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
 // execution/execution-provider.ts
 init_common();
 import { mkdtempSync } from "fs";
-import { writeFile as writeFile4 } from "fs/promises";
+import { writeFile as writeFile5 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname7, join as join18 } from "path";
+import { dirname as dirname8, join as join21 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join18(worktreePath, artifact.path);
-    await ensureDir(dirname7(filePath));
-    await writeFile4(filePath, artifact.content, "utf-8");
+    const filePath = join21(worktreePath, artifact.path);
+    await ensureDir(dirname8(filePath));
+    await writeFile5(filePath, artifact.content, "utf-8");
   }
 }
 
@@ -15018,7 +16927,7 @@ async function createSandboxFromExistingWorktree(options) {
 }
 
 // execution/sandbox-options.ts
-import { join as join19 } from "path";
+import { join as join22 } from "path";
 var POURKIT_ICM_CONTAINER_DIR = "/home/agent/.pourkit/icm";
 function buildSandboxOptions(repoRoot2, sandbox, memory) {
   const mounts = [];
@@ -15027,12 +16936,12 @@ function buildSandboxOptions(repoRoot2, sandbox, memory) {
   }
   if (memory?.available) {
     mounts.push({
-      hostPath: join19(repoRoot2, ".pourkit", "icm"),
+      hostPath: join22(repoRoot2, ".pourkit", "icm"),
       sandboxPath: POURKIT_ICM_CONTAINER_DIR,
       readonly: false
     });
     mounts.push({
-      hostPath: join19(repoRoot2, ".pourkit", "icm", "cache"),
+      hostPath: join22(repoRoot2, ".pourkit", "icm", "cache"),
       sandboxPath: "/home/agent/.cache/icm",
       readonly: false
     });
@@ -15166,13 +17075,13 @@ var SandcastleExecutionSession = class {
             "Memory enabled but memory context is invalid. Run `pourkit memory init` or install ICM for host planning use."
           );
         }
-        const hostMemoryDir = join20(repoRoot2, ".pourkit", "icm");
+        const hostMemoryDir = join23(repoRoot2, ".pourkit", "icm");
         if (!existsSync21(hostMemoryDir) || !statSync2(hostMemoryDir).isDirectory()) {
           throw new MissingHostMemoryDirError(
             "Memory enabled but host .pourkit/icm/ directory is missing. Run `pourkit memory init` to create the repo-scoped memory store."
           );
         }
-        mkdirSync9(join20(hostMemoryDir, "cache"), { recursive: true });
+        mkdirSync9(join23(hostMemoryDir, "cache"), { recursive: true });
       }
       const sandboxOptions = buildSandboxOptions(
         repoRoot2,
@@ -15331,7 +17240,7 @@ function sanitizeBranch(branchName) {
 }
 function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
   return paths.filter((relativePath) => {
-    const source = join20(repoRoot2, relativePath);
+    const source = join23(repoRoot2, relativePath);
     if (!existsSync21(source)) {
       return true;
     }
@@ -15342,7 +17251,7 @@ function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
     } catch {
       return true;
     }
-    const destination = join20(worktreePath, relativePath);
+    const destination = join23(worktreePath, relativePath);
     return !existsSync21(destination);
   });
 }
@@ -15407,17 +17316,17 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join20(repoRoot2, ".pourkit", ".tmp", "prompts");
+  const promptsDir = join23(repoRoot2, ".pourkit", ".tmp", "prompts");
   mkdirSync9(promptsDir, { recursive: true });
   const timestamp2 = Date.now();
   const iterationSuffix = iteration !== void 0 ? `-iteration-${iteration}` : "";
   const filename = `${stage}${iterationSuffix}-${timestamp2}.md`;
-  const filePath = join20(promptsDir, filename);
+  const filePath = join23(promptsDir, filename);
   writeFileSync6(filePath, prompt, "utf-8");
 }
 
 // cli.ts
-function normalizePrdRef(ref) {
+function normalizePrdRef2(ref) {
   const normalized = ref.trim().toUpperCase();
   if (!/^PRD-\d+$/.test(normalized)) {
     throw new Error(
@@ -15482,6 +17391,7 @@ 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");
+  const prdPlanWorkspaceCommand = program.command("prd-plan-workspace").description("PRD Plan Workspace commands");
   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(
@@ -15513,7 +17423,7 @@ function createCliProgram(version) {
   });
   program.command("validate-artifact").description("Validate an agent handoff artifact").argument(
     "<kind>",
-    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, failure-resolution, or issue-final-review"
+    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, failure-resolution, issue-final-review, prd-plan, prd-child-issue, or prd-plan-workspace"
   ).argument("<artifactPath>", "artifact path to validate").argument("[extraPaths...]", "unused compatibility argument").option("--iteration <number>", "review/refactor iteration", (value) => {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed < 1) {
@@ -15566,7 +17476,13 @@ function createCliProgram(version) {
   ).option(
     "--base-ref <ref>",
     "canonical base ref for issue-final-review changedFiles coverage validation"
-  ).option("--no-check-conflict-markers", "skip conflict marker scan").option("--cwd <path>", "target repository directory").action(
+  ).option(
+    "--prd-ref <ref>",
+    "PRD reference for PRD plan validation artifacts"
+  ).option(
+    "--workspace <path>",
+    "PRD Plan Workspace path for prd-plan-workspace validation"
+  ).option("--child-id <id>", "child issue ID for prd-child-issue validation").option("--no-check-conflict-markers", "skip conflict marker scan").option("--cwd <path>", "target repository directory").action(
     (kind, artifactPath, _extraPaths, options) => {
       const allowedKinds = /* @__PURE__ */ new Set([
         "reviewer",
@@ -15574,7 +17490,10 @@ function createCliProgram(version) {
         "finalizer",
         "conflict-resolution",
         "failure-resolution",
-        "issue-final-review"
+        "issue-final-review",
+        "prd-plan",
+        "prd-child-issue",
+        "prd-plan-workspace"
       ]);
       if (!allowedKinds.has(kind)) {
         throw new CommanderError(
@@ -15596,7 +17515,10 @@ function createCliProgram(version) {
         issueNumber: options.issueNumber,
         branchName: options.branchName,
         baseRef: options.baseRef,
-        checkConflictMarkers: options.checkConflictMarkers
+        checkConflictMarkers: options.checkConflictMarkers,
+        prdRef: options.prdRef,
+        workspace: options.workspace,
+        childId: options.childId
       });
       console.log(JSON.stringify(result, null, 2));
       if (!result.ok) {
@@ -15604,6 +17526,40 @@ function createCliProgram(version) {
       }
     }
   );
+  prdPlanWorkspaceCommand.command("publish").description("Publish a PRD Plan Workspace through Beads and GitHub").argument("<workspace>", "PRD Plan Workspace path").requiredOption("--prd-ref <ref>", "PRD reference to publish").option("--cwd <path>", "target repository directory").action(
+    async (workspace, options) => {
+      const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
+      const logPath = path8.join(
+        targetRepoRoot,
+        ".pourkit",
+        "logs",
+        "prd-plan-workspace-publish.log"
+      );
+      const logger = createLogger("pourkit", logPath);
+      try {
+        const config = await loadRepoConfig(targetRepoRoot);
+        const client = await requireGitHubClient({ cwd: targetRepoRoot });
+        const issueProvider = new GitHubIssueProvider(client, {
+          readyForAgentLabel: config.labels.readyForAgent,
+          blockedLabel: config.labels.blocked,
+          issueListLimit: config.checks.issueListLimit
+        });
+        const result = await runPrdPlanWorkspacePublishCommand({
+          repoRoot: targetRepoRoot,
+          workspacePath: workspace,
+          prdRef: options.prdRef,
+          issueProvider,
+          labels: config.labels,
+          logger
+        });
+        console.log(JSON.stringify(result, null, 2));
+      } catch (error) {
+        await handleError(logger, error);
+      } finally {
+        await logger.close();
+      }
+    }
+  );
   issueCommand.command("create").description("Create a new GitHub issue").requiredOption("--title <title>", "issue title").option("--body <body>", "issue body text").option("--body-file <path>", "file to read issue body from").option(
     "--label <label>",
     "label to apply (repeatable)",
@@ -15743,7 +17699,7 @@ function createCliProgram(version) {
   );
   program.command("queue-run").requiredOption("--target <name>", "target name").option("--force", "bypass issue gates").option("--loop", "process runnable issues until the queue is drained").option("--cwd <path>", "target repository directory").option("--prd <ref>", "limit queue selection to child issues under a PRD").action(
     async (options) => {
-      const prdRef = options.prd ? normalizePrdRef(options.prd) : void 0;
+      const prdRef = options.prd ? normalizePrdRef2(options.prd) : void 0;
       const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
       const config = await loadRepoConfig(targetRepoRoot);
       const logPath = path8.join(
@@ -15811,7 +17767,7 @@ function createCliProgram(version) {
   prdRun.command("start").argument("<prdRef>", "PRD ref").requiredOption("--target <name>", "target name").option("--base <branch>", "override target baseBranch for this PRD Run").option("--adopt-existing-branch", "adopt an existing PRD branch").option("--cwd <path>", "target repository directory").action(
     async (prdRef, options) => {
       const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
-      const normalizedPrdRef = normalizePrdRef(prdRef);
+      const normalizedPrdRef = normalizePrdRef2(prdRef);
       const logPath = path8.join(
         targetRepoRoot,
         ".pourkit",
@@ -15857,7 +17813,7 @@ function createCliProgram(version) {
   prdRun.command("launch").argument("<prdRef>", "PRD ref").requiredOption("--target <name>", "target name").option("--base <branch>", "override target baseBranch for this PRD Run").option("--cwd <path>", "target repository directory").option("--no-auto-merge", "skip auto-merge for manual review").option("--adopt-existing-branch", "adopt an existing PRD branch").action(
     async (prdRef, options) => {
       const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
-      const normalizedPrdRef = normalizePrdRef(prdRef);
+      const normalizedPrdRef = normalizePrdRef2(prdRef);
       const logPath = path8.join(
         targetRepoRoot,
         ".pourkit",
@@ -16133,11 +18089,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260625073725")) {
-    return "0.0.0-next-20260625073725";
+  if (isPackageVersion("0.0.0-next-20260627024509")) {
+    return "0.0.0-next-20260627024509";
   }
-  if (isReleaseVersion("0.0.0-next-20260625073725")) {
-    return "0.0.0-next-20260625073725";
+  if (isReleaseVersion("0.0.0-next-20260627024509")) {
+    return "0.0.0-next-20260627024509";
   }
   try {
     const root = repoRoot();