@pourkit/cli 0.0.0-next-20260727021939 → 0.0.0-next-20260729083209

package/dist/cli.js

@@ -11965,10 +11965,49 @@ async function claimReadyPrdChild(options) {
     }
   };
 }
+async function listInProgressPrdChildren(options) {
+  const epicId = derivePrdEpicId(options.prdRef);
+  let result;
+  try {
+    result = await runBdJson({
+      repoRoot: options.repoRoot,
+      args: [
+        "list",
+        "--parent",
+        epicId,
+        "--status",
+        "in_progress",
+        "--limit",
+        "0",
+        "--json"
+      ],
+      logger: options.logger
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      epicId,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  return {
+    ok: true,
+    epicId,
+    children: findListChildren(result)
+  };
+}
 async function releaseClaimedPrdChild(options) {
   const result = await runBdJson({
     repoRoot: options.repoRoot,
-    args: ["update", options.childId, "--status", "open", "--json"],
+    args: [
+      "update",
+      options.childId,
+      "--status",
+      "open",
+      "--assignee",
+      "",
+      "--json"
+    ],
     logger: options.logger
   });
   const child = findReadyClaim(result);
@@ -11998,6 +12037,15 @@ function findReadyClaim(value) {
   }
   return void 0;
 }
+function findListChildren(value) {
+  if (!value) return [];
+  const entries = Array.isArray(value) ? value : value.id ? [value] : Object.values(value);
+  return entries.filter((entry) => Boolean(entry?.id)).map((entry) => ({
+    id: entry.id,
+    title: entry.title,
+    metadata: entry.metadata
+  }));
+}
 function isMissingIssueMessage3(value) {
   return /no issues? found matching/i.test(value);
 }
@@ -12239,7 +12287,7 @@ async function buildIssueContextFromBeadsChild(options) {
 var PRD_RUN_HEARTBEAT_INTERVAL_MS = 3e4;
 var PRD_RUN_LEASE_STALE_AFTER_MS = 12e4;
 function classifyPrdRunLiveness(options) {
-  const { record, now, currentHost, isPidAlive } = options;
+  const { record, now, currentHost, isPidAlive: isPidAlive2 } = options;
   const diagnostics = [];
   if (record.status !== "starting" && record.status !== "running") {
     return {
@@ -12300,8 +12348,8 @@ function classifyPrdRunLiveness(options) {
     };
   }
   const isSameHost = lease.host === currentHost;
-  if (isSameHost && isPidAlive !== void 0) {
-    const pidAlive = isPidAlive(lease.pid);
+  if (isSameHost && isPidAlive2 !== void 0) {
+    const pidAlive = isPidAlive2(lease.pid);
     if (!pidAlive) {
       return {
         status: "stale",
@@ -12610,6 +12658,14 @@ function enrichLaunchRepairGuidance(options) {
   return guidance;
 }
 var CURRENT_HOST = hostname();
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function createPrdRunHeartbeatLease(options, prdRef, currentStage) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -13472,6 +13528,24 @@ function claimedBeadsChildRepairIssue(child) {
     ...parsed.ok ? { beadsChildRef: parsed.childRef } : {}
   };
 }
+function buildInProgressBeadsChildGuidance(options) {
+  const countSuffix = options.totalChildren > 1 ? ` (${options.totalChildren} in-progress Beads children found)` : "";
+  const issue = claimedBeadsChildRepairIssue(options.child);
+  return buildPrdRunRepairGuidance({
+    blockedGate: "queue",
+    blockedStage: "queue-drain",
+    failureCode: "beads-child-in-progress",
+    humanReadableReason: `Beads-backed PRD drain found no ready children because Beads child ${options.child.id} is already in progress${countSuffix}.`,
+    repairability: "operator-action",
+    nextAction: "inspect-in-progress-beads-child",
+    nextRecommendedCommand: `bd show ${options.child.id} --json`,
+    diagnostics: [
+      `Beads child ${options.child.id} is in_progress, so bd ready --claim will not select it.`,
+      `Inspect the child runner, worktree, and log; if it is stale, finish the child or reset it before rerunning pourkit prd-run launch ${options.prdRef}.`
+    ],
+    issue
+  });
+}
 function canRetryQueueGuidanceWithoutIssue(options) {
   const { guidance, startReceipt } = options;
   if (guidance.blockedGate !== "queue") return false;
@@ -13629,7 +13703,8 @@ function shouldRestoreRetryableBeadsProjection(options) {
   if (!retryRepair) return false;
   if (issue.state !== "open") return false;
   const guidance = retryRepair.guidance;
-  if (guidance.repairability !== "automatic-retry-safe") return false;
+  const canRepairProjection = guidance.repairability === "automatic-retry-safe" || guidance.failureCode === "beads-child-in-progress";
+  if (!canRepairProjection) return false;
   if (guidance.blockedGate !== "queue") return false;
   if (issue.labels.includes(config.labels.blocked)) return false;
   return !issue.labels.includes(config.labels.readyForAgent) || issue.labels.includes(config.labels.agentInProgress) || issue.labels.includes(config.labels.readyForHuman);
@@ -13673,6 +13748,207 @@ async function closeBeadsChildForClosedIssueProjection(options) {
     logger: options.logger
   });
 }
+async function repairAndRunInProgressBeadsChild(options) {
+  const guidance = buildInProgressBeadsChildGuidance({
+    prdRef: options.prdRef,
+    child: options.child,
+    totalChildren: options.totalChildren
+  });
+  const contextResult = await buildIssueContextFromBeadsChild({
+    child: options.child,
+    issueProvider: options.issueProvider,
+    expectedPrdRef: options.prdRef
+  });
+  if (!contextResult.ok) {
+    return {
+      kind: "blocked",
+      outcome: buildLaunchBlockedOutcome(
+        options.repoRoot,
+        options.prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "beads-context-mapping-failed",
+          humanReadableReason: `Failed to map in-progress Beads child ${options.child.id} to Issue context: ${contextResult.reason}`,
+          repairability: "operator-action",
+          nextAction: "inspect-and-retry",
+          nextRecommendedCommand: `pourkit prd-run status ${options.prdRef}`,
+          diagnostics: [contextResult.reason],
+          issue: claimedBeadsChildRepairIssue(options.child)
+        }),
+        options.plan,
+        options.startOutcome,
+        options.targetName,
+        options.startReceipt
+      )
+    };
+  }
+  if (contextResult.issue.state === "closed") {
+    await closeBeadsChildForClosedIssueProjection({
+      repoRoot: options.repoRoot,
+      issue: contextResult.issue,
+      beadsChildId: contextResult.beads.childId,
+      logger: options.logger
+    });
+    return {
+      kind: "processed",
+      result: {
+        beadsChildId: contextResult.beads.childId,
+        issueNumber: contextResult.issue.number,
+        publicationStatus: "merged"
+      }
+    };
+  }
+  let issue;
+  try {
+    issue = await reconcileBlockedBeadsIssueProjection({
+      issue: contextResult.issue,
+      issueProvider: options.issueProvider,
+      config: options.config,
+      prdRef: options.prdRef,
+      repoRoot: options.repoRoot,
+      logger: options.logger,
+      retryRepair: {
+        guidance,
+        beadsChildId: contextResult.beads.childId
+      }
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      kind: "blocked",
+      outcome: buildLaunchBlockedOutcome(
+        options.repoRoot,
+        options.prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "beads-child-repair-failed",
+          humanReadableReason: `Failed to repair stale Beads child ${contextResult.beads.childId} projection for Issue #${contextResult.issue.number}: ${msg}`,
+          repairability: "operator-action",
+          nextAction: "inspect-and-retry",
+          nextRecommendedCommand: `pourkit prd-run status ${options.prdRef}`,
+          diagnostics: [msg],
+          issue: {
+            number: contextResult.issue.number,
+            title: contextResult.issue.title,
+            beadsChildId: contextResult.beads.childId,
+            beadsChildRef: contextResult.beads.childRef
+          }
+        }),
+        options.plan,
+        options.startOutcome,
+        options.targetName,
+        options.startReceipt
+      )
+    };
+  }
+  if (issue.labels.includes(options.config.labels.blocked)) {
+    return { kind: "skipped-blocked", child: options.child };
+  }
+  if (!issue.labels.includes(options.config.labels.readyForAgent) || issue.labels.includes(options.config.labels.agentInProgress)) {
+    return {
+      kind: "blocked",
+      outcome: buildLaunchBlockedOutcome(
+        options.repoRoot,
+        options.prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: "beads-child-repair-failed",
+          humanReadableReason: `Failed to restore runnable GitHub labels for stale Beads child ${contextResult.beads.childId}.`,
+          repairability: "operator-action",
+          nextAction: "inspect-and-retry",
+          nextRecommendedCommand: `pourkit prd-run status ${options.prdRef}`,
+          diagnostics: [
+            `Issue #${issue.number} labels after repair: ${issue.labels.join(", ") || "none"}`
+          ],
+          issue: {
+            number: issue.number,
+            title: issue.title,
+            beadsChildId: contextResult.beads.childId,
+            beadsChildRef: contextResult.beads.childRef
+          }
+        }),
+        options.plan,
+        options.startOutcome,
+        options.targetName,
+        options.startReceipt
+      )
+    };
+  }
+  try {
+    logCoordinatorStep(
+      options.logger,
+      "info",
+      `Resuming stale in-progress Beads child ${contextResult.beads.childId} through GitHub Issue #${issue.number}.`
+    );
+    const runResult = await runClaimedPrdIssueCommand({
+      targetName: options.targetName,
+      config: options.config,
+      issueProvider: options.issueProvider,
+      prProvider: options.prProvider,
+      executionProvider: options.executionProvider,
+      force: false,
+      logger: options.logger,
+      repoRoot: options.repoRoot,
+      issue,
+      queueRunContext: {
+        prdRef: options.prdRef,
+        prdBranch: options.startReceipt.prdBranch,
+        beadsChild: contextResult.beads
+      }
+    });
+    return {
+      kind: "processed",
+      result: {
+        beadsChildId: contextResult.beads.childId,
+        issueNumber: runResult.selected.number,
+        noOp: runResult.runResult.noOp,
+        publicationStatus: runResult.runResult.publicationStatus
+      }
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const repair = buildQueueIssueRunRepairMetadata(
+      msg,
+      "beads-issue-run-failed",
+      options.prdRef
+    );
+    const guidanceDiagnostics = [msg, ...repair.classifierDiagnostics ?? []];
+    return {
+      kind: "blocked",
+      outcome: buildLaunchBlockedOutcome(
+        options.repoRoot,
+        options.prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "queue",
+          blockedStage: "queue-drain",
+          failureCode: repair.failureCode,
+          humanReadableReason: msg,
+          repairability: repair.repairability,
+          nextAction: repair.nextAction,
+          nextRecommendedCommand: repair.nextRecommendedCommand,
+          timeoutClass: repair.timeoutClass,
+          diagnostics: guidanceDiagnostics,
+          issue: {
+            number: issue.number,
+            title: issue.title,
+            beadsChildId: contextResult.beads.childId,
+            beadsChildRef: contextResult.beads.childRef,
+            beadsChildClosed: msg.startsWith(
+              "Projection failure after Beads close"
+            )
+          }
+        }),
+        options.plan,
+        options.startOutcome,
+        options.targetName,
+        options.startReceipt
+      )
+    };
+  }
+}
 function extractIssueFromQueueError(error) {
   if (!error || typeof error !== "object" || !("issue" in error)) {
     return void 0;
@@ -14317,7 +14593,8 @@ async function launchPrdRun(options) {
     const liveness = classifyPrdRunLiveness({
       record: rec,
       now: /* @__PURE__ */ new Date(),
-      currentHost: CURRENT_HOST
+      currentHost: CURRENT_HOST,
+      isPidAlive
     });
     if (liveness.status === "active") {
       return {
@@ -15498,6 +15775,60 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
             "info",
             `Beads-backed PRD queue drain for ${prdRef} found no additional ready child work.`
           );
+          if (processedResults.length === 0 && !beadsClaimAttempted) {
+            const inProgressChildren = await listInProgressPrdChildren({
+              repoRoot: options.repoRoot,
+              prdRef,
+              logger
+            });
+            if (!inProgressChildren.ok) {
+              return buildLaunchBlockedOutcome(
+                options.repoRoot,
+                prdRef,
+                buildPrdRunRepairGuidance({
+                  blockedGate: "queue",
+                  blockedStage: "queue-drain",
+                  failureCode: "beads-in-progress-check-failed",
+                  humanReadableReason: `Failed to inspect in-progress Beads children for PRD ${prdRef}.`,
+                  repairability: "operator-action",
+                  nextAction: "inspect-and-retry",
+                  nextRecommendedCommand: `pourkit prd-run status ${prdRef}`,
+                  diagnostics: [inProgressChildren.reason]
+                }),
+                plan,
+                startOutcome,
+                targetName,
+                startReceipt
+              );
+            }
+            if (inProgressChildren.children.length > 0) {
+              const repairResult = await repairAndRunInProgressBeadsChild({
+                repoRoot: options.repoRoot,
+                prdRef,
+                child: inProgressChildren.children[0],
+                totalChildren: inProgressChildren.children.length,
+                targetName,
+                plan,
+                startOutcome,
+                startReceipt,
+                config: options.config,
+                issueProvider,
+                prProvider,
+                executionProvider,
+                logger
+              });
+              if (repairResult.kind === "blocked") {
+                return repairResult.outcome;
+              }
+              if (repairResult.kind === "skipped-blocked") {
+                skippedBlockedBeadsChildren.push(repairResult.child);
+                break;
+              }
+              beadsClaimAttempted = true;
+              processedResults.push(repairResult.result);
+              continue;
+            }
+          }
           break;
         }
         return buildLaunchBlockedOutcome(
@@ -23078,11 +23409,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260727021939")) {
-    return "0.0.0-next-20260727021939";
+  if (isPackageVersion("0.0.0-next-20260729083209")) {
+    return "0.0.0-next-20260729083209";
   }
-  if (isReleaseVersion("0.0.0-next-20260727021939")) {
-    return "0.0.0-next-20260727021939";
+  if (isReleaseVersion("0.0.0-next-20260729083209")) {
+    return "0.0.0-next-20260729083209";
   }
   try {
     const root = repoRoot();