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

package/dist/cli.js

@@ -14,15 +14,17 @@ import { createWriteStream } from "fs";
 import { mkdirSync } from "fs";
 import path from "path";
 import { styleText } from "util";
-function createLogger(name, filePath) {
+function createLogger(name, filePath, options = {}) {
   let fileStream;
   if (filePath) {
     mkdirSync(path.dirname(filePath), { recursive: true });
     fileStream = createWriteStream(filePath, { flags: "a" });
   }
-  const write = (terminal, plain = terminal) => {
-    process.stdout.write(`${terminal}
+  const write = (terminal, plain = terminal, detail = false) => {
+    if (!options.quiet || !detail) {
+      process.stdout.write(`${terminal}
 `);
+    }
     if (fileStream) {
       fileStream.write(`${plain}
 `);
@@ -34,7 +36,7 @@ function createLogger(name, filePath) {
       write(`${ts.terminal} ${msg}`, `${ts.plain} ${msg}`);
     },
     raw(msg) {
-      write(msg);
+      write(msg, msg, true);
     },
     step(step, msg) {
       const ts = timestamp();
@@ -54,7 +56,8 @@ function createLogger(name, filePath) {
       const ts = timestamp();
       write(
         `${ts.terminal} ${color("dim", key)}=${formatValue(key, value)}`,
-        `${ts.plain} ${key}=${value}`
+        `${ts.plain} ${key}=${value}`,
+        true
       );
     },
     async close() {
@@ -10022,6 +10025,12 @@ var PrdRunRepairAttemptSchema = z.object({
   failureCode: z.string().min(1),
   summary: z.string().min(1)
 }).strict();
+var PrdRunGuidanceTimeoutClassSchema = z.enum([
+  "launcher-stale-lease",
+  "sandcastle-idle-timeout",
+  "verification-command-timeout",
+  "agent-runtime-abort"
+]);
 var PrdRunRepairGuidanceSchema = z.object({
   createdAt: z.string().min(1),
   updatedAt: z.string().min(1),
@@ -10045,6 +10054,8 @@ var PrdRunRepairGuidanceSchema = z.object({
   ]),
   nextAction: z.string().min(1),
   nextRecommendedCommand: z.string().min(1),
+  nextRecommendedArgv: z.array(z.string().min(1)).optional(),
+  timeoutClass: PrdRunGuidanceTimeoutClassSchema.optional(),
   diagnostics: z.array(z.string()).optional(),
   offendingPaths: z.array(z.string()).optional(),
   issue: z.object({
@@ -10076,6 +10087,8 @@ function buildPrdRunRepairGuidance(input) {
     repairability: input.repairability,
     nextAction: input.nextAction,
     nextRecommendedCommand: input.nextRecommendedCommand,
+    nextRecommendedArgv: input.nextRecommendedArgv,
+    timeoutClass: input.timeoutClass,
     diagnostics: input.diagnostics,
     offendingPaths: input.offendingPaths,
     issue: input.issue,
@@ -10118,6 +10131,7 @@ function validateActivePrdRunRepairGuidance(record) {
         repairability: "unsupported-state",
         nextAction: "inspect-prd-run-state",
         nextRecommendedCommand: `pourkit prd-run status ${record.prdRef}`,
+        nextRecommendedArgv: ["pourkit", "prd-run", "status", record.prdRef],
         diagnostics: [
           `Validation error: ${parsed.error?.message ?? "Unknown schema error"}`
         ]
@@ -10136,6 +10150,7 @@ function validateActivePrdRunRepairGuidance(record) {
       repairability: "unsupported-state",
       nextAction: "inspect-prd-run-state",
       nextRecommendedCommand: `pourkit prd-run status ${record.prdRef}`,
+      nextRecommendedArgv: ["pourkit", "prd-run", "status", record.prdRef],
       diagnostics: record.diagnostics ? [...record.diagnostics] : []
     }
   };
@@ -10149,6 +10164,10 @@ function renderPrdRunRepairGuidance(guidance) {
   lines.push(`Repairability: ${guidance.repairability}`);
   lines.push(`Next Action: ${guidance.nextAction}`);
   lines.push(`Command: ${guidance.nextRecommendedCommand}`);
+  if (guidance.nextRecommendedArgv)
+    lines.push(`Argv: ${JSON.stringify(guidance.nextRecommendedArgv)}`);
+  if (guidance.timeoutClass)
+    lines.push(`Timeout Class: ${guidance.timeoutClass}`);
   if (guidance.targetName) lines.push(`Target: ${guidance.targetName}`);
   if (guidance.baseBranch) lines.push(`Base: ${guidance.baseBranch}`);
   if (guidance.issue) {
@@ -10194,6 +10213,59 @@ function renderPrdRunRepairGuidance(guidance) {
 
 // prd-run/state.ts
 var PRD_RUN_STATE_DIR = ".pourkit/prd-runs";
+var prdRunCurrentIssueSchema = z2.object({
+  number: z2.number().int().positive().optional(),
+  title: z2.string().optional(),
+  beadsChildId: z2.string().min(1).optional(),
+  beadsChildRef: z2.string().min(1).optional()
+}).strict();
+var prdRunHeartbeatLeaseSchema = z2.object({
+  launchId: z2.string().min(1),
+  host: z2.string().min(1),
+  pid: z2.number().int(),
+  argv: z2.array(z2.string()),
+  startedAt: z2.string().min(1),
+  lastHeartbeatAt: z2.string().min(1),
+  currentStage: z2.string().min(1),
+  currentIssue: prdRunCurrentIssueSchema.optional(),
+  logPath: z2.string().optional()
+}).strict();
+var prdRunTimeoutClassSchema = z2.enum([
+  "launcher-stale-lease",
+  "sandcastle-idle-timeout",
+  "verification-command-timeout",
+  "agent-runtime-abort"
+]);
+var prdRunEventKindSchema = z2.enum([
+  "launch-started",
+  "active-launch-reported",
+  "stale-lease-recovered",
+  "projection-repaired",
+  "projection-repair-failed",
+  "blocked-guidance-written",
+  "timeout-classified",
+  "launch-completed",
+  "launch-blocked"
+]);
+var prdRunEventHistoryEntrySchema = z2.object({
+  eventId: z2.string().min(1),
+  kind: prdRunEventKindSchema,
+  occurredAt: z2.string().min(1),
+  launchId: z2.string().min(1).optional(),
+  stage: z2.string().optional(),
+  issue: prdRunCurrentIssueSchema.optional(),
+  failureCode: z2.string().optional(),
+  repairability: z2.enum(["automatic-retry-safe", "operator-action", "unsupported-state"]).optional(),
+  timeoutClass: prdRunTimeoutClassSchema.optional(),
+  summary: z2.string().min(1),
+  diagnostics: z2.array(z2.string()).optional()
+}).strict();
+var prdRunQueueProgressSchema = z2.object({
+  processedIssueNumbers: z2.array(z2.number().int().positive()),
+  processedCount: z2.number().int().nonnegative(),
+  lastIssueNumber: z2.number().int().positive().optional(),
+  updatedAt: z2.string().min(1)
+}).strict();
 var PrdRunRecordSchema = z2.object({
   prdRef: z2.string().regex(
     /^PRD-\d{4}$/,
@@ -10316,7 +10388,10 @@ var PrdRunRecordSchema = z2.object({
       acceptedBy: z2.string().min(1),
       acceptedAt: z2.string().min(1)
     }).strict()
-  ).optional()
+  ).optional(),
+  heartbeatLease: prdRunHeartbeatLeaseSchema.optional(),
+  eventHistory: z2.array(prdRunEventHistoryEntrySchema).optional(),
+  queueProgress: prdRunQueueProgressSchema.optional()
 }).strict();
 function normalizePrdRunRef(ref) {
   const trimmed = ref.trim().toUpperCase();
@@ -11125,10 +11200,13 @@ async function runPrdPlanWorkspacePublishCommand(options) {
 
 // commands/prd-run.ts
 import { lstatSync, realpathSync } from "fs";
+import { hostname as hostname2 } from "os";
 import { join as join24 } from "path";
 
 // prd-run/coordinator.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { randomUUID } from "crypto";
+import { hostname } from "os";
 import { join as join23 } from "path";
 import { Match, pipe } from "effect";
 init_common();
@@ -12157,6 +12235,141 @@ async function buildIssueContextFromBeadsChild(options) {
   }
 }
 
+// prd-run/liveness.ts
+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 diagnostics = [];
+  if (record.status !== "starting" && record.status !== "running") {
+    return {
+      status: "unknown",
+      reason: `Record status is "${record.status}", not starting or running`,
+      diagnostics: [
+        ...diagnostics,
+        `Liveness classification requires starting or running status, got "${record.status}"`
+      ]
+    };
+  }
+  const lease = record.heartbeatLease;
+  if (!lease) {
+    return {
+      status: "stale",
+      reason: "No heartbeat lease exists",
+      diagnostics: [
+        ...diagnostics,
+        "PRD Run record has no heartbeatLease field"
+      ]
+    };
+  }
+  if (!Number.isFinite(lease.pid) || !Number.isInteger(lease.pid) || lease.pid <= 0) {
+    return {
+      status: "unknown",
+      reason: "Invalid PID in heartbeat lease",
+      lease,
+      diagnostics: [
+        ...diagnostics,
+        `PID value "${lease.pid}" is not a valid positive integer`
+      ]
+    };
+  }
+  const heartbeatTime = new Date(lease.lastHeartbeatAt);
+  if (Number.isNaN(heartbeatTime.getTime())) {
+    return {
+      status: "unknown",
+      reason: "Unparseable heartbeat timestamp",
+      lease,
+      diagnostics: [
+        ...diagnostics,
+        `Cannot parse lastHeartbeatAt "${lease.lastHeartbeatAt}" as a valid date`
+      ]
+    };
+  }
+  const heartbeatAgeMs = now.getTime() - heartbeatTime.getTime();
+  if (heartbeatAgeMs < 0) {
+    const futureDelta = Math.abs(heartbeatAgeMs);
+    return {
+      status: "unknown",
+      reason: `Heartbeat timestamp is ${futureDelta}ms in the future`,
+      lease,
+      heartbeatAgeMs,
+      diagnostics: [
+        ...diagnostics,
+        `lastHeartbeatAt "${lease.lastHeartbeatAt}" is ${futureDelta}ms ahead of reference time "${now.toISOString()}"`
+      ]
+    };
+  }
+  const isSameHost = lease.host === currentHost;
+  if (isSameHost && isPidAlive !== void 0) {
+    const pidAlive = isPidAlive(lease.pid);
+    if (!pidAlive) {
+      return {
+        status: "stale",
+        reason: "Same-host PID is not alive",
+        lease,
+        heartbeatAgeMs,
+        diagnostics: [
+          ...diagnostics,
+          `PID ${lease.pid} on host "${lease.host}" is not alive (advisory same-host evidence)`
+        ]
+      };
+    }
+  }
+  if (heartbeatAgeMs > PRD_RUN_LEASE_STALE_AFTER_MS) {
+    return {
+      status: "stale",
+      reason: `Heartbeat age ${heartbeatAgeMs}ms exceeds stale threshold ${PRD_RUN_LEASE_STALE_AFTER_MS}ms`,
+      lease,
+      heartbeatAgeMs,
+      diagnostics: [
+        ...diagnostics,
+        `lastHeartbeatAt "${lease.lastHeartbeatAt}" is ${heartbeatAgeMs}ms old (threshold: ${PRD_RUN_LEASE_STALE_AFTER_MS}ms)`
+      ]
+    };
+  }
+  return {
+    status: "active",
+    reason: isSameHost ? "Fresh heartbeat lease on current host" : `Fresh heartbeat lease on host "${lease.host}"`,
+    lease,
+    heartbeatAgeMs,
+    diagnostics
+  };
+}
+
+// prd-run/failure-classification.ts
+function classifyPrdRunFailure(reason, _context) {
+  if (/^Sandcastle failed:/.test(reason) && /(?:timeout|timed?\s+out|aborted)/i.test(reason)) {
+    return {
+      timeoutClass: "sandcastle-idle-timeout",
+      diagnostics: [
+        "Timeout class: sandcastle-idle-timeout",
+        "Sandcastle execution timeout detected."
+      ]
+    };
+  }
+  if (/^Timeout waiting for/.test(reason) && /checks|to be green/.test(reason)) {
+    return {
+      timeoutClass: "verification-command-timeout",
+      diagnostics: [
+        "Timeout class: verification-command-timeout",
+        "Verification wait timeout detected."
+      ]
+    };
+  }
+  if (/\b(?:agent|runtime)\b.*\b(?:abort|timeout|timed?\s+out|killed)\b/i.test(
+    reason
+  ) || /\b(?:abort|killed)\b.*\b(?:agent|runtime)\b/i.test(reason)) {
+    return {
+      timeoutClass: "agent-runtime-abort",
+      diagnostics: [
+        "Timeout class: agent-runtime-abort",
+        "Agent/runtime abort detected."
+      ]
+    };
+  }
+  return { diagnostics: [] };
+}
+
 // prd-run/coordinator.ts
 function canRetryFinalReviewBlock(record) {
   if (record.status !== "blocked" || record.blockedGate !== "final-review") {
@@ -12323,6 +12536,148 @@ function resolvePrdRunBaseBranch(options) {
   const source = options.baseBranchOverride !== void 0 ? "override" : "target";
   return { ok: true, baseBranch: trimmed, source };
 }
+function buildPrdRunLaunchRetryCommand(options, prdRef) {
+  if (options.originalArgv && options.originalArgv.length > 0) {
+    return {
+      command: options.originalArgv.join(" "),
+      argv: [...options.originalArgv]
+    };
+  }
+  const argv = ["pourkit", "prd-run", "launch", prdRef];
+  if (options.targetName) {
+    argv.push("--target", options.targetName);
+  }
+  if (options.baseBranchOverride) {
+    argv.push("--base", options.baseBranchOverride);
+  }
+  if (options.quiet === true) {
+    argv.push("--quiet");
+  }
+  if (options.autoMerge === false) {
+    argv.push("--no-auto-merge");
+  }
+  if (options.adoptExistingBranch === true) {
+    argv.push("--adopt-existing-branch");
+  }
+  if (options.cwd) {
+    argv.push("--cwd", options.cwd);
+  }
+  return { command: argv.join(" "), argv };
+}
+function isLaunchRecommendation(command) {
+  return /\bprd-run\s+launch\b/.test(command);
+}
+function isStatusRecommendation(command) {
+  return /\bprd-run\s+status\b/.test(command);
+}
+function buildFallbackLaunchRetryArgv(options) {
+  if (options.heartbeatArgv && options.heartbeatArgv.length > 0) {
+    return [...options.heartbeatArgv];
+  }
+  const argv = ["pourkit", "prd-run", "launch", options.prdRef];
+  if (options.targetName) argv.push("--target", options.targetName);
+  if (options.baseBranch) argv.push("--base", options.baseBranch);
+  return argv;
+}
+function enrichLaunchRepairGuidance(options) {
+  const { guidance, prdRef, targetName, baseBranch, heartbeatArgv } = options;
+  if (guidance.nextAction === "rerun-prd-run-launch" || isLaunchRecommendation(guidance.nextRecommendedCommand)) {
+    const argv = guidance.nextRecommendedArgv ?? buildFallbackLaunchRetryArgv({
+      prdRef,
+      targetName: guidance.targetName ?? targetName,
+      baseBranch: guidance.baseBranch ?? baseBranch,
+      heartbeatArgv
+    });
+    return {
+      ...guidance,
+      nextRecommendedCommand: argv.join(" "),
+      nextRecommendedArgv: argv
+    };
+  }
+  if (isStatusRecommendation(guidance.nextRecommendedCommand)) {
+    const argv = guidance.nextRecommendedArgv ?? [
+      "pourkit",
+      "prd-run",
+      "status",
+      prdRef
+    ];
+    return {
+      ...guidance,
+      nextRecommendedCommand: argv.join(" "),
+      nextRecommendedArgv: argv
+    };
+  }
+  return guidance;
+}
+var CURRENT_HOST = hostname();
+function createPrdRunHeartbeatLease(options, prdRef, currentStage) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    launchId: randomUUID(),
+    host: CURRENT_HOST,
+    pid: process.pid,
+    argv: buildPrdRunLaunchRetryCommand(options, prdRef).argv,
+    startedAt: now,
+    lastHeartbeatAt: now,
+    currentStage
+  };
+}
+function refreshPrdRunHeartbeat(repoRoot2, prdRef, launchId, update) {
+  const current = readPrdRun(repoRoot2, prdRef).record;
+  if (!current?.heartbeatLease) return;
+  if (current.heartbeatLease.launchId !== launchId) return;
+  writePrdRunRecord(repoRoot2, {
+    ...current,
+    heartbeatLease: {
+      ...current.heartbeatLease,
+      ...update
+    },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function withPrdRunHeartbeat(repoRoot2, prdRef, lease, fn) {
+  const interval = setInterval(() => {
+    refreshPrdRunHeartbeat(repoRoot2, prdRef, lease.launchId, {
+      lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }, PRD_RUN_HEARTBEAT_INTERVAL_MS);
+  try {
+    return await fn({
+      updateStage: (stage) => {
+        refreshPrdRunHeartbeat(repoRoot2, prdRef, lease.launchId, {
+          currentStage: stage,
+          lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    });
+  } finally {
+    clearInterval(interval);
+  }
+}
+var PRD_RUN_EVENT_HISTORY_LIMIT = 50;
+function appendPrdRunEvent(record, event) {
+  const currentHistory = record?.eventHistory ?? [];
+  const newEntry = {
+    ...event,
+    eventId: randomUUID(),
+    occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return [...currentHistory, newEntry].slice(-PRD_RUN_EVENT_HISTORY_LIMIT);
+}
+function updatePrdRunQueueProgress(record, issueNumbers) {
+  const current = record?.queueProgress;
+  const merged = new Set(current?.processedIssueNumbers ?? []);
+  for (const n of issueNumbers) {
+    merged.add(n);
+  }
+  const sorted = [...merged].sort((a, b) => a - b);
+  return {
+    processedIssueNumbers: sorted,
+    processedCount: sorted.length,
+    lastIssueNumber: sorted.length > 0 ? sorted[sorted.length - 1] : current?.lastIssueNumber,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 function fetchOriginBranch(repoRoot2, baseBranch) {
   const fetchResult = spawnSync2("git", ["fetch", "origin", baseBranch], {
     cwd: repoRoot2,
@@ -12537,6 +12892,8 @@ function persistStartingPrdRunRecord(repoRoot2, prdRef, existingRecord, start, c
   });
 }
 function blocked(repoRoot2, prdRef, gate, failureCode, reason, diagnostics, targetName, stage, repairability = "operator-action") {
+  const retryArgv = ["pourkit", "prd-run", "launch", prdRef];
+  if (targetName) retryArgv.push("--target", targetName);
   return buildBlockedOutcome(
     repoRoot2,
     prdRef,
@@ -12547,7 +12904,8 @@ function blocked(repoRoot2, prdRef, gate, failureCode, reason, diagnostics, targ
       humanReadableReason: reason,
       repairability,
       nextAction: repairability === "automatic-retry-safe" ? "rerun-prd-run-launch" : "inspect-and-retry",
-      nextRecommendedCommand: `pourkit prd-run launch ${prdRef}`,
+      nextRecommendedCommand: retryArgv.join(" "),
+      nextRecommendedArgv: retryArgv,
       ...diagnostics?.length ? { diagnostics: [...diagnostics] } : {},
       ...targetName ? { targetName } : {}
     }),
@@ -12911,13 +13269,49 @@ async function startPrdRun(options) {
   };
 }
 function buildLaunchBlockedOutcome(repoRoot2, prdRef, guidance, resume, start, targetName, startReceipt) {
-  const enrichedGuidance = {
+  const current = readPrdRun(repoRoot2, prdRef).record;
+  const enrichedGuidanceBase = {
     ...guidance,
     targetName: guidance.targetName ?? targetName,
     baseBranch: guidance.baseBranch ?? startReceipt?.startBaseBranch
   };
-  const current = readPrdRun(repoRoot2, prdRef).record;
+  const enrichedGuidance = enrichLaunchRepairGuidance({
+    guidance: enrichedGuidanceBase,
+    prdRef,
+    targetName,
+    baseBranch: startReceipt?.startBaseBranch,
+    heartbeatArgv: current?.heartbeatLease?.argv
+  });
   const postCompletionFinalReview = current?.postCompletionFinalReview;
+  let eventHistory = current?.eventHistory ?? [];
+  if (enrichedGuidance.timeoutClass) {
+    eventHistory = appendPrdRunEvent(
+      current ? { ...current, eventHistory } : null,
+      {
+        kind: "timeout-classified",
+        launchId: current?.heartbeatLease?.launchId,
+        stage: enrichedGuidance.blockedStage,
+        failureCode: enrichedGuidance.failureCode,
+        repairability: enrichedGuidance.repairability,
+        timeoutClass: enrichedGuidance.timeoutClass,
+        summary: `PRD Run ${prdRef} classified timeout as ${enrichedGuidance.timeoutClass}.`,
+        diagnostics: enrichedGuidance.diagnostics?.length ? [...enrichedGuidance.diagnostics] : void 0
+      }
+    );
+  }
+  eventHistory = appendPrdRunEvent(
+    current ? { ...current, eventHistory } : null,
+    {
+      kind: "launch-blocked",
+      launchId: current?.heartbeatLease?.launchId,
+      stage: enrichedGuidance.blockedStage,
+      failureCode: enrichedGuidance.failureCode,
+      repairability: enrichedGuidance.repairability,
+      summary: enrichedGuidance.humanReadableReason,
+      diagnostics: enrichedGuidance.diagnostics?.length ? [...enrichedGuidance.diagnostics] : void 0
+    }
+  );
+  const queueProgress = current?.queueProgress;
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status: "blocked",
@@ -12929,6 +13323,8 @@ function buildLaunchBlockedOutcome(repoRoot2, prdRef, guidance, resume, start, t
     ...targetName ? { targetName } : {},
     ...startReceipt ? { start: startReceipt } : {},
     ...postCompletionFinalReview ? { postCompletionFinalReview } : {},
+    eventHistory,
+    ...queueProgress ? { queueProgress } : {},
     repairGuidance: enrichedGuidance
   });
   return {
@@ -12940,22 +13336,37 @@ function buildLaunchBlockedOutcome(repoRoot2, prdRef, guidance, resume, start, t
   };
 }
 function writeDrainedRecord(repoRoot2, prdRef, startReceipt, targetName) {
+  const current = readPrdRun(repoRoot2, prdRef).record;
+  const eventHistory = current?.eventHistory;
+  const queueProgress = current?.queueProgress;
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status: "drained",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName,
-    start: startReceipt
+    start: startReceipt,
+    ...eventHistory ? { eventHistory } : {},
+    ...queueProgress ? { queueProgress } : {}
   });
 }
 function writeTerminalRecord(repoRoot2, prdRef, status, targetName, startReceipt, prdBranch) {
+  const current = readPrdRun(repoRoot2, prdRef).record;
+  const eventHistory = appendPrdRunEvent(current, {
+    kind: "launch-completed",
+    launchId: current?.heartbeatLease?.launchId,
+    stage: "completed",
+    summary: `PRD Run ${prdRef} completed with status ${status}. Branch: ${prdBranch}.`
+  });
+  const queueProgress = current?.queueProgress;
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName,
     prdBranch,
-    start: startReceipt
+    start: startReceipt,
+    eventHistory,
+    ...queueProgress ? { queueProgress } : {}
   });
 }
 function validateRecordedIssueResumeEvidence(options) {
@@ -13035,11 +13446,14 @@ var QUEUE_FAILURE_CODES_WITHOUT_SELECTED_ISSUE = /* @__PURE__ */ new Set([
 var ISSUE_FINAL_REVIEW_HANDOFF_PREFIX = "Issue Final Review requires human handoff";
 function buildQueueIssueRunRepairMetadata(message, fallbackFailureCode, prdRef) {
   if (!message.startsWith(ISSUE_FINAL_REVIEW_HANDOFF_PREFIX)) {
+    const classification = classifyPrdRunFailure(message, { prdRef });
     return {
       failureCode: fallbackFailureCode,
       repairability: "automatic-retry-safe",
       nextAction: "rerun-prd-run-launch",
-      nextRecommendedCommand: "pourkit prd-run launch"
+      nextRecommendedCommand: "pourkit prd-run launch",
+      timeoutClass: classification.timeoutClass,
+      classifierDiagnostics: classification.diagnostics
     };
   }
   return {
@@ -13105,13 +13519,22 @@ async function prdParentIssueIsClosed(options) {
   }
 }
 async function reconcileBlockedBeadsIssueProjection(options) {
-  const { issue, issueProvider, config, prdRef, logger, retryRepair } = options;
+  const {
+    issue,
+    issueProvider,
+    config,
+    prdRef,
+    repoRoot: repoRoot2,
+    logger,
+    retryRepair
+  } = options;
   if (shouldRestoreRetryableBeadsProjection({ issue, config, retryRepair })) {
     logCoordinatorStep(
       logger,
       "info",
       `Restoring retryable GitHub projection for Beads Issue #${issue.number}.`
     );
+    let repairFailed = false;
     for (const label of [
       config.labels.blocked,
       config.labels.agentInProgress,
@@ -13121,9 +13544,25 @@ async function reconcileBlockedBeadsIssueProjection(options) {
       try {
         await issueProvider.removeLabel(issue.number, label);
       } catch {
+        repairFailed = true;
       }
     }
     await issueProvider.addLabels(issue.number, [config.labels.readyForAgent]);
+    const currentRecord = readPrdRun(repoRoot2, prdRef).record;
+    const projectionEvent = appendPrdRunEvent(currentRecord, {
+      kind: repairFailed ? "projection-repair-failed" : "projection-repaired",
+      launchId: currentRecord?.heartbeatLease?.launchId,
+      stage: "queue-drain",
+      issue: { number: issue.number, title: issue.title },
+      summary: repairFailed ? `Projection repair failed for Issue #${issue.number}.` : `Projection repaired for Issue #${issue.number}.`
+    });
+    writePrdRunRecord(repoRoot2, {
+      ...currentRecord,
+      prdRef,
+      status: currentRecord?.status ?? "running",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      eventHistory: projectionEvent
+    });
     return await issueProvider.fetchIssue(issue.number);
   }
   if (!issue.labels.includes(config.labels.blocked)) {
@@ -13260,7 +13699,7 @@ async function attemptRecordedIssueLabelProjection(options, prdRef, resumeIssueN
     return true;
   } catch {
     const state = readPrdRun(options.repoRoot, prdRef).record;
-    const guidance = originalGuidance ?? state?.repairGuidance;
+    const guidance = state?.repairGuidance ?? originalGuidance;
     if (guidance) {
       const updated = appendPrdRunRepairAttempt(guidance, {
         outcome: "projection-failed",
@@ -13638,7 +14077,9 @@ async function runPostCompletionAfterTerminal(options, prdRef, record, resumeFac
         prdBranch,
         start: record.start,
         postCompletionFinalReview: pcReceipt,
-        repairGuidance: record.repairGuidance
+        repairGuidance: record.repairGuidance,
+        ...current?.eventHistory ? { eventHistory: current.eventHistory } : {},
+        ...current?.queueProgress ? { queueProgress: current.queueProgress } : {}
       });
     }
   };
@@ -13873,28 +14314,57 @@ async function launchPrdRun(options) {
   const plan = planPrdRunLaunchResume(existingRecord.record);
   const rec = existingRecord.record;
   if (rec && (rec.status === "starting" || rec.status === "running") && !rec.repairGuidance) {
-    const nextRecommendedCommand = `pourkit prd-run launch ${prdRef}${rec.targetName ? ` --target ${rec.targetName}` : ""}${rec.start?.startBaseBranch ? ` --base ${rec.start.startBaseBranch}` : ""}`;
-    return buildLaunchBlockedOutcome(
-      options.repoRoot,
-      prdRef,
-      buildPrdRunRepairGuidance({
-        blockedGate: "branch-state",
-        blockedStage: "start-validation",
-        failureCode: "prd-run-in-progress",
-        humanReadableReason: `PRD Run ${prdRef} is already ${rec.status}. A second launch cannot start another Queue drain while the run is in progress.`,
-        repairability: "automatic-retry-safe",
-        nextAction: "confirm-no-active-run-then-rerun-prd-run-launch",
-        nextRecommendedCommand,
-        diagnostics: [
-          `PRD Run ${prdRef} is in status "${rec.status}" without active repair guidance.`,
-          "If no pourkit/sandcastle agent process is still active for this PRD, rerun the launch command to resume from the preserved start receipt."
-        ]
-      }),
-      plan,
-      void 0,
-      rec.targetName ?? options.targetName,
-      rec.start
-    );
+    const liveness = classifyPrdRunLiveness({
+      record: rec,
+      now: /* @__PURE__ */ new Date(),
+      currentHost: CURRENT_HOST
+    });
+    if (liveness.status === "active") {
+      return {
+        kind: "active",
+        prdRef,
+        status: rec.status,
+        liveness,
+        resume: plan
+      };
+    }
+    if (liveness.status === "unknown") {
+      const retryCommand = buildPrdRunLaunchRetryCommand(options, prdRef);
+      return buildLaunchBlockedOutcome(
+        options.repoRoot,
+        prdRef,
+        buildPrdRunRepairGuidance({
+          blockedGate: "branch-state",
+          blockedStage: "start-validation",
+          failureCode: "prd-run-liveness-unknown",
+          humanReadableReason: `PRD Run ${prdRef} has unknown liveness for status "${rec.status}". The heartbeat lease data is malformed or unreadable.`,
+          repairability: "operator-action",
+          nextAction: "inspect-prd-run-state",
+          nextRecommendedCommand: retryCommand.command,
+          nextRecommendedArgv: retryCommand.argv,
+          diagnostics: [
+            ...liveness.diagnostics,
+            `PRD Run ${prdRef} is in status "${rec.status}" with unreadable lease data.`
+          ]
+        }),
+        plan,
+        void 0,
+        rec.targetName ?? options.targetName,
+        rec.start
+      );
+    }
+    const eventHistory = appendPrdRunEvent(rec, {
+      kind: "stale-lease-recovered",
+      timeoutClass: "launcher-stale-lease",
+      summary: `Stale lease recovered for PRD Run ${prdRef}. Status: "${rec.status}", reason: "${liveness.reason}".`,
+      diagnostics: liveness.diagnostics.length > 0 ? [...liveness.diagnostics] : void 0
+    });
+    writePrdRunRecord(options.repoRoot, {
+      ...rec,
+      heartbeatLease: void 0,
+      eventHistory,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   if (existingRecord.record === null && existingRecord.diagnostics.length > 0) {
     return buildLaunchBlockedOutcome(
@@ -14054,13 +14524,14 @@ async function launchPrdRun(options) {
       baseBranchOverride: options.baseBranchOverride
     });
     if (startOutcome.kind === "blocked") {
-      return {
-        kind: "blocked",
+      return buildLaunchBlockedOutcome(
+        options.repoRoot,
         prdRef,
-        guidance: startOutcome.guidance,
-        start: startOutcome,
-        resume: plan
-      };
+        startOutcome.guidance,
+        plan,
+        startOutcome,
+        options.targetName
+      );
     }
   }
   const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
@@ -14200,13 +14671,28 @@ async function launchPrdRun(options) {
     startReceipt.queueStartedAt = (/* @__PURE__ */ new Date()).toISOString();
     startReceipt.queueCommand = "queue-run";
   }
+  const launchLease = createPrdRunHeartbeatLease(
+    options,
+    prdRef,
+    "queue-drain"
+  );
+  const launchStartedEventHistory = appendPrdRunEvent(currentRecord, {
+    kind: "launch-started",
+    launchId: launchLease.launchId,
+    stage: "queue-drain",
+    summary: `PRD Run ${prdRef} launch started. Target: ${targetName}.`
+  });
+  const currentQueueProgress = currentRecord?.queueProgress;
   writePrdRunRecord(options.repoRoot, {
     prdRef,
     status: "running",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName,
     start: startReceipt,
-    repairGuidance: currentRecord?.repairGuidance
+    repairGuidance: currentRecord?.repairGuidance,
+    heartbeatLease: launchLease,
+    eventHistory: launchStartedEventHistory,
+    ...currentQueueProgress ? { queueProgress: currentQueueProgress } : {}
   });
   const modeSelection = await selectPrdRunCoordinatorMode({
     repoRoot: options.repoRoot,
@@ -14228,25 +14714,33 @@ async function launchPrdRun(options) {
       startReceipt
     );
   }
-  if (modeSelection.mode === "github") {
-    return await launchGithubQueueDrain(
-      options,
-      prdRef,
-      startReceipt,
-      targetName,
-      plan,
-      startOutcome,
-      resumeIssueNumber
-    );
-  }
-  return await launchBeadsQueueDrain(
-    options,
+  return await withPrdRunHeartbeat(
+    options.repoRoot,
     prdRef,
-    startReceipt,
-    targetName,
-    plan,
-    startOutcome,
-    resumeIssueNumber
+    launchLease,
+    async (heartbeat) => {
+      heartbeat.updateStage("queue-drain");
+      if (modeSelection.mode === "github") {
+        return await launchGithubQueueDrain(
+          options,
+          prdRef,
+          startReceipt,
+          targetName,
+          plan,
+          startOutcome,
+          resumeIssueNumber
+        );
+      }
+      return await launchBeadsQueueDrain(
+        options,
+        prdRef,
+        startReceipt,
+        targetName,
+        plan,
+        startOutcome,
+        resumeIssueNumber
+      );
+    }
   );
 }
 async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName, plan, startOutcome, resumeIssueNumber) {
@@ -14384,6 +14878,21 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
       startReceipt.queueProcessedCount = outcome.processedCount;
       const prdBranch = startReceipt.prdBranch ?? prdRef;
+      const drainCurrentRecord = readPrdRun(options.repoRoot, prdRef).record;
+      if (drainCurrentRecord) {
+        const drainIssueNumbers = outcome.results.map((r) => r.selected.number);
+        const updatedQueueProgress = updatePrdRunQueueProgress(
+          drainCurrentRecord,
+          drainIssueNumbers
+        );
+        writePrdRunRecord(options.repoRoot, {
+          ...drainCurrentRecord,
+          prdRef,
+          status: drainCurrentRecord.status,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          queueProgress: updatedQueueProgress
+        });
+      }
       writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
       const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
       if (drainRecord) {
@@ -14531,13 +15040,13 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
     return result;
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    const diagnostics = [msg];
     const issue = extractIssueFromQueueError(error);
     const repair = buildQueueIssueRunRepairMetadata(
       msg,
       "queue-exception",
       prdRef
     );
+    const diagnostics = [msg, ...repair.classifierDiagnostics ?? []];
     const result = buildLaunchBlockedOutcome(
       options.repoRoot,
       prdRef,
@@ -14549,6 +15058,7 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
         repairability: repair.repairability,
         nextAction: repair.nextAction,
         nextRecommendedCommand: repair.nextRecommendedCommand,
+        timeoutClass: repair.timeoutClass,
         diagnostics,
         issue
       }),
@@ -14760,6 +15270,7 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
           issueProvider,
           config: options.config,
           prdRef,
+          repoRoot: options.repoRoot,
           logger
         });
         if (issue.labels.includes(options.config.labels.blocked)) {
@@ -14808,6 +15319,10 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
         const beadsChildClosed = msg.startsWith(
           "Projection failure after Beads close"
         );
+        const guidanceDiagnostics = [
+          msg,
+          ...repair.classifierDiagnostics ?? []
+        ];
         return buildLaunchBlockedOutcome(
           options.repoRoot,
           prdRef,
@@ -14819,7 +15334,8 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
             repairability: repair.repairability,
             nextAction: repair.nextAction,
             nextRecommendedCommand: repair.nextRecommendedCommand,
-            diagnostics: [msg],
+            timeoutClass: repair.timeoutClass,
+            diagnostics: guidanceDiagnostics,
             issue: {
               number: contextResult.issue.number,
               title: contextResult.issue.title,
@@ -14873,6 +15389,7 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
         issueProvider,
         config: options.config,
         prdRef,
+        repoRoot: options.repoRoot,
         logger,
         ...resumeBeadsContext ? {
           retryRepair: {
@@ -14934,6 +15451,10 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
         "resume-issue-failed",
         prdRef
       );
+      const guidanceDiagnostics = [
+        msg,
+        ...repair.classifierDiagnostics ?? []
+      ];
       return buildLaunchBlockedOutcome(
         options.repoRoot,
         prdRef,
@@ -14945,7 +15466,8 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
           repairability: repair.repairability,
           nextAction: repair.nextAction,
           nextRecommendedCommand: repair.nextRecommendedCommand,
-          diagnostics: [msg],
+          timeoutClass: repair.timeoutClass,
+          diagnostics: guidanceDiagnostics,
           issue: resumeIssue ? {
             number: fetchedIssue.number,
             title: fetchedIssue.title,
@@ -15050,6 +15572,7 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
           issueProvider,
           config: options.config,
           prdRef,
+          repoRoot: options.repoRoot,
           logger
         });
         if (issue.labels.includes(options.config.labels.blocked)) {
@@ -15099,6 +15622,10 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
         const beadsChildClosed = msg.startsWith(
           "Projection failure after Beads close"
         );
+        const guidanceDiagnostics = [
+          msg,
+          ...repair.classifierDiagnostics ?? []
+        ];
         return buildLaunchBlockedOutcome(
           options.repoRoot,
           prdRef,
@@ -15110,7 +15637,8 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
             repairability: repair.repairability,
             nextAction: repair.nextAction,
             nextRecommendedCommand: repair.nextRecommendedCommand,
-            diagnostics: [msg],
+            timeoutClass: repair.timeoutClass,
+            diagnostics: guidanceDiagnostics,
             issue: {
               number: contextResult.issue.number,
               title: contextResult.issue.title,
@@ -15176,6 +15704,21 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
   startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
   startReceipt.queueProcessedCount = processedResults.length;
   const prdBranch = startReceipt.prdBranch ?? prdRef;
+  const beadsDrainCurrent = readPrdRun(options.repoRoot, prdRef).record;
+  if (beadsDrainCurrent) {
+    const beadsIssueNumbers = processedResults.map((r) => r.issueNumber);
+    const beadsUpdatedProgress = updatePrdRunQueueProgress(
+      beadsDrainCurrent,
+      beadsIssueNumbers
+    );
+    writePrdRunRecord(options.repoRoot, {
+      ...beadsDrainCurrent,
+      prdRef,
+      status: beadsDrainCurrent.status,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      queueProgress: beadsUpdatedProgress
+    });
+  }
   writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
   const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
   if (drainRecord) {
@@ -15308,6 +15851,39 @@ function mapLaunchPrdRunOutcomeToCommandResult(outcome, options) {
       start: outcome.start ? mapStartPrdRunOutcomeToCommandResult(outcome.start) : void 0
     };
   }
+  if (outcome.kind === "active") {
+    const livenessDiagnostics = [
+      `Liveness: ${outcome.liveness.status}`
+    ];
+    if (outcome.liveness.lease) {
+      const lease = outcome.liveness.lease;
+      if (outcome.liveness.heartbeatAgeMs !== void 0) {
+        livenessDiagnostics.push(
+          `  Heartbeat age: ${outcome.liveness.heartbeatAgeMs}ms`
+        );
+      }
+      livenessDiagnostics.push(`  Host: ${lease.host}`);
+      livenessDiagnostics.push(`  PID: ${lease.pid}`);
+      livenessDiagnostics.push(`  Launch ID: ${lease.launchId}`);
+      livenessDiagnostics.push(`  Stage: ${lease.currentStage}`);
+      if (lease.currentIssue?.number) {
+        livenessDiagnostics.push(
+          `  Current issue: #${lease.currentIssue.number}`
+        );
+      }
+      if (lease.logPath) {
+        livenessDiagnostics.push(`  Log path: ${lease.logPath}`);
+      }
+    }
+    return {
+      prdRef,
+      status: outcome.status,
+      attempted: [...outcome.resume.attempted],
+      skipped: [...outcome.resume.skipped],
+      resumed: [...outcome.resume.resumed],
+      diagnostics: [...livenessDiagnostics, ...outcome.liveness.diagnostics]
+    };
+  }
   return {
     prdRef,
     status: outcome.status,
@@ -15361,6 +15937,44 @@ function runPrdRunStatusCommand(options) {
       ]
     };
   }
+  if (record?.status === "starting" || record?.status === "running") {
+    const liveness = classifyPrdRunLiveness({
+      record,
+      now: /* @__PURE__ */ new Date(),
+      currentHost: hostname2()
+    });
+    const livenessDiagnostics = [`Liveness: ${liveness.status}`];
+    if (liveness.lease) {
+      const lease = liveness.lease;
+      if (liveness.heartbeatAgeMs !== void 0) {
+        livenessDiagnostics.push(
+          `  Heartbeat age: ${liveness.heartbeatAgeMs}ms`
+        );
+      }
+      livenessDiagnostics.push(`  Host: ${lease.host}`);
+      livenessDiagnostics.push(`  PID: ${lease.pid}`);
+      livenessDiagnostics.push(`  Launch ID: ${lease.launchId}`);
+      livenessDiagnostics.push(`  Stage: ${lease.currentStage}`);
+      if (lease.currentIssue?.number) {
+        livenessDiagnostics.push(
+          `  Current issue: #${lease.currentIssue.number}`
+        );
+      }
+      if (lease.logPath) {
+        livenessDiagnostics.push(`  Log path: ${lease.logPath}`);
+      }
+    }
+    return {
+      prdRef,
+      record,
+      diagnostics: [
+        ...diagnostics,
+        ...livenessDiagnostics,
+        ...liveness.diagnostics
+      ],
+      liveness
+    };
+  }
   return { prdRef, record, diagnostics };
 }
 function runPrdRunListCommand(options) {
@@ -15834,7 +16448,7 @@ import {
   rename,
   writeFile as writeFile2
 } from "fs/promises";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 import path5 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -15933,6 +16547,7 @@ var BASELINE_MANAGED_SKILLS = [
   "grill-with-docs",
   "handoff",
   "improve-codebase-architecture",
+  "prd-run",
   "publish-prd",
   "secret-commit-guard",
   "security-review",
@@ -17890,7 +18505,7 @@ async function promptForInitChoices(plan, current) {
   };
 }
 async function writeFileAtomic(filePath, content) {
-  const tmpPath = `${filePath}.tmp.${randomUUID()}`;
+  const tmpPath = `${filePath}.tmp.${randomUUID2()}`;
   await writeFile2(tmpPath, content, "utf-8");
   await rename(tmpPath, filePath);
 }
@@ -18551,7 +19166,7 @@ import { existsSync as existsSync21, readFileSync as readFileSync20 } from "fs";
 import { writeFile as writeFile3, rename as rename2 } from "fs/promises";
 import { resolve as resolve5, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import Ajv2 from "ajv";
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname6(__filename3);
@@ -18828,7 +19443,7 @@ function checkPropertyExists(obj, instancePath, property) {
   return property in target;
 }
 async function writeFileAtomic2(filePath, content) {
-  const tmpPath = `${filePath}.tmp.${randomUUID2()}`;
+  const tmpPath = `${filePath}.tmp.${randomUUID3()}`;
   await writeFile3(tmpPath, content, "utf-8");
   await rename2(tmpPath, filePath);
 }
@@ -22136,7 +22751,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(
+  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").option("--quiet", "suppress detailed launch log output on stdout").action(
     async (prdRef, options) => {
       const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
       const normalizedPrdRef = normalizePrdRef2(prdRef);
@@ -22146,7 +22761,7 @@ function createCliProgram(version) {
         "logs",
         "prd-run-launch.log"
       );
-      const logger = createLogger("pourkit", logPath);
+      const logger = options.quiet ? createLogger("pourkit", logPath, { quiet: true }) : createLogger("pourkit", logPath);
       try {
         const config = await loadRepoConfig(targetRepoRoot);
         resolveTarget(config, options.target);
@@ -22158,6 +22773,29 @@ function createCliProgram(version) {
         });
         const prProvider = new GitHubPRProvider(client, logger);
         const executionProvider = new SandcastleExecutionProvider();
+        const launchArgv = [
+          "pourkit",
+          "prd-run",
+          "launch",
+          normalizedPrdRef,
+          "--target",
+          options.target
+        ];
+        if (options.base) {
+          launchArgv.push("--base", options.base);
+        }
+        if (options.quiet) {
+          launchArgv.push("--quiet");
+        }
+        if (options.autoMerge === false) {
+          launchArgv.push("--no-auto-merge");
+        }
+        if (options.adoptExistingBranch) {
+          launchArgv.push("--adopt-existing-branch");
+        }
+        if (options.cwd) {
+          launchArgv.push("--cwd", options.cwd);
+        }
         const result = await runPrdRunLaunchCommand({
           repoRoot: targetRepoRoot,
           prdRef: normalizedPrdRef,
@@ -22165,6 +22803,9 @@ function createCliProgram(version) {
           baseBranchOverride: options.base,
           autoMerge: options.autoMerge ?? true,
           adoptExistingBranch: options.adoptExistingBranch ?? false,
+          quiet: options.quiet ?? false,
+          cwd: options.cwd,
+          originalArgv: launchArgv,
           config,
           issueProvider,
           prProvider,
@@ -22437,11 +23078,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260724200221")) {
-    return "0.0.0-next-20260724200221";
+  if (isPackageVersion("0.0.0-next-20260727021939")) {
+    return "0.0.0-next-20260727021939";
   }
-  if (isReleaseVersion("0.0.0-next-20260724200221")) {
-    return "0.0.0-next-20260724200221";
+  if (isReleaseVersion("0.0.0-next-20260727021939")) {
+    return "0.0.0-next-20260727021939";
   }
   try {
     const root = repoRoot();