issue-flow 0.8.0 → 0.9.0

package/dist/run-BRBFHVUO.js

@@ -0,0 +1,1860 @@
+#!/usr/bin/env node
+import {
+  runPrd
+} from "./chunk-WHEU55ZP.js";
+import {
+  runReview
+} from "./chunk-X7XBF5TS.js";
+import {
+  ensureWebMonitor
+} from "./chunk-VNKSMWDN.js";
+import {
+  runInit
+} from "./chunk-M72ZEPWD.js";
+import {
+  printQueueSummary,
+  printRunSummary,
+  runExecute
+} from "./chunk-DP43WJY4.js";
+import {
+  runPlan
+} from "./chunk-TJMZWRS6.js";
+import {
+  runPr
+} from "./chunk-66ZGYXTH.js";
+import "./chunk-NB6WKTBL.js";
+import {
+  emptyRelations,
+  getProvider,
+  resolveCommandIssue,
+  uniqueIds
+} from "./chunk-KXAG24DD.js";
+import "./chunk-HDV3YDTG.js";
+import {
+  mostRecent,
+  prReviewDir,
+  readPrReviewIndex,
+  runPrReview
+} from "./chunk-TLSIK656.js";
+import {
+  listPullRequests,
+  publishGitState
+} from "./chunk-M37YZYDO.js";
+import "./chunk-JGKPSWOA.js";
+import {
+  beginUsageScope,
+  getRunUsageTotals
+} from "./chunk-DTNM3LTO.js";
+import "./chunk-SLHZPB3C.js";
+import {
+  executionPlanSchema,
+  loadIssuesConfig,
+  loadWebConfig,
+  resolveIssuePaths,
+  resolveProjectPaths,
+  resolveQueuePaths
+} from "./chunk-MTJQOOMG.js";
+import {
+  FilePublisher,
+  NullPublisher,
+  isVerbose,
+  isoNow,
+  loadTaskPlan,
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+  saveTaskPlan,
+  setOutputCallback,
+  setSessionPublisher,
+  setStoryStageCallback,
+  setStoryUpdateCallback,
+  writeFileAtomic
+} from "./chunk-57MH6RYJ.js";
+
+// src/commands/run.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2 } from "fs/promises";
+import { join } from "path";
+import { execa } from "execa";
+
+// src/core/pipeline.ts
+var PIPELINE_PHASES = ["init", "prd", "plan", "execute", "review", "pr"];
+var PIPELINE_PHASES_WITH_PR_REVIEW = [...PIPELINE_PHASES, "pr-review"];
+var PIPELINE_PHASES_NO_BRANCH = PIPELINE_PHASES.filter(
+  (p) => p !== "pr"
+);
+var PHASE_TO_FIELD = {
+  init: null,
+  prd: "prdCompleted",
+  plan: "jsonCompleted",
+  execute: "executionCompleted",
+  review: "reviewCompleted",
+  pr: "prCreated",
+  "pr-review": "prReviewCompleted"
+};
+var PipelineManager = class {
+  tasksJsonPath;
+  plan;
+  activePhases;
+  constructor(plan, tasksJsonPath, activePhases) {
+    this.plan = plan;
+    this.tasksJsonPath = tasksJsonPath;
+    this.activePhases = activePhases ?? PIPELINE_PHASES;
+  }
+  /**
+   * Reload state from disk.
+   */
+  async reload() {
+    this.plan = await loadTaskPlan(this.tasksJsonPath);
+  }
+  /**
+   * Check if a phase is complete.
+   */
+  isPhaseComplete(phase) {
+    const field = PHASE_TO_FIELD[phase];
+    if (field === null) return true;
+    return this.plan.pipeline?.[field] ?? false;
+  }
+  /**
+   * Get the first incomplete phase in the pipeline.
+   * Returns null if all phases are complete.
+   */
+  getNextPhase() {
+    for (const phase of this.activePhases) {
+      if (!this.isPhaseComplete(phase)) {
+        return phase;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the current phase (alias for getNextPhase).
+   */
+  getCurrentPhase() {
+    return this.getNextPhase();
+  }
+  /**
+   * Check whether we can resume from a specific phase.
+   * All prerequisite phases must be complete.
+   */
+  canResume(fromPhase) {
+    const idx = this.activePhases.indexOf(fromPhase);
+    if (idx < 0) return false;
+    for (let i = 0; i < idx; i++) {
+      if (!this.isPhaseComplete(this.activePhases[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Mark a phase as complete and persist to disk.
+   */
+  async markPhaseComplete(phase) {
+    const field = PHASE_TO_FIELD[phase];
+    if (field === null) return;
+    this.plan = {
+      ...this.plan,
+      pipeline: {
+        ...this.plan.pipeline ?? {
+          prdCompleted: false,
+          jsonCompleted: false,
+          executionCompleted: false,
+          reviewCompleted: false,
+          prCreated: false
+        },
+        [field]: true
+      }
+    };
+    await saveTaskPlan(this.tasksJsonPath, this.plan);
+  }
+};
+
+// src/execution/plan.ts
+import { mkdir, readFile } from "fs/promises";
+import { dirname } from "path";
+import { ZodError } from "zod";
+
+// src/issues/graph.ts
+var DEFAULT_MAX_NODES = 25;
+var DEFAULT_MAX_DEPTH = 3;
+function dependencyEdges(graph) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (from, to) => {
+    if (from === to || !graph.nodes.has(from) || !graph.nodes.has(to)) return;
+    const key = `${from}->${to}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push({ from, to });
+  };
+  for (const node of graph.nodes.values()) {
+    for (const blocker of node.relations.blockedBy) {
+      add(blocker, node.id);
+    }
+    for (const blocked of node.relations.blocking) {
+      add(node.id, blocked);
+    }
+  }
+  return edges;
+}
+function findCycles(graph) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const { from, to } of dependencyEdges(graph)) {
+    const list = adjacency.get(from);
+    if (list === void 0) {
+      adjacency.set(from, [to]);
+    } else {
+      list.push(to);
+    }
+  }
+  const cycles = [];
+  const reported = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const record = (cycle) => {
+    let pivot = 0;
+    for (let i = 1; i < cycle.length; i++) {
+      if (compareIds(cycle[i], cycle[pivot]) < 0) pivot = i;
+    }
+    const normalized = [...cycle.slice(pivot), ...cycle.slice(0, pivot)];
+    const key = normalized.join("->");
+    if (reported.has(key)) return;
+    reported.add(key);
+    cycles.push(normalized);
+  };
+  const visit = (id) => {
+    state.set(id, "visiting");
+    stack.push(id);
+    for (const next of adjacency.get(id) ?? []) {
+      const status = state.get(next);
+      if (status === "visiting") {
+        record(stack.slice(stack.indexOf(next)));
+        continue;
+      }
+      if (status === void 0) {
+        visit(next);
+      }
+    }
+    stack.pop();
+    state.set(id, "done");
+  };
+  for (const id of graph.nodes.keys()) {
+    if (!state.has(id)) visit(id);
+  }
+  return cycles;
+}
+function compareIds(a, b) {
+  const na = Number(a);
+  const nb = Number(b);
+  if (Number.isInteger(na) && Number.isInteger(nb)) {
+    return na - nb;
+  }
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function neighbours(relations) {
+  return uniqueIds(
+    [
+      ...relations.parent === null ? [] : [relations.parent],
+      ...relations.children,
+      ...relations.blockedBy,
+      ...relations.blocking
+    ],
+    relations.id
+  );
+}
+async function buildDependencyGraph(roots, fetchRelations, options = {}) {
+  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const warn = options.warn ?? (() => {
+  });
+  const known = /* @__PURE__ */ new Map();
+  for (const issue of options.known ?? []) {
+    known.set(issue.id, issue);
+  }
+  const rootIds = uniqueIds(roots);
+  const nodes = /* @__PURE__ */ new Map();
+  const queued = new Set(rootIds);
+  let truncated = false;
+  let frontier = rootIds.map((id) => ({ id, depth: 0 }));
+  while (frontier.length > 0) {
+    const next = [];
+    for (const { id, depth } of frontier) {
+      if (nodes.size >= maxNodes) {
+        truncated = true;
+        break;
+      }
+      let relations = null;
+      try {
+        relations = await fetchRelations(id);
+      } catch (err) {
+        warn(
+          `Could not read the relations of issue '${id}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      let issue = known.get(id) ?? null;
+      if (issue === null && options.fetchIssue !== void 0) {
+        try {
+          issue = await options.fetchIssue(id);
+        } catch (err) {
+          warn(`Could not read issue '${id}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      const resolved = relations ?? emptyRelations(id);
+      nodes.set(id, { id, relations: resolved, depth, issue, root: rootIds.includes(id) });
+      if (depth >= maxDepth) {
+        if (neighbours(resolved).some((neighbour) => !queued.has(neighbour))) {
+          truncated = true;
+        }
+        continue;
+      }
+      for (const neighbour of neighbours(resolved)) {
+        if (queued.has(neighbour)) continue;
+        queued.add(neighbour);
+        next.push({ id: neighbour, depth: depth + 1 });
+      }
+    }
+    if (nodes.size >= maxNodes && next.length > 0) {
+      truncated = true;
+      break;
+    }
+    frontier = next;
+  }
+  const graph = {
+    roots: rootIds,
+    nodes,
+    cycles: [],
+    truncated,
+    limits: { maxNodes, maxDepth }
+  };
+  linkReferencedBy(graph);
+  graph.cycles = findCycles(graph);
+  return graph;
+}
+function linkReferencedBy(graph) {
+  for (const node of graph.nodes.values()) {
+    for (const cited of node.relations.references) {
+      const target = graph.nodes.get(cited);
+      if (target === void 0 || target.id === node.id) continue;
+      target.relations.referencedBy = uniqueIds(
+        [...target.relations.referencedBy, node.id],
+        target.id
+      );
+    }
+  }
+}
+
+// src/execution/order.ts
+var PRIORITY_LABELS = {
+  high: "high",
+  medium: "medium",
+  low: "low"
+};
+var PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
+var NO_PRIORITY_RANK = 3;
+function priorityOf(labels) {
+  for (const label of labels) {
+    const normalized = label.trim().toLowerCase();
+    const direct = PRIORITY_LABELS[normalized];
+    if (direct !== void 0) return direct;
+    const qualified = /^(?:priority|prio|p)\s*[:/-]\s*(high|medium|low)$/.exec(normalized);
+    const matched = qualified?.[1];
+    if (matched !== void 0) return PRIORITY_LABELS[matched];
+  }
+  return null;
+}
+function hierarchyDepth(id, parentOf, selected) {
+  let depth = 0;
+  let current = parentOf.get(id) ?? null;
+  const seen = /* @__PURE__ */ new Set([id]);
+  while (current !== null && selected.has(current) && !seen.has(current)) {
+    depth++;
+    seen.add(current);
+    current = parentOf.get(current) ?? null;
+  }
+  return depth;
+}
+function computeExecutionOrder(graph, options = {}) {
+  const selected = new Set(
+    (options.include ?? [...graph.nodes.keys()]).filter((id) => graph.nodes.has(id))
+  );
+  const parentOf = /* @__PURE__ */ new Map();
+  const priority = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    const node = graph.nodes.get(id);
+    parentOf.set(id, node?.relations.parent ?? null);
+    priority.set(id, priorityOf(node?.issue?.labels ?? []));
+  }
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    incoming.set(id, /* @__PURE__ */ new Set());
+    outgoing.set(id, []);
+  }
+  for (const { from, to } of dependencyEdges(graph)) {
+    if (!selected.has(from) || !selected.has(to) || from === to) continue;
+    incoming.get(to)?.add(from);
+    outgoing.get(from)?.push(to);
+  }
+  const depth = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    depth.set(id, hierarchyDepth(id, parentOf, selected));
+  }
+  const rank = (id) => {
+    const value = priority.get(id) ?? null;
+    return value === null ? NO_PRIORITY_RANK : PRIORITY_RANK[value];
+  };
+  const better = (a, b) => {
+    const byHierarchy = (depth.get(a) ?? 0) - (depth.get(b) ?? 0);
+    if (byHierarchy !== 0) return byHierarchy;
+    const byPriority = rank(a) - rank(b);
+    if (byPriority !== 0) return byPriority;
+    return compareIds(a, b);
+  };
+  const ready = [...selected].filter((id) => (incoming.get(id)?.size ?? 0) === 0);
+  const order = [];
+  while (ready.length > 0) {
+    ready.sort(better);
+    const next = ready.shift();
+    order.push(next);
+    for (const dependent of outgoing.get(next) ?? []) {
+      const pending = incoming.get(dependent);
+      if (pending === void 0) continue;
+      pending.delete(next);
+      if (pending.size === 0) {
+        ready.push(dependent);
+      }
+    }
+  }
+  if (order.length !== selected.size) {
+    const cycles = graph.cycles.length > 0 ? graph.cycles : findCycles(graph);
+    const relevant = cycles.filter((cycle) => cycle.every((id) => selected.has(id)));
+    return { ok: false, cycles: relevant.length > 0 ? relevant : cycles };
+  }
+  return { ok: true, order };
+}
+function describeCycles(cycles) {
+  return cycles.map((cycle) => [...cycle, cycle[0]].map((id) => `#${id}`).join(" \u2192 ")).join("; ");
+}
+
+// src/execution/plan.ts
+function describeIssue(issue, id) {
+  const parsed = Number.parseInt(id, 10);
+  return {
+    number: issue?.number ?? (Number.isNaN(parsed) ? null : parsed),
+    title: issue?.title ?? "",
+    url: issue?.remoteRef ?? null,
+    source: issue?.source ?? "github"
+  };
+}
+function buildExecutionPlan(input) {
+  const now = input.now ?? isoNow;
+  const at = now();
+  const scheduled = new Set(input.order);
+  const requested = new Set(input.requested);
+  const issues = input.order.map((id, index) => {
+    const node = input.graph.nodes.get(id);
+    const relations = node?.relations;
+    const described = describeIssue(node?.issue ?? null, id);
+    return {
+      id,
+      number: described.number,
+      title: described.title,
+      url: described.url,
+      source: described.source,
+      position: index + 1,
+      status: "pending",
+      origin: requested.has(id) ? "requested" : "discovered",
+      // Only the constraints that survive inside the queue: a blocker left out
+      // of it is reported in `excluded`, not enforced as a dependency.
+      dependsOn: (relations?.blockedBy ?? []).filter((blocker) => scheduled.has(blocker)),
+      parent: relations?.parent ?? null,
+      priority: priorityOf(node?.issue?.labels ?? []),
+      heuristic: (relations?.heuristic.length ?? 0) > 0,
+      failedPhase: null,
+      lastError: null,
+      startedAt: null,
+      completedAt: null
+    };
+  });
+  const excluded = [];
+  for (const node of input.graph.nodes.values()) {
+    if (scheduled.has(node.id)) continue;
+    const described = describeIssue(node.issue, node.id);
+    excluded.push({
+      id: node.id,
+      number: described.number,
+      title: described.title,
+      url: described.url,
+      reason: "Discovered in the hierarchy but not selected for this run"
+    });
+  }
+  return {
+    schemaVersion: 1,
+    id: input.requested[0] ?? input.order[0],
+    project: input.projectId,
+    requested: [...input.requested],
+    branchName: null,
+    noBranch: input.noBranch ?? false,
+    prReview: input.prReview ?? false,
+    status: "pending",
+    createdAt: at,
+    updatedAt: at,
+    truncated: input.graph.truncated,
+    issues,
+    excluded
+  };
+}
+async function loadExecutionPlan(path) {
+  const raw = JSON.parse(await readFile(path, "utf-8"));
+  try {
+    return executionPlanSchema.parse(raw);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new Error(`Invalid execution-plan.json at ${path}:
+${issues}`);
+    }
+    throw err;
+  }
+}
+async function saveExecutionPlan(path, plan, now = isoNow) {
+  await mkdir(dirname(path), { recursive: true });
+  const stamped = { ...plan, updatedAt: now() };
+  await writeFileAtomic(path, `${JSON.stringify(stamped, null, 2)}
+`);
+}
+function nextQueueIssue(plan) {
+  return plan.issues.find((entry) => entry.status === "in_progress") ?? plan.issues.find((entry) => entry.status === "failed") ?? plan.issues.find((entry) => entry.status === "pending") ?? null;
+}
+function queueStatus(plan) {
+  if (plan.issues.some((entry) => entry.status === "failed")) return "failed";
+  if (plan.issues.every((entry) => entry.status === "completed")) return "completed";
+  if (plan.issues.some((entry) => entry.status !== "pending")) return "in_progress";
+  return "pending";
+}
+function isQueueComplete(plan) {
+  return plan.issues.every((entry) => entry.status === "completed");
+}
+function updateIssue(plan, id, patch) {
+  const issues = plan.issues.map((entry) => entry.id === id ? { ...entry, ...patch } : entry);
+  const next = { ...plan, issues };
+  return { ...next, status: queueStatus(next) };
+}
+function markQueueIssueInProgress(plan, id, now = isoNow) {
+  const current = plan.issues.find((entry) => entry.id === id);
+  return updateIssue(plan, id, {
+    status: "in_progress",
+    // Preserved across a resume: the queue reports when the work on this Issue
+    // really began, not when it was last picked up.
+    startedAt: current?.startedAt ?? now(),
+    failedPhase: null,
+    lastError: null
+  });
+}
+function markQueueIssueCompleted(plan, id, now = isoNow) {
+  return updateIssue(plan, id, {
+    status: "completed",
+    completedAt: now(),
+    failedPhase: null,
+    lastError: null
+  });
+}
+function markQueueIssueFailed(plan, id, failure2) {
+  return updateIssue(plan, id, {
+    status: "failed",
+    failedPhase: failure2.phase,
+    lastError: failure2.error
+  });
+}
+function setQueueBranch(plan, branchName) {
+  return { ...plan, branchName };
+}
+function setQueuePullRequest(plan, pullRequest) {
+  return { ...plan, pullRequest };
+}
+
+// src/execution/confirm.ts
+import { createInterface } from "readline";
+var MAX_PROMPT_ATTEMPTS = 3;
+var QueueConfirmationError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "QueueConfirmationError";
+    this.exitCode = exitCode;
+  }
+};
+function isInteractiveByDefault() {
+  const ci = process.env.CI;
+  const inCi = ci !== void 0 && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !inCi;
+}
+function issueLabel(entry) {
+  return entry.number === null ? entry.id : `#${entry.number}`;
+}
+function reasonFor(entry) {
+  const parts = [];
+  if (entry.origin === "requested") {
+    parts.push("requested");
+  }
+  if (entry.dependsOn.length > 0) {
+    parts.push(`after ${entry.dependsOn.map((id) => `#${id}`).join(", ")}`);
+  }
+  if (entry.parent !== null) {
+    parts.push(`sub-issue of #${entry.parent}`);
+  }
+  if (entry.priority !== null) {
+    parts.push(entry.priority);
+  }
+  return parts.join(", ");
+}
+function buildQueueSummaryLines(plan) {
+  const primary = plan.issues.find((entry) => entry.id === plan.id) ?? plan.issues[0];
+  const lines = [];
+  if (primary !== void 0) {
+    lines.push(`  Main issue:   ${issueLabel(primary)}${primary.title ? ` ${primary.title}` : ""}`);
+  }
+  lines.push(`  Total issues: ${plan.issues.length}`);
+  lines.push("  Suggested order:");
+  for (const entry of plan.issues) {
+    const reason = reasonFor(entry);
+    const flag = entry.heuristic ? " ~" : "";
+    const title = entry.title === "" ? "" : ` ${entry.title}`;
+    lines.push(
+      `    ${entry.position}. ${issueLabel(entry)}${title}${reason === "" ? "" : ` (${reason})`}${flag}`
+    );
+  }
+  if (plan.issues.some((entry) => entry.heuristic)) {
+    lines.push("  ~ relation found only in the issue text, which may be a false positive");
+  }
+  if (plan.truncated) {
+    lines.push("  Note: discovery hit its limit \u2014 the hierarchy may be larger than shown");
+  }
+  return lines;
+}
+async function confirmQueue(plan, requestedOnlyCount, options = {}) {
+  const info = options.info ?? printInfo;
+  const warn = options.warn ?? printWarning;
+  info(`Issue ${plan.requested.map((id) => `#${id}`).join(", ")} is part of a larger structure:`);
+  for (const line of buildQueueSummaryLines(plan)) {
+    (options.stdout ?? process.stdout).write(`${line}
+`);
+  }
+  if (options.only === true) {
+    info(`--only: running just the ${requestedOnlyCount} issue(s) you asked for.`);
+    return "requested";
+  }
+  if (options.yes === true) {
+    info(`--yes: running the whole hierarchy (${plan.issues.length} issues).`);
+    return "all";
+  }
+  const interactive = options.interactive ?? isInteractiveByDefault();
+  if (!interactive && options.singleRequest === true) {
+    warn(
+      `A larger structure was found, but the terminal is not interactive: running just issue ${plan.requested.map((id) => `#${id}`).join(", ")}. Re-run with --yes to execute the whole hierarchy.`
+    );
+    return "requested";
+  }
+  if (!interactive) {
+    throw new QueueConfirmationError(
+      "This run involves more than one issue and the terminal is not interactive. Re-run with --yes to execute the whole hierarchy, or --only to execute just the issues you informed."
+    );
+  }
+  const query = `Which scope should run? [1] Only the issues informed (${requestedOnlyCount})  [2] The whole hierarchy (${plan.issues.length})  [3] Cancel: `;
+  return await ask(query, options.stdin ?? process.stdin, options.stdout ?? process.stdout, warn);
+}
+async function ask(query, stdin, stdout, warn) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const queued = [];
+  let pending = null;
+  let closed = false;
+  rl.on("line", (line) => {
+    if (pending !== null) {
+      const resolve = pending;
+      pending = null;
+      resolve(line);
+      return;
+    }
+    queued.push(line);
+  });
+  rl.on("close", () => {
+    closed = true;
+    if (pending !== null) {
+      const resolve = pending;
+      pending = null;
+      resolve(null);
+    }
+  });
+  const read = () => new Promise((resolve) => {
+    const buffered = queued.shift();
+    if (buffered !== void 0) {
+      resolve(buffered);
+      return;
+    }
+    if (closed) {
+      resolve(null);
+      return;
+    }
+    stdout.write(query);
+    pending = resolve;
+  });
+  try {
+    for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt++) {
+      const answer = await read();
+      if (answer === null) {
+        return "cancel";
+      }
+      const choice = answer.trim();
+      if (choice === "1") return "requested";
+      if (choice === "" || choice === "2") return "all";
+      if (choice === "3") return "cancel";
+      warn(`Invalid choice: '${choice}'. Enter 1, 2 or 3.`);
+    }
+    return "cancel";
+  } finally {
+    rl.close();
+  }
+}
+
+// src/execution/discovery.ts
+function supportsRelations(source) {
+  try {
+    return typeof getProvider(source).fetchRelations === "function";
+  } catch {
+    return false;
+  }
+}
+async function discoverIssueGraph(roots, options = {}) {
+  const source = options.source ?? [...options.known ?? []][0]?.source ?? "github";
+  let fetchRelations = null;
+  let fetchIssue = null;
+  try {
+    const provider = getProvider(source);
+    const relations = provider.fetchRelations?.bind(provider);
+    if (relations !== void 0) {
+      fetchRelations = (id) => relations(id);
+      fetchIssue = (id) => provider.get(id);
+    }
+  } catch {
+  }
+  if (fetchRelations === null) {
+    return buildDependencyGraph(roots, async () => null, { ...options, fetchIssue: void 0 });
+  }
+  return buildDependencyGraph(roots, fetchRelations, {
+    ...options,
+    fetchIssue: options.fetchIssue ?? fetchIssue ?? void 0
+  });
+}
+
+// src/execution/queue.ts
+async function loadResumableQueue(planFile, requested) {
+  let plan;
+  try {
+    plan = await loadExecutionPlan(planFile);
+  } catch {
+    return null;
+  }
+  const sameRequest = plan.requested.length === requested.length && plan.requested.every((id, index) => id === requested[index]);
+  return sameRequest ? plan : null;
+}
+async function planQueue(input) {
+  const info = input.info ?? printInfo;
+  const warn = input.warn ?? printWarning;
+  const single = input.requested.length === 1;
+  const resumable = await loadResumableQueue(input.planFile, input.requested);
+  if (resumable !== null && isQueueComplete(resumable)) {
+    const pr = resumable.pullRequest?.url;
+    info(
+      `The execution queue of issue #${resumable.id} is already complete (${resumable.issues.length} issues)${pr === void 0 ? "" : ` \u2014 ${pr}`}. Nothing to run.`
+    );
+    return { kind: "stop", code: 0 };
+  }
+  if (resumable !== null) {
+    const done = resumable.issues.filter((entry) => entry.status === "completed").length;
+    info(
+      `Resuming the execution queue of issue #${resumable.id}: ${done}/${resumable.issues.length} issues already completed.`
+    );
+    return { kind: "queue", plan: resumable, resumed: true };
+  }
+  if (single && input.confirm?.only === true) {
+    return { kind: "single" };
+  }
+  if (single && !supportsRelations(input.source)) {
+    return { kind: "single" };
+  }
+  const graph = await discoverIssueGraph(input.requested, {
+    source: input.source,
+    known: input.known,
+    warn
+  });
+  if (single && graph.nodes.size <= 1) {
+    return { kind: "single" };
+  }
+  const suggested = computeExecutionOrder(graph);
+  if (!suggested.ok) {
+    if (single) {
+      warn(
+        `Dependency cycle between issues: ${describeCycles(suggested.cycles)}. Running just the issue you informed; fix the dependencies on GitHub to run the hierarchy.`
+      );
+      return { kind: "single" };
+    }
+    warn(
+      `Dependency cycle between issues: ${describeCycles(suggested.cycles)}. Fix the dependencies on GitHub, or re-run with --only to execute just the issues you informed.`
+    );
+    return { kind: "stop", code: 1 };
+  }
+  const requestedOrder = computeExecutionOrder(graph, { include: input.requested });
+  const requestedCount = requestedOrder.ok ? requestedOrder.order.length : input.requested.length;
+  const suggestedPlan = buildExecutionPlan({
+    projectId: input.projectId,
+    requested: input.requested,
+    graph,
+    order: suggested.order,
+    noBranch: input.noBranch,
+    prReview: input.prReview
+  });
+  let choice;
+  try {
+    choice = await confirmQueue(suggestedPlan, requestedCount, {
+      ...input.confirm ?? {},
+      singleRequest: single
+    });
+  } catch (err) {
+    if (err instanceof QueueConfirmationError) {
+      warn(err.message);
+      return { kind: "stop", code: err.exitCode };
+    }
+    throw err;
+  }
+  if (choice === "cancel") {
+    info("Cancelled: nothing was executed.");
+    return { kind: "stop", code: 1 };
+  }
+  let plan = suggestedPlan;
+  if (choice === "requested") {
+    if (!requestedOrder.ok) {
+      warn(
+        `Dependency cycle between the issues you informed: ${describeCycles(requestedOrder.cycles)}.`
+      );
+      return { kind: "stop", code: 1 };
+    }
+    if (requestedOrder.order.length <= 1) {
+      if (input.requested.length > 1) {
+        const missing = input.requested.filter((id) => !requestedOrder.order.includes(id));
+        warn(
+          `Only issue #${requestedOrder.order[0] ?? "\u2014"} of the ones you informed could be read; ${missing.map((id) => `#${id}`).join(", ")} did not make it into the dependency graph. Nothing was executed \u2014 check the identifiers and try again.`
+        );
+        return { kind: "stop", code: 1 };
+      }
+      return { kind: "single" };
+    }
+    plan = buildExecutionPlan({
+      projectId: input.projectId,
+      requested: input.requested,
+      graph,
+      order: requestedOrder.order,
+      noBranch: input.noBranch,
+      prReview: input.prReview
+    });
+  }
+  await saveExecutionPlan(input.planFile, plan);
+  return { kind: "queue", plan, resumed: false };
+}
+
+// src/issues/args.ts
+var IssueArgumentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IssueArgumentError";
+  }
+};
+var INVALID_ID = /[/\\\s]/;
+function parseIssueArguments(values) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    for (const raw of value.split(",")) {
+      const id = raw.trim().replace(/^#/, "").trim();
+      if (id === "") {
+        if (raw.trim() !== "" || value.includes(",")) {
+          throw new IssueArgumentError(
+            `Invalid issue list '${value}': it has an empty entry. Use '42,43' or '42 43'.`
+          );
+        }
+        continue;
+      }
+      if (INVALID_ID.test(id) || id === "." || id === "..") {
+        throw new IssueArgumentError(`Invalid issue identifier '${raw.trim()}'.`);
+      }
+      if (seen.has(id)) continue;
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+  if (ids.length === 0) {
+    throw new IssueArgumentError("No issue was informed. Pass at least one issue number.");
+  }
+  return ids;
+}
+
+// src/ui/pipeline-renderer.ts
+import { Listr, PRESET_TIMER, PRESET_TIMESTAMP } from "listr2";
+var PHASE_LABELS = {
+  prd: "PRD",
+  plan: "Plan",
+  execute: "Execute",
+  review: "Review",
+  pr: "PR",
+  "pr-review": "PR Review"
+};
+function phaseLabel(phase) {
+  return PHASE_LABELS[phase] ?? phase.charAt(0).toUpperCase() + phase.slice(1);
+}
+function selectRenderer(verbose) {
+  const isTTY = !!process.stdout.isTTY;
+  const isCI = !!process.env.CI;
+  if (!isTTY || isCI) {
+    return "simple";
+  }
+  return verbose ? "verbose" : "default";
+}
+function storySubtaskTitle(story, executing) {
+  const base = `${story.id}: ${story.title}`;
+  return executing ? `${base} \u2192 Executando...` : base;
+}
+function createActiveStoryTracker(stories, storyTasks) {
+  let activeStoryId;
+  const retitle = (storyId, executing) => {
+    const task = storyTasks.get(storyId);
+    if (!task) return;
+    task.title = storySubtaskTitle(
+      stories.find((s) => s.id === storyId) ?? { id: storyId, title: "" },
+      executing
+    );
+  };
+  return {
+    setActive(storyId) {
+      if (activeStoryId !== void 0 && activeStoryId !== storyId) {
+        retitle(activeStoryId, false);
+      }
+      activeStoryId = storyId;
+      if (storyId !== void 0) retitle(storyId, true);
+    },
+    clear() {
+      if (activeStoryId === void 0) return;
+      retitle(activeStoryId, false);
+      activeStoryId = void 0;
+    }
+  };
+}
+function buildExecutePhaseTask(runner, tasksPath, verbose) {
+  return async (_ctx, task) => {
+    let stories;
+    try {
+      const plan = await loadTaskPlan(tasksPath);
+      stories = [...plan.userStories].sort((a, b) => a.priority - b.priority);
+    } catch {
+      setOutputCallback((line) => {
+        task.output = line;
+      });
+      try {
+        await runner();
+      } finally {
+        setOutputCallback(void 0);
+      }
+      return;
+    }
+    const totalStories = stories.length;
+    const initialPassed = stories.filter((s) => s.passes).length;
+    task.title = `Execute (${initialPassed}/${totalStories} stories passing)`;
+    const resolvers = /* @__PURE__ */ new Map();
+    setStoryUpdateCallback((updatedStories) => {
+      const passed = updatedStories.filter((s) => s.passes).length;
+      task.title = `Execute (${passed}/${totalStories} stories passing)`;
+      for (const s of updatedStories) {
+        if (s.passes && resolvers.has(s.id)) {
+          resolvers.get(s.id).resolve();
+          resolvers.delete(s.id);
+        }
+      }
+    });
+    const storyTasks = /* @__PURE__ */ new Map();
+    const tracker = createActiveStoryTracker(stories, storyTasks);
+    setStoryStageCallback((storyId) => {
+      tracker.setActive(storyId);
+    });
+    const subtaskDefs = stories.map((story) => ({
+      title: storySubtaskTitle(story, false),
+      skip: story.passes ? "already passing" : false,
+      task: async (_c, subTask) => {
+        storyTasks.set(story.id, subTask);
+        await new Promise((resolve, reject) => {
+          resolvers.set(story.id, { resolve, reject });
+        });
+      },
+      rendererOptions: {
+        timer: PRESET_TIMER
+      }
+    }));
+    const engineSubtask = {
+      title: "Running engine",
+      task: async (_c, engineTask) => {
+        setOutputCallback((line) => {
+          engineTask.output = line;
+        });
+        try {
+          await runner();
+        } finally {
+          setOutputCallback(void 0);
+          setStoryUpdateCallback(void 0);
+          setStoryStageCallback(void 0);
+          tracker.clear();
+          for (const [, { resolve }] of resolvers) {
+            resolve();
+          }
+          resolvers.clear();
+        }
+      },
+      rendererOptions: {
+        timer: PRESET_TIMER,
+        outputBar: verbose ? Infinity : false,
+        persistentOutput: false,
+        bottomBar: verbose ? Infinity : 3
+      }
+    };
+    return task.newListr([engineSubtask, ...subtaskDefs], {
+      concurrent: true,
+      exitOnError: true,
+      rendererOptions: {
+        timer: PRESET_TIMER,
+        collapseSkips: false
+      }
+    });
+  };
+}
+async function runPipelineWithRenderer(options) {
+  const { phases, startIndex, verbose, runners, tasksPath } = options;
+  const overallStart = Date.now();
+  let currentPhase;
+  const renderer = selectRenderer(verbose);
+  const isSimple = renderer === "simple";
+  const tasks = new Listr(
+    phases.map((phase, index) => {
+      const label = phaseLabel(phase);
+      const isExecutePhase = phase === "execute" && tasksPath;
+      return {
+        title: label,
+        skip: index < startIndex ? "skipped" : false,
+        task: isExecutePhase ? async (_ctx, task) => {
+          currentPhase = phase;
+          const runner = runners[phase];
+          if (!runner) {
+            throw new Error(`No runner defined for phase: ${phase}`);
+          }
+          return buildExecutePhaseTask(runner, tasksPath, verbose)(_ctx, task);
+        } : async (_ctx, task) => {
+          currentPhase = phase;
+          const runner = runners[phase];
+          if (!runner) {
+            throw new Error(`No runner defined for phase: ${phase}`);
+          }
+          setOutputCallback((line) => {
+            task.output = line;
+          });
+          try {
+            await runner();
+          } finally {
+            setOutputCallback(void 0);
+          }
+        },
+        rendererOptions: {
+          timer: PRESET_TIMER,
+          outputBar: verbose ? Infinity : false,
+          persistentOutput: false
+        }
+      };
+    }),
+    {
+      renderer,
+      rendererOptions: {
+        timer: PRESET_TIMER,
+        collapseSkips: false,
+        ...isSimple ? { timestamp: PRESET_TIMESTAMP } : {}
+      },
+      exitOnError: true
+    }
+  );
+  let failedPhase;
+  try {
+    await tasks.run();
+  } catch {
+    failedPhase = currentPhase ?? phases[startIndex];
+  } finally {
+    setOutputCallback(void 0);
+    setStoryUpdateCallback(void 0);
+    setStoryStageCallback(void 0);
+  }
+  const overallElapsedSeconds = Math.floor((Date.now() - overallStart) / 1e3);
+  return {
+    success: !failedPhase,
+    failedPhase,
+    overallElapsedSeconds
+  };
+}
+
+// src/commands/run.ts
+function toIssueNumber(id) {
+  const parsed = Number.parseInt(id, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function publishStorySeed(publisher, stories, at) {
+  if (stories.length === 0) return false;
+  publisher.publish({ type: "stories:update", at, stories: [...stories] });
+  return true;
+}
+function publishIssueDetails(publisher, issue, at) {
+  publisher.publish({
+    type: "issue:update",
+    at,
+    number: issue.number,
+    // Left undefined (rather than null) when the origin has no remote, so the
+    // reducer keeps whatever URL session:start already published.
+    url: issue.remoteRef ?? void 0,
+    title: issue.title,
+    description: issue.body,
+    labels: issue.labels,
+    state: issue.state
+  });
+}
+var RUNNABLE_PHASES = ["prd", "plan", "execute", "review", "pr"];
+var RUNNABLE_PHASES_NO_BRANCH = ["prd", "plan", "execute", "review"];
+var RUNNABLE_PHASES_WITH_PR_REVIEW = [...RUNNABLE_PHASES, "pr-review"];
+var QUEUE_PR_PHASES = ["init", "pr"];
+var QUEUE_PR_PHASES_WITH_REVIEW = [
+  "init",
+  "pr",
+  "pr-review"
+];
+var RUNNABLE_QUEUE_PR_PHASES = ["pr"];
+var RUNNABLE_QUEUE_PR_PHASES_WITH_REVIEW = ["pr", "pr-review"];
+async function readPrReviewOutcome(issue, tasksPath, requestedChanges) {
+  const outcome = { requestedChanges, recommendation: null, reportPath: null };
+  try {
+    const plan = await loadTaskPlan(tasksPath);
+    outcome.recommendation = plan.prReview?.lastRecommendation ?? null;
+    const pullRequest = plan.prReview?.pullRequestNumber;
+    if (pullRequest !== void 0) {
+      const dir = await prReviewDir({ issue, pullRequest });
+      const index = await readPrReviewIndex(dir);
+      const last = index?.rounds.reduce(
+        (latest, entry) => latest === null || entry.round > latest.round ? entry : latest,
+        null
+      );
+      if (last) {
+        outcome.reportPath = join(dir, last.reportPath);
+        outcome.recommendation ??= last.recommendation;
+      }
+    }
+  } catch {
+  }
+  return outcome;
+}
+async function runPipeline(issue, mode, from, noBranch, prReview, options = {}) {
+  let requested;
+  try {
+    requested = parseIssueArguments(typeof issue === "string" ? [issue] : issue);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  const first = await runIssueSession(requested[0], mode, {
+    from,
+    noBranch,
+    prReview,
+    requested,
+    runOptions: options
+  });
+  if (first.queue === void 0) {
+    return first.code;
+  }
+  return runQueue(
+    first.queue.plan,
+    { mode, from, noBranch, prReview, runOptions: options },
+    first.queue.resolved
+  );
+}
+async function runIssueSession(issueNumber, mode, input) {
+  const paths = await resolveIssuePaths(issueNumber);
+  const webConfig = await loadWebConfig();
+  let publisher = new NullPublisher();
+  if (webConfig.enabled) {
+    await mkdir2(paths.issueDir, { recursive: true });
+    publisher = new FilePublisher(paths.sessionFile, {
+      logLimit: webConfig.logLimit,
+      includeLogs: webConfig.includeLogs
+    });
+  }
+  setSessionPublisher(publisher);
+  if (webConfig.enabled) {
+    await ensureWebMonitor({
+      publisher,
+      port: webConfig.port,
+      host: webConfig.host,
+      refreshSeconds: webConfig.refreshSeconds
+    });
+  }
+  let result = {
+    code: 1,
+    failedPhase: null,
+    branchName: null,
+    storyCount: 0,
+    elapsedSeconds: 0
+  };
+  try {
+    result = await runPipelinePhases(issueNumber, paths, mode, publisher, input);
+    return result;
+  } finally {
+    if (result.queue === void 0) {
+      publisher.publish({
+        type: "session:end",
+        at: isoNow(),
+        status: result.code === 0 ? "completed" : "failed"
+      });
+    }
+    await publisher.close();
+    setSessionPublisher(void 0);
+  }
+}
+async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
+  const { from, noBranch, prReview, queue } = input;
+  const continueNumbering = input.runOptions?.continueNumbering;
+  const startUs = input.runOptions?.startUs;
+  const tasksPath = paths.tasksFile;
+  const sessionId = randomUUID();
+  let publishedIssueNumber = toIssueNumber(issueNumber);
+  const publishSessionStart = (phases, at, info) => {
+    publisher.publish({
+      type: "session:start",
+      at,
+      sessionId,
+      issueNumber: publishedIssueNumber,
+      issueUrl: info?.issueUrl,
+      branch: info?.branch,
+      phases: [...phases],
+      environment: { node: process.version, platform: process.platform }
+    });
+  };
+  printInfo(`Starting pipeline for issue #${issueNumber} (mode: ${mode})`);
+  const issuesConfig = await loadIssuesConfig();
+  const sessionStartedAt = isoNow();
+  if (queue?.preChecked !== true) {
+    printInfo("Running prerequisite checks...");
+    const initCode = await runInit(issuesConfig.preferredProvider);
+    if (initCode !== 0) {
+      publishSessionStart(PIPELINE_PHASES, sessionStartedAt);
+      publisher.publish({ type: "phase:start", at: sessionStartedAt, phase: "init" });
+      publisher.publish({
+        type: "phase:end",
+        at: isoNow(),
+        phase: "init",
+        success: false,
+        error: "Prerequisites not met"
+      });
+      printError("Prerequisites not met. Fix the issues above and try again.");
+      return failure(1);
+    }
+  }
+  const resolution = await resolveCommandIssue(issueNumber, queue?.resolved, {
+    config: issuesConfig
+  });
+  if (!resolution.ok) {
+    return failure(resolution.code);
+  }
+  const resolvedIssue = resolution.resolved;
+  publishedIssueNumber = resolvedIssue.issue.number;
+  if (queue === void 0) {
+    const decision = await decideQueue({
+      requested: input.requested ?? [issueNumber],
+      resolved: resolvedIssue,
+      noBranch: noBranch ?? false,
+      prReview: prReview ?? false,
+      runOptions: input.runOptions ?? {}
+    });
+    if (decision.kind === "stop") {
+      return failure(decision.code);
+    }
+    if (decision.kind === "queue") {
+      return {
+        ...failure(0),
+        queue: { plan: decision.plan, resumed: decision.resumed, resolved: resolvedIssue }
+      };
+    }
+  }
+  let effectiveNoBranch = noBranch ?? false;
+  let effectivePrReview = prReview ?? false;
+  let planIssueUrl;
+  let planBranch;
+  let planStories = [];
+  try {
+    const existingPlan = await loadTaskPlan(tasksPath);
+    const persistedNoBranch = existingPlan.noBranch ?? false;
+    planIssueUrl = existingPlan.issueUrl || void 0;
+    planBranch = existingPlan.branchName || void 0;
+    planStories = existingPlan.userStories;
+    effectivePrReview = prReview ?? existingPlan.prReview?.enabled ?? false;
+    if (noBranch !== void 0 && noBranch !== persistedNoBranch) {
+      if (persistedNoBranch) {
+        printWarning(
+          "This pipeline was started with --no-branch. Ignoring current flag; using persisted mode."
+        );
+      } else {
+        printWarning(
+          "This pipeline was started without --no-branch. Ignoring current flag; using persisted mode."
+        );
+      }
+    }
+    effectiveNoBranch = persistedNoBranch;
+  } catch {
+  }
+  if (effectiveNoBranch && effectivePrReview) {
+    printWarning(
+      "This pipeline runs with --no-branch and opens no PR. Skipping the pr-review phase."
+    );
+    effectivePrReview = false;
+  }
+  if (effectivePrReview) {
+    try {
+      const plan = await loadTaskPlan(tasksPath);
+      if (plan.prReview?.enabled !== true) {
+        plan.prReview = { ...plan.prReview, enabled: true, rounds: plan.prReview?.rounds ?? 0 };
+        await saveTaskPlan(tasksPath, plan);
+      }
+    } catch {
+    }
+  }
+  const inQueue = queue !== void 0;
+  const finalPr = queue?.finalPr;
+  const activePhases = finalPr ? effectivePrReview ? QUEUE_PR_PHASES_WITH_REVIEW : QUEUE_PR_PHASES : inQueue ? PIPELINE_PHASES_NO_BRANCH : effectiveNoBranch ? PIPELINE_PHASES_NO_BRANCH : effectivePrReview ? PIPELINE_PHASES_WITH_PR_REVIEW : PIPELINE_PHASES;
+  const phaseOrder = finalPr ? effectivePrReview ? RUNNABLE_QUEUE_PR_PHASES_WITH_REVIEW : RUNNABLE_QUEUE_PR_PHASES : inQueue ? RUNNABLE_PHASES_NO_BRANCH : effectiveNoBranch ? RUNNABLE_PHASES_NO_BRANCH : effectivePrReview ? RUNNABLE_PHASES_WITH_PR_REVIEW : RUNNABLE_PHASES;
+  const queueCommitScope = queue === void 0 ? void 0 : `issue-${issueNumber}`;
+  let producedBranch = null;
+  if (queue !== void 0 && finalPr === void 0 && !effectiveNoBranch) {
+    producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
+    if (producedBranch !== null) {
+      planBranch = producedBranch;
+    }
+  }
+  publishSessionStart(activePhases, sessionStartedAt, {
+    issueUrl: planIssueUrl ?? resolvedIssue.issue.remoteRef ?? void 0,
+    branch: planBranch
+  });
+  publishIssueDetails(publisher, resolvedIssue.issue, sessionStartedAt);
+  publishStorySeed(publisher, planStories, sessionStartedAt);
+  publisher.publish({ type: "phase:start", at: sessionStartedAt, phase: "init" });
+  publisher.publish({ type: "phase:end", at: isoNow(), phase: "init", success: true });
+  await publishGitState(publisher);
+  let startPhase = "prd";
+  if (from) {
+    if (!activePhases.includes(from)) {
+      const validPhases = activePhases.filter((p) => p !== "init").join(", ");
+      if (effectiveNoBranch && PIPELINE_PHASES.includes(from)) {
+        printError(
+          `The '${from}' phase is not available in --no-branch mode. Valid phases: ${validPhases}`
+        );
+      } else {
+        printError(`Invalid phase: ${from}. Valid phases: ${validPhases}`);
+      }
+      return failure(1);
+    }
+    startPhase = from;
+  } else {
+    try {
+      const plan = await loadTaskPlan(tasksPath);
+      const mgr = new PipelineManager(plan, tasksPath, activePhases);
+      const nextPhase = mgr.getNextPhase();
+      if (nextPhase && nextPhase !== "init") {
+        startPhase = nextPhase;
+        printInfo(`Resuming from phase: ${startPhase}`);
+      }
+    } catch {
+    }
+  }
+  if (from) {
+    try {
+      const plan = await loadTaskPlan(tasksPath);
+      const mgr = new PipelineManager(plan, tasksPath, activePhases);
+      if (!mgr.canResume(startPhase)) {
+        printError(`Cannot resume from ${startPhase}: prerequisite phases not complete`);
+        return failure(1);
+      }
+    } catch {
+      if (startPhase !== "prd") {
+        printError(`Cannot resume from ${startPhase}: no pipeline state found`);
+        return failure(1);
+      }
+    }
+  }
+  const startIdx = Math.max(phaseOrder.indexOf(startPhase), 0);
+  const makeRunner = (fn, phase) => async () => {
+    const code = await fn();
+    if (code !== 0) {
+      throw new Error(`Phase ${phase} failed with exit code ${code}`);
+    }
+  };
+  const runners = {
+    prd: makeRunner(() => runPrd(issueNumber, resolvedIssue), "prd"),
+    plan: async () => {
+      await makeRunner(
+        () => runPlan(issueNumber, resolvedIssue, { continueFlag: continueNumbering, startUs }),
+        "plan"
+      )();
+      if (effectiveNoBranch || effectivePrReview) {
+        try {
+          const plan = await loadTaskPlan(tasksPath);
+          if (effectiveNoBranch) {
+            plan.noBranch = true;
+          }
+          if (effectivePrReview) {
+            plan.prReview = { ...plan.prReview, enabled: true, rounds: plan.prReview?.rounds ?? 0 };
+          }
+          await saveTaskPlan(tasksPath, plan);
+        } catch {
+        }
+      }
+      if (queue !== void 0 && !effectiveNoBranch) {
+        producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
+      }
+    },
+    execute: makeRunner(
+      () => runExecute(void 0, { issue: issueNumber, commitScope: queueCommitScope }),
+      "execute"
+    ),
+    review: async () => {
+      let maxCycles = 3;
+      try {
+        const plan = await loadTaskPlan(tasksPath);
+        maxCycles = plan.maxCorrectionCycles;
+      } catch {
+      }
+      let code = await runReview(issueNumber, resolvedIssue);
+      let cycle = 0;
+      while (code !== 0 && cycle < maxCycles) {
+        cycle++;
+        printWarning(`Review failed. Starting correction cycle ${cycle}/${maxCycles}...`);
+        publisher.publish({ type: "correction:cycle", at: isoNow(), cycle, maxCycles });
+        try {
+          const plan = await loadTaskPlan(tasksPath);
+          plan.correctionCycle = cycle;
+          await saveTaskPlan(tasksPath, plan);
+        } catch {
+        }
+        const execCode = await runExecute(void 0, {
+          issue: issueNumber,
+          commitScope: queueCommitScope
+        });
+        if (execCode !== 0) {
+          throw new Error("Correction execution failed");
+        }
+        code = await runReview(issueNumber, resolvedIssue);
+      }
+      if (code !== 0) {
+        throw new Error(`Review failed after ${maxCycles} correction cycles`);
+      }
+    },
+    pr: makeRunner(
+      // The options argument is omitted outside a queue so a standalone run
+      // calls `runPr` exactly as it always did.
+      () => finalPr === void 0 ? runPr(issueNumber, resolvedIssue) : runPr(issueNumber, resolvedIssue, { queue: finalPr }),
+      "pr"
+    )
+  };
+  const reviewBox = { outcome: null };
+  if (effectivePrReview) {
+    runners["pr-review"] = async () => {
+      const code = await runPrReview(void 0, { issue: issueNumber, yes: true });
+      if (code === 1) {
+        throw new Error("Phase pr-review failed with exit code 1");
+      }
+      reviewBox.outcome = await readPrReviewOutcome(issueNumber, tasksPath, code === 2);
+    };
+  }
+  const instrumentedRunners = Object.fromEntries(
+    Object.entries(runners).map(([phase, fn]) => [
+      phase,
+      async () => {
+        publisher.publish({ type: "phase:start", at: isoNow(), phase });
+        try {
+          await fn();
+          await publishGitState(publisher);
+          publisher.publish({ type: "phase:end", at: isoNow(), phase, success: true });
+        } catch (err) {
+          await publishGitState(publisher);
+          publisher.publish({
+            type: "phase:end",
+            at: isoNow(),
+            phase,
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
+          throw err;
+        }
+      }
+    ])
+  );
+  const result = await runPipelineWithRenderer({
+    phases: phaseOrder,
+    startIndex: startIdx,
+    verbose: isVerbose(),
+    runners: instrumentedRunners,
+    tasksPath
+  });
+  if (!result.success) {
+    printError(`Phase ${result.failedPhase} failed`);
+    return {
+      ...failure(1),
+      failedPhase: result.failedPhase ?? null,
+      branchName: producedBranch,
+      elapsedSeconds: result.overallElapsedSeconds
+    };
+  }
+  const review = reviewBox.outcome;
+  if (review?.requestedChanges) {
+    console.log("");
+    printWarning("PR review requested changes \u2014 the Pull Request is not ready to merge.");
+    if (review.reportPath !== null) {
+      console.log(`  Report: ${review.reportPath}`);
+    }
+  }
+  if (review?.requestedChanges) {
+    printInfo("Issue left open until the review blockers are addressed.");
+  } else if (!inQueue) {
+    await closeIssue(issueNumber, resolvedIssue.source);
+  }
+  let branchName = "unknown";
+  try {
+    const proc = await execa("git", ["branch", "--show-current"], { reject: false });
+    branchName = proc.stdout?.toString().trim() ?? "unknown";
+  } catch {
+  }
+  let storyCount = 0;
+  let planPrUrl = null;
+  try {
+    const plan = await loadTaskPlan(tasksPath);
+    storyCount = plan.userStories.length;
+    planPrUrl = plan.pullRequest?.url ?? null;
+    plan.lastAttemptAt = isoNow();
+    if (!review?.requestedChanges) {
+      plan.issueStatus = "completed";
+      plan.completedAt = isoNow();
+    }
+    await saveTaskPlan(tasksPath, plan);
+  } catch {
+  }
+  if (inQueue) {
+    if (finalPr === void 0) {
+      printSuccess(`Issue #${issueNumber} completed (${storyCount} stories).`);
+    }
+    return {
+      code: 0,
+      failedPhase: null,
+      branchName: producedBranch ?? (branchName === "unknown" ? null : branchName),
+      storyCount,
+      elapsedSeconds: result.overallElapsedSeconds,
+      review
+    };
+  }
+  let prUrl = "unknown";
+  if (!effectiveNoBranch && resolvedIssue.source === "github") {
+    if (planPrUrl !== null) {
+      prUrl = planPrUrl;
+    } else if (branchName !== "unknown" && branchName !== "") {
+      try {
+        const latest = mostRecent(await listPullRequests(branchName));
+        if (latest !== null) {
+          prUrl = latest.url;
+        }
+      } catch {
+      }
+    }
+  }
+  printRunSummary({
+    issueNumber,
+    branchName,
+    noBranch: effectiveNoBranch,
+    storyCount,
+    elapsedSeconds: result.overallElapsedSeconds,
+    prUrl,
+    prReview: review,
+    // Process-owned counters: the session snapshot is empty whenever web
+    // monitoring is off, so it cannot be the source of these totals.
+    usage: getRunUsageTotals()
+  });
+  return {
+    code: 0,
+    failedPhase: null,
+    branchName: branchName === "unknown" ? null : branchName,
+    storyCount,
+    elapsedSeconds: result.overallElapsedSeconds
+  };
+}
+async function decideQueue(input) {
+  const primary = input.requested[0];
+  const single = input.requested.length === 1;
+  if (single && input.runOptions.only === true) {
+    return { kind: "single" };
+  }
+  try {
+    const [project, queuePaths] = await Promise.all([
+      resolveProjectPaths(),
+      resolveQueuePaths(primary)
+    ]);
+    return await planQueue({
+      requested: input.requested,
+      source: input.resolved.source,
+      known: [input.resolved.issue],
+      projectId: project.projectId,
+      planFile: queuePaths.planFile,
+      noBranch: input.noBranch,
+      prReview: input.prReview,
+      confirm: { yes: input.runOptions.yes, only: input.runOptions.only }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (single) {
+      printWarning(
+        `Could not inspect related issues (${message}). Running issue #${primary} alone.`
+      );
+      return { kind: "single" };
+    }
+    printError(`Could not plan the execution of ${input.requested.length} issues: ${message}`);
+    return { kind: "stop", code: 1 };
+  }
+}
+async function runQueue(initialPlan, options, resolvedPrimary) {
+  const planFile = (await resolveQueuePaths(initialPlan.id)).planFile;
+  let plan = initialPlan;
+  const queueUsage = beginUsageScope();
+  const startedAtMs = Date.now();
+  const summaries = [];
+  let firstOfThisRun = true;
+  try {
+    while (true) {
+      const entry = nextQueueIssue(plan);
+      if (entry === null) break;
+      plan = markQueueIssueInProgress(plan, entry.id);
+      await saveExecutionPlan(planFile, plan);
+      printInfo(
+        `Queue ${entry.position}/${plan.issues.length}: issue #${entry.id}${entry.title === "" ? "" : ` \u2014 ${entry.title}`}`
+      );
+      const issueUsage = beginUsageScope();
+      let result;
+      try {
+        result = await runIssueSession(entry.id, options.mode, {
+          // `--from` addresses the issue the queue is resuming, never the ones
+          // that come after it — those start from their own beginning.
+          from: firstOfThisRun ? options.from : void 0,
+          noBranch: options.noBranch,
+          // `--start-us` belongs to the first issue this invocation runs; the
+          // ones after it continue from the history those plans just wrote.
+          runOptions: {
+            ...options.runOptions,
+            startUs: firstOfThisRun ? options.runOptions?.startUs : void 0
+          },
+          queue: {
+            plan,
+            preChecked: true,
+            resolved: entry.id === initialPlan.id ? resolvedPrimary : void 0
+          }
+        });
+      } finally {
+        firstOfThisRun = false;
+        issueUsage.end();
+      }
+      const usage = issueUsage.totals();
+      if (result.code !== 0) {
+        plan = markQueueIssueFailed(plan, entry.id, {
+          phase: result.failedPhase,
+          error: {
+            category: "queue_issue_failed",
+            message: `Issue #${entry.id} failed${result.failedPhase === null ? "" : ` in phase ${result.failedPhase}`}`,
+            at: isoNow()
+          }
+        });
+        await saveExecutionPlan(planFile, plan);
+        printError(
+          `Queue stopped at issue #${entry.id}${result.failedPhase === null ? "" : ` (phase ${result.failedPhase})`}. The branch and every commit made so far were kept.`
+        );
+        printInfo(`Resume with: issue-flow run ${plan.requested.join(",")}`);
+        return result.code;
+      }
+      if (plan.branchName === null && result.branchName !== null) {
+        plan = setQueueBranch(plan, result.branchName);
+      }
+      plan = markQueueIssueCompleted(plan, entry.id);
+      await saveExecutionPlan(planFile, plan);
+      summaries.push({
+        id: entry.id,
+        title: entry.title,
+        storyCount: result.storyCount,
+        elapsedSeconds: result.elapsedSeconds,
+        usage
+      });
+    }
+    return await finishQueue(
+      plan,
+      planFile,
+      summaries,
+      startedAtMs,
+      queueUsage,
+      options,
+      resolvedPrimary
+    );
+  } finally {
+    queueUsage.end();
+  }
+}
+async function finishQueue(plan, planFile, summaries, startedAtMs, queueUsage, options, resolvedPrimary) {
+  let current = plan;
+  let review = null;
+  const alreadyOpened = current.pullRequest !== void 0 || await primaryPrCreated(current);
+  if (!current.noBranch && options.noBranch !== true && !alreadyOpened) {
+    const outcome = await runIssueSession(current.id, options.mode, {
+      prReview: options.prReview ?? current.prReview,
+      queue: {
+        plan: current,
+        preChecked: true,
+        resolved: resolvedPrimary,
+        finalPr: await buildPrQueueContext(current)
+      }
+    });
+    review = outcome.review ?? null;
+    if (outcome.code !== 0) {
+      printError("The consolidated Pull Request could not be created.");
+      await saveExecutionPlan(planFile, current);
+      return outcome.code;
+    }
+    const pullRequest = await propagatePullRequest(current);
+    if (pullRequest !== null) {
+      current = setQueuePullRequest(current, pullRequest);
+    }
+  }
+  await saveExecutionPlan(planFile, current);
+  if (review?.requestedChanges === true) {
+    printInfo("Issues left open until the review blockers are addressed.");
+  } else {
+    for (const entry of current.issues) {
+      await closeIssue(entry.id, entry.source);
+    }
+  }
+  printQueueSummary({
+    queueId: current.id,
+    branchName: current.branchName,
+    issues: summaries,
+    excluded: current.excluded.map((entry) => ({ id: entry.id, title: entry.title })),
+    elapsedSeconds: Math.round((Date.now() - startedAtMs) / 1e3),
+    prUrl: current.pullRequest?.url ?? null,
+    // Read here, after the consolidated Pull Request (and the optional
+    // pr-review) already ran: reading it before would report a queue total
+    // that leaves out the phase that just spent tokens.
+    usage: queueUsage.totals(),
+    prReview: review
+  });
+  return 0;
+}
+async function primaryPrCreated(plan) {
+  try {
+    const paths = await resolveIssuePaths(plan.id);
+    return (await loadTaskPlan(paths.tasksFile)).pipeline.prCreated;
+  } catch {
+    return false;
+  }
+}
+async function buildPrQueueContext(plan) {
+  const pending = [];
+  for (const entry of plan.issues) {
+    try {
+      const paths = await resolveIssuePaths(entry.id);
+      const taskPlan = await loadTaskPlan(paths.tasksFile);
+      if (taskPlan.lastReviewFindings !== null && taskPlan.lastReviewFindings !== "") {
+        pending.push(`Issue #${entry.id} has unresolved review findings`);
+      }
+    } catch {
+    }
+  }
+  return {
+    issues: plan.issues.map((entry) => ({
+      id: entry.id,
+      number: entry.number,
+      title: entry.title,
+      url: entry.url,
+      source: entry.source
+    })),
+    excluded: plan.excluded.map((entry) => ({
+      id: entry.id,
+      number: entry.number,
+      title: entry.title,
+      reason: entry.reason
+    })),
+    pending
+  };
+}
+async function propagatePullRequest(plan) {
+  let pullRequest = null;
+  try {
+    const primaryPaths = await resolveIssuePaths(plan.id);
+    pullRequest = (await loadTaskPlan(primaryPaths.tasksFile)).pullRequest ?? null;
+  } catch {
+    return null;
+  }
+  if (pullRequest === null) return null;
+  for (const entry of plan.issues) {
+    if (entry.id === plan.id) continue;
+    try {
+      const paths = await resolveIssuePaths(entry.id);
+      const taskPlan = await loadTaskPlan(paths.tasksFile);
+      taskPlan.pullRequest = pullRequest;
+      taskPlan.pipeline.prCreated = true;
+      await saveTaskPlan(paths.tasksFile, taskPlan);
+    } catch {
+      printWarning(`Could not record the Pull Request on issue #${entry.id}'s task plan.`);
+    }
+  }
+  return pullRequest;
+}
+function failure(code) {
+  return { code, failedPhase: null, branchName: null, storyCount: 0, elapsedSeconds: 0 };
+}
+async function closeIssue(issueNumber, source) {
+  try {
+    const provider = getProvider(source);
+    if (provider.close !== void 0) {
+      printInfo("Closing issue...");
+      await provider.close(issueNumber);
+    }
+  } catch {
+    printWarning("Failed to close issue automatically");
+  }
+}
+async function adoptQueueBranch(tasksPath, queueBranch) {
+  try {
+    const plan = await loadTaskPlan(tasksPath);
+    if (queueBranch === null || queueBranch === "") {
+      return plan.branchName === "" ? null : plan.branchName;
+    }
+    if (plan.branchName !== queueBranch) {
+      plan.branchName = queueBranch;
+      await saveTaskPlan(tasksPath, plan);
+    }
+    return queueBranch;
+  } catch {
+    return queueBranch;
+  }
+}
+export {
+  publishIssueDetails,
+  publishStorySeed,
+  runPipeline
+};
+//# sourceMappingURL=run-BRBFHVUO.js.map