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

package/dist/e2e/run-live-e2e.js

@@ -1756,7 +1756,7 @@ async function runBaseRefreshAttempt(options) {
 
 // commands/conflict-resolution.ts
 import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 init_common();
 
 // conflicts/conflict-resolution-artifact.ts
@@ -1919,8 +1919,8 @@ function parseConflictResolutionArtifact(output) {
 
 // commands/artifact-validation.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
+import { isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "path";
 
 // pr/review-verdict.ts
 var ReviewVerdictProtocolError = class extends Error {
@@ -3319,6 +3319,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,
@@ -3668,11 +3675,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 (!existsSync8(prdPath)) {
+    return invalid(options, `PRD plan workspace missing PRD.md at ${prdPath}`);
+  }
+  let prdContent;
+  try {
+    prdContent = readFileSync8(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 (!existsSync8(issuesDir)) {
+    return invalid(
+      options,
+      `PRD plan workspace missing issues/ directory at ${issuesDir}`
+    );
+  }
+  let childFiles;
+  const CHILD_FILE_PATTERN = /^I-0*(\d+)-.+\.md$/i;
+  try {
+    childFiles = readdirSync3(issuesDir).filter(
+      (f) => CHILD_FILE_PATTERN.test(f) && !f.startsWith(".")
+    );
+  } catch {
+    return invalid(options, `Cannot read issues/ directory at ${issuesDir}`);
+  }
+  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]);
+  });
+  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_PATTERN = /^\s*(I-0*\d+)\s*$/i;
+  const BLOCKED_BY_SECTION_REGEX = /## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i;
+  const PARENT_SECTION_REGEX = /## Parent\s*\n([\s\S]*?)(?=\n## |$)/i;
+  for (const childFile of childFiles) {
+    const childPath = join7(issuesDir, childFile);
+    let childContent;
+    try {
+      childContent = readFileSync8(childPath, "utf-8");
+    } catch {
+      diagnostics.push(`${childFile}: cannot read`);
+      continue;
+    }
+    const childFileMatch = childFile.match(CHILD_FILE_PATTERN);
+    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_REGEX)?.[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_REGEX)?.[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_PATTERN);
+          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);
@@ -3815,7 +3988,7 @@ function shellQuote(value) {
 var CONFLICT_MARKER_PATTERN2 = /<<<<<<<|=======|>>>>>>>/m;
 async function hasUnresolvedConflictMarkers(worktreePath, files) {
   for (const file of files) {
-    const filePath = join7(worktreePath, file);
+    const filePath = join8(worktreePath, file);
     try {
       const content = readFileSync9(filePath, "utf-8");
       if (CONFLICT_MARKER_PATTERN2.test(content)) {
@@ -3829,7 +4002,7 @@ async function hasUnresolvedConflictMarkers(worktreePath, files) {
 
 // failure-resolution/failure-resolution-agent.ts
 import { readFileSync as readFileSync10 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // failure-resolution/recovery-policy.ts
 function isSecuritySensitiveFailure(failure) {
@@ -3905,7 +4078,7 @@ async function runFailureResolutionAgent(options) {
   } = options;
   const frConfig = target.strategy.failureResolution;
   const artifactPath = packet.artifactTarget;
-  const fullArtifactPath = join8(worktreePath, artifactPath);
+  const fullArtifactPath = join9(worktreePath, artifactPath);
   const fingerprint = computeFailureFingerprint(packet.stageName, failure._tag);
   const prompt = [
     `# Failure Resolution: ${packet.failureType}`,
@@ -4736,11 +4909,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 join11 } from "path";
+import { isAbsolute as isAbsolute4, join as join12 } from "path";
 
 // pr/pr-description-context.ts
 init_common();
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { readFile } from "fs/promises";
 import { Effect as Effect6 } from "effect";
 function collectFinalizerContextEffect(options) {
@@ -4805,7 +4978,7 @@ function remoteTargetBase(targetBase) {
   return targetBase.includes("/") ? targetBase : `origin/${targetBase}`;
 }
 function buildFinalizerPrompt(context, promptTemplate) {
-  const artifactPathInWorktree = join9(
+  const artifactPathInWorktree = join10(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -4860,9 +5033,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 join10, relative as relative2, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute3, join as join11, relative as relative2, sep as sep2 } from "path";
 init_common();
-var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join10(
+var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join11(
   ".pourkit",
   ".tmp",
   "issue-final-review",
@@ -4880,7 +5053,7 @@ async function runIssueFinalReview(options) {
     logger
   } = options;
   const artifactPathInWorktree = ISSUE_FINAL_REVIEW_ARTIFACT_PATH;
-  const artifactPath = join10(worktreePath, artifactPathInWorktree);
+  const artifactPath = join11(worktreePath, artifactPathInWorktree);
   const ifrFromState = options.worktreeState?.issueFinalReview;
   if (ifrFromState?.completed && ifrFromState.verdict === "pass") {
     if (!ifrFromState.artifactPath) {
@@ -4888,7 +5061,7 @@ async function runIssueFinalReview(options) {
         "Issue Final Review state is incomplete: missing artifactPath"
       );
     }
-    const cachedArtifactPath = isAbsolute3(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join10(worktreePath, ifrFromState.artifactPath);
+    const cachedArtifactPath = isAbsolute3(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join11(worktreePath, ifrFromState.artifactPath);
     const validation2 = validateAgentArtifact({
       kind: "issue-final-review",
       artifactPath: cachedArtifactPath,
@@ -5237,20 +5410,20 @@ function loadFinalizerPromptEffect(repoRoot2, promptTemplate, fs) {
 }
 function persistGeneratedArtifactEffect(worktreePath, output, fs) {
   return Effect7.gen(function* () {
-    const dir = join11(worktreePath, ".pourkit", ".tmp", "finalizer");
+    const dir = join12(worktreePath, ".pourkit", ".tmp", "finalizer");
     yield* fs.mkdir(dir).pipe(Effect7.catchAll(() => Effect7.void));
-    yield* fs.writeFile(join11(dir, "generated.md"), output).pipe(Effect7.catchAll(() => Effect7.void));
+    yield* fs.writeFile(join12(dir, "generated.md"), output).pipe(Effect7.catchAll(() => Effect7.void));
   });
 }
 function runPrDescriptionAgent(options) {
   const { executionProvider } = options;
-  const artifactPathInWorktree = join11(
+  const artifactPathInWorktree = join12(
     ".pourkit",
     ".tmp",
     "finalizer",
     "agent-output.md"
   );
-  const artifactPath = join11(options.worktreePath, artifactPathInWorktree);
+  const artifactPath = join12(options.worktreePath, artifactPathInWorktree);
   const finalizerFromState = options.worktreeState?.finalizer?.completed ? options.worktreeState.finalizer : null;
   if (finalizerFromState) {
     return Effect7.gen(function* () {
@@ -5261,7 +5434,7 @@ function runPrDescriptionAgent(options) {
           })
         );
       }
-      const resolvedArtifactPath = isAbsolute4(finalizerFromState.artifactPath) ? finalizerFromState.artifactPath : join11(options.worktreePath, finalizerFromState.artifactPath);
+      const resolvedArtifactPath = isAbsolute4(finalizerFromState.artifactPath) ? finalizerFromState.artifactPath : join12(options.worktreePath, finalizerFromState.artifactPath);
       if (!existsSync12(resolvedArtifactPath)) {
         return yield* Effect7.fail(
           new FinalizerFailure({
@@ -5383,7 +5556,7 @@ function runPrDescriptionAgent(options) {
   );
 }
 function runPrDescriptionFinalizerCore(options) {
-  const artifactPath = join11(
+  const artifactPath = join12(
     options.worktreePath,
     options.artifactPathInWorktree
   );
@@ -5484,7 +5657,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 join12 } from "path";
+import { isAbsolute as isAbsolute5, join as join13 } from "path";
 
 // issues/issue-transitions.ts
 function createIssueTransitions(deps, labels) {
@@ -5542,6 +5715,35 @@ function createIssueTransitions(deps, labels) {
   };
 }
 
+// beads/client.ts
+init_common();
+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;
@@ -5959,7 +6161,7 @@ function readIssueFinalReviewArtifact(worktreeState, worktreePath) {
   if (!configuredPath) {
     return null;
   }
-  const artifactPath = isAbsolute5(configuredPath) ? configuredPath : join12(worktreePath, configuredPath);
+  const artifactPath = isAbsolute5(configuredPath) ? configuredPath : join13(worktreePath, configuredPath);
   if (!existsSync13(artifactPath)) return null;
   let parsed;
   try {
@@ -6066,19 +6268,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)}`
@@ -6277,7 +6516,7 @@ async function runFinalCommit(options) {
 
 // issues/issue-worktree-resolution.ts
 init_common();
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   const worktreeList = await execCapture(
     "git",
@@ -6335,7 +6574,7 @@ async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   return { mode: "new", branchName, baseRef };
 }
 function issueWorktreePath(root, branchName) {
-  return join13(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
+  return join14(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
 }
 function resolveRegisteredIssueWorktreePath(worktreeListPorcelain, root, branchName) {
   const branchWorktreePath = parseWorktreeListPorcelain(
@@ -6728,7 +6967,9 @@ async function completeIssueRun(options) {
       blocked: config.labels.blocked
     },
     checkWaitOptions,
-    secretLikeContentDetectionEnabled: true
+    secretLikeContentDetectionEnabled: true,
+    repoRoot: ROOT,
+    beadsCompletion: options.beadsIssueRunContext
   });
   return {
     branchName,
@@ -7068,6 +7309,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,
@@ -7692,7 +7943,7 @@ async function ensureSandboxImageBuilt(repoRoot2, options) {
 }
 
 // execution/sandbox-options.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var POURKIT_ICM_CONTAINER_DIR = "/home/agent/.pourkit/icm";
 function buildSandboxOptions(repoRoot2, sandbox, memory) {
   const mounts = [];
@@ -7701,12 +7952,12 @@ function buildSandboxOptions(repoRoot2, sandbox, memory) {
   }
   if (memory?.available) {
     mounts.push({
-      hostPath: join14(repoRoot2, ".pourkit", "icm"),
+      hostPath: join15(repoRoot2, ".pourkit", "icm"),
       sandboxPath: POURKIT_ICM_CONTAINER_DIR,
       readonly: false
     });
     mounts.push({
-      hostPath: join14(repoRoot2, ".pourkit", "icm", "cache"),
+      hostPath: join15(repoRoot2, ".pourkit", "icm", "cache"),
       sandboxPath: "/home/agent/.cache/icm",
       readonly: false
     });
@@ -7724,10 +7975,10 @@ init_common();
 import { mkdtempSync } from "fs";
 import { writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname5, join as join15 } from "path";
+import { dirname as dirname5, join as join16 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join15(worktreePath, artifact.path);
+    const filePath = join16(worktreePath, artifact.path);
     await ensureDir(dirname5(filePath));
     await writeFile(filePath, artifact.content, "utf-8");
   }