issue-flow 0.16.0 → 0.18.0

package/dist/{chunk-OLUOZLU5.js → chunk-CWSQVHVV.js}

@@ -3,19 +3,26 @@ import {
   formatPhaseLine,
   loadPhaseTiming,
   snapshotTimingFields
-} from "./chunk-VK65RNFA.js";
+} from "./chunk-QJ44VG5G.js";
+import {
+  runPr
+} from "./chunk-OODXFCQV.js";
 import {
   mostRecent,
   prReviewDir,
   readPrReviewIndex,
   runPrReview
-} from "./chunk-Q2TZA6AC.js";
+} from "./chunk-LTH6XYZ3.js";
+import {
+  listPullRequests,
+  publishGitState
+} from "./chunk-YUNBOUQH.js";
 import {
   runPrd
-} from "./chunk-OGN2NX57.js";
+} from "./chunk-XUEMATVY.js";
 import {
   runReview
-} from "./chunk-EPFC4LHT.js";
+} from "./chunk-EG2MGDP5.js";
 import {
   PIPELINE_PHASES,
   PIPELINE_PHASES_NO_BRANCH,
@@ -37,65 +44,65 @@ import {
   saveExecutionPlan,
   setQueueBranch,
   setQueuePullRequest
-} from "./chunk-X6GY3CM2.js";
+} from "./chunk-7UMMFOL2.js";
 import {
   runInit
-} from "./chunk-KV2K7MK2.js";
+} from "./chunk-PMLE7KAQ.js";
 import {
   printQueueSummary,
   printRunSummary,
   runExecute,
   stripMarkdown
-} from "./chunk-SW2MF47D.js";
+} from "./chunk-KRAGAUKD.js";
 import {
   ensureWebMonitor
-} from "./chunk-YA6FWFYW.js";
+} from "./chunk-NEWNXZ65.js";
 import {
   runPlan
-} from "./chunk-GV2DABNZ.js";
-import {
-  runPr
-} from "./chunk-2H43OVTU.js";
-import {
-  listPullRequests,
-  publishGitState
-} from "./chunk-WLJVL25O.js";
+} from "./chunk-34OCSKOB.js";
 import {
   resolveCommandIssue
-} from "./chunk-MCLPSL6B.js";
+} from "./chunk-SA6HXL4Y.js";
 import {
   getProvider
-} from "./chunk-H3EYBJZU.js";
+} from "./chunk-62GVVZQO.js";
 import {
   beginUsageScope,
   getRunUsageTotals
-} from "./chunk-4FUWWBTP.js";
+} from "./chunk-KMCS76ZW.js";
 import {
   assessDecomposition,
   buildDecompositionReport,
   proposeSubIssues,
   resetAgentInvocationState
-} from "./chunk-73TS2H42.js";
+} from "./chunk-TZYINKCC.js";
 import {
   JournalPublisher,
   MultiPublisher
-} from "./chunk-IAMIBZRF.js";
+} from "./chunk-WCCZJL7W.js";
+import {
+  recommendedTarget
+} from "./chunk-ZVZMWNCG.js";
 import {
   getPackageVersion
 } from "./chunk-C5TL7T4V.js";
 import {
   describeRunAgents,
   getActiveResilienceConfig,
+  getAgentCliOverrides,
+  hasExplicitAgentSelection,
   initResilienceConfig,
+  loadAgentConfig,
   loadIssuesConfig,
+  loadRoutingConfig,
   loadWebConfig,
   onShutdown
-} from "./chunk-J2LJB2OH.js";
+} from "./chunk-QF7VEL3M.js";
 import {
   resolveIssuePaths,
   resolveProjectPaths,
   resolveQueuePaths
-} from "./chunk-VTF4RWS5.js";
+} from "./chunk-LI35PIIS.js";
 import {
   formatDuration,
   getIcons,
@@ -110,18 +117,12 @@ import {
   setOutputCallback,
   setStoryStageCallback,
   setStoryUpdateCallback
-} from "./chunk-SVDEWOUD.js";
-import {
-  FilePublisher,
-  MemoryPublisher,
-  getSessionPublisher,
-  setSessionPublisher
-} from "./chunk-ROIIEVZH.js";
+} from "./chunk-XZUEFTUP.js";
 import {
   bindDiagnosticContext,
   flushDiagnostics,
   writeDiagnostic
-} from "./chunk-FKWYD44M.js";
+} from "./chunk-QPGEFLMY.js";
 import {
   committedStoryIds,
   describePreflight,
@@ -132,22 +133,22 @@ import {
   localBranchExists,
   preflightRepository,
   run
-} from "./chunk-WNROH2YE.js";
+} from "./chunk-YVPZUN6X.js";
+import {
+  FilePublisher,
+  MemoryPublisher,
+  getSessionPublisher,
+  setSessionPublisher
+} from "./chunk-DUS5ZNKL.js";
 import {
   isoNow,
   loadTaskPlan,
   saveTaskPlan
-} from "./chunk-GVOZ6NDO.js";
+} from "./chunk-SOM4QA6C.js";
 import {
   acquireRunLock,
   describeRunLockOwner
-} from "./chunk-QVLIIGBU.js";
-
-// src/commands/run.ts
-import { randomUUID } from "crypto";
-import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
-import { join } from "path";
-import { execa } from "execa";
+} from "./chunk-ICM463EO.js";
 
 // src/execution/detach.ts
 import { spawn } from "child_process";
@@ -219,6 +220,42 @@ async function spawnDetachedRun(input) {
   }
 }
 
+// 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/execution/confirm.ts
 import { createInterface } from "readline";
 var MAX_PROMPT_ATTEMPTS = 3;
@@ -476,11 +513,43 @@ async function loadResumableQueue(planFile, requested) {
   const sameRequest = plan.requested.length === requested.length && plan.requested.every((id, index) => id === requested[index]);
   return sameRequest ? plan : null;
 }
+function executableGraphIds(graph, requested) {
+  const roots = new Set(requested);
+  return [...graph.nodes.values()].filter((node) => roots.has(node.id) || node.issue?.state !== "closed").map((node) => node.id);
+}
+async function reconcileClosedDiscoveredIssues(plan, warn) {
+  let next = plan;
+  const closed = [];
+  for (const entry of plan.issues) {
+    if (entry.origin !== "discovered" || entry.status === "completed") continue;
+    try {
+      const issue = await getProvider(entry.source).get(entry.id);
+      if (issue?.state !== "closed") continue;
+      next = markQueueIssueCompleted(next, entry.id);
+      closed.push(entry.id);
+    } catch (err) {
+      warn(
+        `Could not refresh issue #${entry.id} before resuming the queue: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { plan: next, closed };
+}
 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);
+  let resumable = await loadResumableQueue(input.planFile, input.requested);
+  if (resumable !== null) {
+    const reconciled = await reconcileClosedDiscoveredIssues(resumable, warn);
+    resumable = reconciled.plan;
+    if (reconciled.closed.length > 0) {
+      await saveExecutionPlan(input.planFile, resumable);
+      info(
+        `Skipping already closed issue(s) in the resumed queue: ${reconciled.closed.map((id) => `#${id}`).join(", ")}.`
+      );
+    }
+  }
   if (resumable !== null && isQueueComplete(resumable)) {
     const pr = resumable.pullRequest?.url;
     info(
@@ -506,10 +575,8 @@ async function planQueue(input) {
     known: input.known,
     warn
   });
-  if (single && graph.nodes.size <= 1) {
-    return { kind: "single" };
-  }
-  const suggested = computeExecutionOrder(graph);
+  const schedulable = executableGraphIds(graph, input.requested);
+  const suggested = computeExecutionOrder(graph, { include: schedulable });
   if (!suggested.ok) {
     if (single) {
       warn(
@@ -532,6 +599,9 @@ async function planQueue(input) {
     noBranch: input.noBranch,
     prReview: input.prReview
   });
+  if (single && suggestedPlan.issues.length === 1 && suggestedPlan.issues[0]?.role !== "container") {
+    return { kind: "single" };
+  }
   let choice;
   try {
     choice = await confirmQueue(suggestedPlan, requestedCount, {
@@ -551,7 +621,8 @@ async function planQueue(input) {
   }
   let plan = suggestedPlan;
   if (choice === "cascade") {
-    const include = collectCascadeIds(graph, input.requested);
+    const eligible = new Set(schedulable);
+    const include = collectCascadeIds(graph, input.requested).filter((id) => eligible.has(id));
     const cascadeOrder = computeExecutionOrder(graph, { include });
     if (!cascadeOrder.ok) {
       warn(`Dependency cycle between issues: ${describeCycles(cascadeOrder.cycles)}.`);
@@ -605,131 +676,525 @@ async function planQueue(input) {
   return { kind: "queue", plan, resumed: false };
 }
 
-// src/issues/args.ts
-var IssueArgumentError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "IssueArgumentError";
+// src/commands/run/pull-request.ts
+async function primaryPrCreated(plan) {
+  try {
+    const paths = await resolveIssuePaths(plan.id);
+    return (await loadTaskPlan(paths.tasksFile)).pipeline.prCreated;
+  } catch {
+    return false;
   }
-};
-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()}'.`);
+}
+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`);
       }
-      if (seen.has(id)) continue;
-      seen.add(id);
-      ids.push(id);
+    } catch {
     }
   }
-  if (ids.length === 0) {
-    throw new IssueArgumentError("No issue was informed. Pass at least one issue number.");
-  }
-  return ids;
+  return {
+    issues: plan.issues.map((entry) => ({
+      id: entry.id,
+      number: entry.number,
+      title: entry.title,
+      url: entry.url,
+      source: entry.source,
+      parent: entry.parent,
+      role: entry.role,
+      complete: entry.status === "completed"
+    })),
+    excluded: plan.excluded.map((entry) => ({
+      id: entry.id,
+      number: entry.number,
+      title: entry.title,
+      reason: entry.reason
+    })),
+    pending
+  };
 }
-
-// src/ui/pipeline-renderer.ts
-import { Listr, PRESET_TIMER, PRESET_TIMESTAMP } from "listr2";
-
-// src/ui/status-view.ts
-function renderExecuteFocus(snapshot, options = {}) {
-  const icons = options.icons ?? getIcons();
-  const story = activeStory(snapshot);
-  if (story === void 0 && snapshot.currentActivity === null) return [];
-  const lines = [];
-  if (story !== void 0) {
-    const duration = story.durationSeconds !== null && story.durationSeconds !== void 0 ? `  ${formatDuration(story.durationSeconds)}` : "";
-    lines.push(`  ${icons.pending} ${story.id}  ${stripMarkdown(story.title)}${duration}`);
+async function propagatePullRequest(plan) {
+  let pullRequest = null;
+  try {
+    const primaryPaths = await resolveIssuePaths(plan.id);
+    pullRequest = (await loadTaskPlan(primaryPaths.tasksFile)).pullRequest ?? null;
+  } catch {
+    return null;
   }
-  const activity = snapshot.currentActivity;
-  if (activity?.tool) {
-    const detail = activity.detail ? `  ${stripMarkdown(activity.detail)}` : "";
-    lines.push(`     ${activity.tool}${detail}`);
+  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 lines;
+  return pullRequest;
 }
-function activeStory(snapshot) {
-  const fromActivity = snapshot.currentActivity?.story;
-  if (fromActivity) {
-    const match = snapshot.stories.find((story) => story.id === fromActivity);
-    if (match) return match;
+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");
   }
-  return snapshot.stories.find((story) => story.stage === "executing");
 }
 
-// src/ui/pipeline-renderer.ts
-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;
+// src/commands/run/queue-failure.ts
+async function handleQueueIssueFailure(input) {
+  let plan = input.plan;
+  const { planFile, entry, result, failureMode, maxIssueAttempts, exhausted, failedIds } = input;
+  const failure2 = {
+    phase: result.failedPhase,
+    error: {
+      category: "queue_issue_failed",
+      message: `Issue #${entry.id} failed${result.failedPhase === null ? "" : ` in phase ${result.failedPhase}`}`,
+      at: isoNow()
     }
   };
-}
-function executeExpandsStories(verbose) {
-  return verbose;
-}
-function paintExecuteFocus(task) {
-  const lines = renderExecuteFocus(getSessionPublisher().snapshot());
-  if (lines.length > 0) task.output = lines.join("\n");
-}
-function buildExecutePhaseTask(runner, tasksPath, verbose) {
-  return async (_ctx, task) => {
-    let stories;
-    try {
+  const where = result.failedPhase === null ? "" : ` (phase ${result.failedPhase})`;
+  if (failureMode === "stop") {
+    plan = markQueueIssueFailed(plan, entry.id, failure2);
+    await saveExecutionPlan(planFile, plan);
+    printError(
+      `Queue stopped at issue #${entry.id}${where}. The branch and every commit made so far were kept.`
+    );
+    printInfo(`Resume with: issue-flow run ${plan.requested.join(",")}`);
+    return { action: "stop", code: result.code };
+  }
+  if (failureMode === "block") {
+    plan = markQueueIssueBlocked(
+      plan,
+      entry.id,
+      `Failed${where} and --on-issue-failure block was in force`,
+      failure2
+    );
+    await saveExecutionPlan(planFile, plan);
+    exhausted.add(entry.id);
+    failedIds.add(entry.id);
+    printWarning(
+      `Issue #${entry.id} failed${where} and is blocked for review. Continuing with the rest of the queue.`
+    );
+    return { action: "continue", plan };
+  }
+  const attempts = entry.attempts + 1;
+  if (attempts >= maxIssueAttempts) {
+    plan = markQueueIssueFailed(plan, entry.id, failure2);
+    exhausted.add(entry.id);
+    failedIds.add(entry.id);
+    printWarning(
+      `Issue #${entry.id} failed${where} after ${attempts} attempt(s). Continuing with the rest of the queue.`
+    );
+  } else {
+    plan = markQueueIssueSkipped(plan, entry.id, failure2);
+    printWarning(
+      `Issue #${entry.id} failed${where}. Skipping it for now and coming back at the end of the queue.`
+    );
+  }
+  await saveExecutionPlan(planFile, plan);
+  return { action: "continue", plan };
+}
+
+// src/commands/run/multi-issue.ts
+var DEFAULT_MAX_ISSUE_ATTEMPTS = 2;
+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,
+        cascade: input.runOptions.cascade
+      }
+    });
+  } 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 detachAfterConfirm(requested, noBranch, prReview, options) {
+  const childFlags = [...process.argv.slice(2)];
+  if (options.yes !== true && options.only !== true) {
+    try {
+      const issuesConfig = await loadIssuesConfig();
+      const resolution = await resolveCommandIssue(requested[0], void 0, {
+        config: issuesConfig
+      });
+      if (resolution.ok) {
+        const decision = await decideQueue({
+          requested,
+          resolved: resolution.resolved,
+          noBranch: noBranch ?? false,
+          prReview: prReview ?? false,
+          runOptions: options
+        });
+        if (decision.kind === "stop") return decision.code;
+        if (decision.kind === "queue" && !childFlags.includes("--yes")) childFlags.push("--yes");
+        if (decision.kind === "single" && !childFlags.includes("--only")) childFlags.push("--only");
+      }
+    } catch {
+    }
+  }
+  const paths = await resolveIssuePaths(requested[0]);
+  const { pid, logFile } = await spawnDetachedRun({ paths, argv: childFlags });
+  printSuccess(`Detached run started (pid ${pid}).`);
+  printInfo(`Log: ${logFile}`);
+  printInfo("Follow with: issue-flow ps");
+  printInfo(`Stop with: kill ${pid}`);
+  return 0;
+}
+async function runQueue(initialPlan, options, resolvedPrimary, runIssueSession3) {
+  const planFile = (await resolveQueuePaths(initialPlan.id)).planFile;
+  const queueUsage = beginUsageScope();
+  const startedAtMs = Date.now();
+  const resilience = getActiveResilienceConfig();
+  const failureMode = options.runOptions?.onIssueFailure ?? resilience.queue?.onIssueFailure ?? "stop";
+  const maxIssueAttempts = resilience.queue?.maxIssueAttempts ?? DEFAULT_MAX_ISSUE_ATTEMPTS;
+  try {
+    return await processQueueIssues({
+      plan: initialPlan,
+      planFile,
+      initialPlan,
+      options,
+      resolvedPrimary,
+      runIssueSession: runIssueSession3,
+      failureMode,
+      maxIssueAttempts,
+      startedAtMs,
+      queueUsage
+    });
+  } finally {
+    queueUsage.end();
+  }
+}
+async function processQueueEntry(input) {
+  let plan = input.plan;
+  const {
+    planFile,
+    entry,
+    initialPlan,
+    options,
+    resolvedPrimary,
+    runIssueSession: runIssueSession3,
+    failureMode,
+    maxIssueAttempts,
+    exhausted,
+    failedIds,
+    summaries
+  } = input;
+  let firstOfThisRun = input.firstOfThisRun;
+  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 runIssueSession3(entry.id, options.mode, {
+      // `--from` / `--start-us` apply only to the first issue of this invocation.
+      from: firstOfThisRun ? options.from : void 0,
+      noBranch: options.noBranch,
+      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();
+  }
+  if (result.code !== 0) {
+    const handled = await handleQueueIssueFailure({
+      plan,
+      planFile,
+      entry,
+      result,
+      failureMode,
+      maxIssueAttempts,
+      exhausted,
+      failedIds
+    });
+    if (handled.action === "stop") return { action: "stop", code: handled.code };
+    return { action: "continue", plan: handled.plan, firstOfThisRun };
+  }
+  plan = await recordQueueIssueSuccess({
+    plan,
+    planFile,
+    entry,
+    result,
+    usage: issueUsage.totals(),
+    summaries
+  });
+  return { action: "continue", plan, firstOfThisRun };
+}
+async function recordQueueIssueSuccess(input) {
+  let { plan } = input;
+  const { planFile, entry, result, usage, summaries } = input;
+  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 plan;
+}
+async function processQueueIssues(input) {
+  let plan = input.plan;
+  const {
+    planFile,
+    initialPlan,
+    options,
+    resolvedPrimary,
+    runIssueSession: runIssueSession3,
+    failureMode,
+    maxIssueAttempts,
+    startedAtMs,
+    queueUsage
+  } = input;
+  const summaries = [];
+  let firstOfThisRun = true;
+  const exhausted = /* @__PURE__ */ new Set();
+  const failedIds = /* @__PURE__ */ new Set();
+  while (true) {
+    const entry = nextQueueIssue(plan, { exclude: exhausted });
+    if (entry === null) break;
+    const processed = await processQueueEntry({
+      plan,
+      planFile,
+      entry,
+      initialPlan,
+      options,
+      resolvedPrimary,
+      runIssueSession: runIssueSession3,
+      failureMode,
+      maxIssueAttempts,
+      firstOfThisRun,
+      exhausted,
+      failedIds,
+      summaries
+    });
+    if (processed.action === "stop") return processed.code;
+    plan = processed.plan;
+    firstOfThisRun = processed.firstOfThisRun;
+  }
+  const code = await finishQueue(
+    plan,
+    planFile,
+    summaries,
+    startedAtMs,
+    queueUsage,
+    options,
+    resolvedPrimary,
+    runIssueSession3
+  );
+  if (failedIds.size > 0) {
+    printError(
+      `${failedIds.size} issue(s) did not finish: ${[...failedIds].map((id) => `#${id}`).join(", ")}.`
+    );
+    printInfo(`Resume with: issue-flow run ${plan.requested.join(",")}`);
+    return code === 0 ? 1 : code;
+  }
+  return code;
+}
+async function finishQueue(plan, planFile, summaries, startedAtMs, queueUsage, options, resolvedPrimary, runIssueSession3) {
+  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 runIssueSession3(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 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;
+  }
+}
+
+// src/ui/pipeline-renderer.ts
+import { Listr, PRESET_TIMER, PRESET_TIMESTAMP } from "listr2";
+
+// src/ui/status-view.ts
+function renderExecuteFocus(snapshot, options = {}) {
+  const icons = options.icons ?? getIcons();
+  const story = activeStory(snapshot);
+  if (story === void 0 && snapshot.currentActivity === null) return [];
+  const lines = [];
+  if (story !== void 0) {
+    const duration = story.durationSeconds !== null && story.durationSeconds !== void 0 ? `  ${formatDuration(story.durationSeconds)}` : "";
+    lines.push(`  ${icons.pending} ${story.id}  ${stripMarkdown(story.title)}${duration}`);
+  }
+  const activity = snapshot.currentActivity;
+  if (activity?.tool) {
+    const detail = activity.detail ? `  ${stripMarkdown(activity.detail)}` : "";
+    lines.push(`     ${activity.tool}${detail}`);
+  }
+  return lines;
+}
+function activeStory(snapshot) {
+  const fromActivity = snapshot.currentActivity?.story;
+  if (fromActivity) {
+    const match = snapshot.stories.find((story) => story.id === fromActivity);
+    if (match) return match;
+  }
+  return snapshot.stories.find((story) => story.stage === "executing");
+}
+
+// src/ui/pipeline-renderer.ts
+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 executeExpandsStories(verbose) {
+  return verbose;
+}
+function paintExecuteFocus(task) {
+  const lines = renderExecuteFocus(getSessionPublisher().snapshot());
+  if (lines.length > 0) task.output = lines.join("\n");
+}
+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 {
@@ -907,7 +1372,11 @@ async function runPipelineWithRenderer(options) {
   };
 }
 
-// src/commands/run.ts
+// src/commands/run/phase-finalize.ts
+import { execa } from "execa";
+
+// src/commands/run/publish.ts
+import { join } from "path";
 function toIssueNumber(id) {
   const parsed = Number.parseInt(id, 10);
   return Number.isNaN(parsed) ? null : parsed;
@@ -960,17 +1429,6 @@ function publishIssueDetails(publisher, issue, at) {
     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"];
 function verificationForSummary(value) {
   if (value === null || value.verdict === null) return null;
   return { verdict: value.verdict, level: value.level };
@@ -997,200 +1455,608 @@ async function readPrReviewOutcome(issue, tasksPath, requestedChanges) {
   }
   return outcome;
 }
-var DEFAULT_MAX_ISSUE_ATTEMPTS = 2;
-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;
-  }
-  if (options.background === true && options.detachedChild !== true) {
-    const reason = backgroundRejection(mode);
-    if (reason !== null) {
-      printError(reason);
-      return 1;
+
+// src/commands/run/phase-finalize.ts
+async function applyReviewOutcomeAndClose(input) {
+  const { issueNumber, resolvedIssue, review, inQueue } = input;
+  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}`);
     }
-    return detachAfterConfirm(requested, noBranch, prReview, options);
-  }
-  const ownership = await claimRunOwnership(requested[0], options.detachedChild === true);
-  if (!ownership.ok) {
-    printError(
-      `Another issue-flow run owns this project: ${describeRunLockOwner(ownership.owner)}.`
-    );
-    printInfo("Wait for it to finish, or stop that process before running again.");
-    return 1;
   }
-  try {
-    const first = await runIssueSession(requested[0], mode, {
-      from,
-      noBranch,
-      prReview,
-      requested,
-      runOptions: options,
-      restartWeb: options.restartWeb,
-      ...ownership.interruptedBy === null ? {} : { interruptedBy: ownership.interruptedBy }
-    });
-    if (first.queue === void 0) {
-      return first.code;
-    }
-    return runQueue(
-      first.queue.plan,
-      { mode, from, noBranch, prReview, runOptions: options },
-      first.queue.resolved
-    );
-  } finally {
-    await ownership.release();
+  if (review?.requestedChanges) {
+    printInfo("Issue left open until the review blockers are addressed.");
+  } else if (!inQueue) {
+    await closeIssue(issueNumber, resolvedIssue.source);
   }
 }
-var WRITING_PHASES = /* @__PURE__ */ new Set(["plan", "execute", "pr"]);
-async function ensureRepositoryWritable(phase) {
-  if (!WRITING_PHASES.has(phase)) return;
-  const preflight = await preflightRepository({ intent: "resume-same-phase" });
-  if (preflight.ok) return;
-  for (const line of describePreflight(preflight)) {
-    printError(line);
+async function resolveSummaryPrUrl(input) {
+  let prUrl = "unknown";
+  if (!input.effectiveNoBranch && input.source === "github") {
+    if (input.planPrUrl !== null) {
+      prUrl = input.planPrUrl;
+    } else if (input.branchName !== "unknown" && input.branchName !== "") {
+      try {
+        const latest = mostRecent(await listPullRequests(input.branchName));
+        if (latest !== null) {
+          prUrl = latest.url;
+        }
+      } catch {
+      }
+    }
   }
-  throw new Error(`The repository is not in a state the ${phase} phase can write to`);
+  return prUrl;
 }
-async function claimRunOwnership(target, detached = false) {
-  let lockFile;
+async function finalizeSuccessfulIssueRun(input) {
+  const {
+    issueNumber,
+    tasksPath,
+    resolvedIssue,
+    review,
+    inQueue,
+    finalPr,
+    producedBranch,
+    effectiveNoBranch,
+    elapsedSeconds
+  } = input;
+  await applyReviewOutcomeAndClose({ issueNumber, resolvedIssue, review, inQueue });
+  let branchName = "unknown";
   try {
-    lockFile = (await resolveProjectPaths()).runLockFile;
+    const proc = await execa("git", ["branch", "--show-current"], { reject: false });
+    branchName = proc.stdout?.toString().trim() ?? "unknown";
   } catch {
-    return { ok: true, interruptedBy: null, release: async () => {
-    } };
   }
-  const result = await acquireRunLock(lockFile, { target, detached });
-  if (!result.ok) return result;
-  return {
-    ok: true,
-    interruptedBy: result.handle.reclaimedFrom,
-    release: () => result.handle.release()
-  };
-}
-async function runIssueSession(issueNumber, mode, input) {
-  resetAgentInvocationState();
-  const paths = await resolveIssuePaths(issueNumber);
+  let storyCount = 0;
+  let planPrUrl = null;
   try {
-    const project = await resolveProjectPaths();
-    bindDiagnosticContext({
-      project: project.projectId,
-      projectRoot: await getProjectRoot(),
-      issue: issueNumber,
-      sessionId: null,
-      executionId: null,
-      phase: null,
-      story: null,
-      harness: null,
-      model: null
-    });
+    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 {
   }
-  const resilience = await initResilienceConfig();
-  const configuredInactivity = resilience.watchdog?.inactivityTimeoutMs;
-  if (configuredInactivity !== void 0 && getInactivityTimeout() === void 0) {
-    setInactivityTimeout(configuredInactivity);
-  }
-  const webConfig = await loadWebConfig();
-  const surfaces = [];
-  const journalEnabled = resilience.journal?.enabled === true;
-  const persistSnapshot = webConfig.enabled || input.runOptions?.detachedChild === true;
-  if (persistSnapshot || journalEnabled) {
-    await mkdir2(paths.issueDir, { recursive: true });
-  }
-  if (persistSnapshot) {
-    surfaces.push(
-      new FilePublisher(paths.sessionFile, {
-        logLimit: webConfig.logLimit,
-        includeLogs: webConfig.includeLogs
-      })
-    );
-  }
-  if (journalEnabled) {
-    surfaces.push(
-      new JournalPublisher(paths.eventsFile, paths.rotatedEventsFile, {
-        logLimit: webConfig.logLimit,
-        includeLogs: webConfig.includeLogs,
-        ...resilience.journal?.maxFileBytes === void 0 ? {} : { maxFileBytes: resilience.journal.maxFileBytes }
-      })
-    );
+  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,
+      review
+    };
   }
-  const publisher = surfaces.length === 0 ? new MemoryPublisher() : surfaces.length === 1 ? surfaces[0] : new MultiPublisher(surfaces);
-  setSessionPublisher(publisher);
-  if (input.interruptedBy !== void 0) {
-    const previous = input.interruptedBy;
-    publisher.publish({
-      type: "log",
-      at: isoNow(),
-      level: "warn",
-      message: `Previous run interrupted: ${describeRunLockOwner(previous)}. Its lock was stale and has been taken over.`
-    });
+  const prUrl = await resolveSummaryPrUrl({
+    effectiveNoBranch,
+    source: resolvedIssue.source,
+    planPrUrl,
+    branchName
+  });
+  printRunSummary({
+    issueNumber,
+    branchName,
+    noBranch: effectiveNoBranch,
+    storyCount,
+    elapsedSeconds,
+    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(),
+    verification: verificationForSummary(getSessionPublisher().snapshot().verification)
+  });
+  return {
+    code: 0,
+    failedPhase: null,
+    branchName: branchName === "unknown" ? null : branchName,
+    storyCount,
+    elapsedSeconds
+  };
+}
+
+// src/commands/run/phase-bootstrap.ts
+import { randomUUID } from "crypto";
+
+// src/commands/run/phase-config.ts
+async function buildAgentConfiguration(prReview) {
+  const agentSummary = await describeRunAgents(
+    prReview ? ["prd", "plan", "execute", "review", "pr", "pr-review"] : ["prd", "plan", "execute", "review", "pr"]
+  );
+  const fallbacks = getActiveResilienceConfig().providers?.chain ?? [];
+  const routingConfig = await loadRoutingConfig();
+  const agentConfig = await loadAgentConfig();
+  const displayedPhases = Object.entries(agentSummary.byPhase).map(([phase, resolved]) => {
+    const recommended = routingConfig.mode === "active" && routingConfig.policy === "recommended" && !hasExplicitAgentSelection(
+      agentConfig,
+      getAgentCliOverrides(),
+      phase
+    ) ? recommendedTarget(phase) : null;
+    return {
+      phase,
+      provider: recommended?.provider ?? resolved.provider,
+      model: recommended?.model ?? resolved.model,
+      providerSource: recommended ? "recommended" : resolved.origin.provider,
+      modelSource: recommended ? "recommended" : resolved.origin.model
+    };
+  });
+  const configurationSnapshot = {
+    precedence: ["default", "global", "project", "env", "cli", "step override"],
+    defaultProvider: {
+      value: agentSummary.defaultProvider,
+      source: agentSummary.defaultOrigin.provider
+    },
+    defaultModel: {
+      value: agentSummary.defaultModel,
+      source: agentSummary.defaultOrigin.model
+    },
+    phases: displayedPhases.map((resolved) => ({
+      phase: resolved.phase,
+      provider: { value: resolved.provider, source: resolved.providerSource },
+      model: { value: resolved.model, source: resolved.modelSource }
+    })),
+    fallbacks,
+    overrides: displayedPhases.filter(
+      (resolved) => resolved.provider !== agentSummary.defaultProvider || resolved.model !== agentSummary.defaultModel
+    ).map(
+      (resolved) => `${resolved.phase}: ${resolved.provider}${resolved.model ? ` \xB7 ${resolved.model}` : ""}`
+    )
+  };
+  return { agentSummary, configurationSnapshot };
+}
+
+// src/commands/run/types.ts
+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"];
+function failure(code) {
+  return { code, failedPhase: null, branchName: null, storyCount: 0, elapsedSeconds: 0 };
+}
+
+// src/commands/run/phase-options.ts
+function resolveExecuteRetry(runOptions) {
+  return {
+    retryLimit: runOptions?.retryLimit,
+    retryForever: runOptions?.retryForever
+  };
+}
+function resolveStoryNumbering(runOptions) {
+  return {
+    continueNumbering: runOptions?.continueNumbering,
+    startUs: runOptions?.startUs
+  };
+}
+function resolveBranchAndReviewModes(input) {
+  const warnings = [];
+  if (input.persisted === null) {
+    const effectiveNoBranch2 = input.noBranch ?? false;
+    let effectivePrReview2 = input.prReview ?? false;
+    if (effectiveNoBranch2 && effectivePrReview2) {
+      warnings.push(
+        "This pipeline runs with --no-branch and opens no PR. Skipping the pr-review phase."
+      );
+      effectivePrReview2 = false;
+    }
+    return {
+      effectiveNoBranch: effectiveNoBranch2,
+      effectivePrReview: effectivePrReview2,
+      warnings,
+      planIssueUrl: void 0,
+      planBranch: void 0,
+      planStories: []
+    };
   }
-  if (webConfig.enabled) {
-    await ensureWebMonitor(
-      {
-        publisher,
-        port: webConfig.port,
-        host: webConfig.host,
-        refreshSeconds: webConfig.refreshSeconds
-      },
-      { restart: input.restartWeb === true }
+  const persistedNoBranch = input.persisted.noBranch;
+  let effectivePrReview = input.prReview ?? input.persisted.prReviewEnabled;
+  if (input.noBranch !== void 0 && input.noBranch !== persistedNoBranch) {
+    if (persistedNoBranch) {
+      warnings.push(
+        "This pipeline was started with --no-branch. Ignoring current flag; using persisted mode."
+      );
+    } else {
+      warnings.push(
+        "This pipeline was started without --no-branch. Ignoring current flag; using persisted mode."
+      );
+    }
+  }
+  const effectiveNoBranch = persistedNoBranch;
+  if (effectiveNoBranch && effectivePrReview) {
+    warnings.push(
+      "This pipeline runs with --no-branch and opens no PR. Skipping the pr-review phase."
     );
+    effectivePrReview = false;
   }
-  let result = {
-    code: 1,
-    failedPhase: null,
-    branchName: null,
-    storyCount: 0,
-    elapsedSeconds: 0
+  return {
+    effectiveNoBranch,
+    effectivePrReview,
+    warnings,
+    planIssueUrl: input.persisted.issueUrl,
+    planBranch: input.persisted.branchName,
+    planStories: [...input.persisted.userStories]
   };
-  const releaseCheckpoint = onShutdown({
-    phase: "checkpoint",
-    run: async () => {
-      await pauseIssue(paths.tasksFile, issueNumber);
+}
+function selectPhaseLists(input) {
+  const { finalPr, inQueue, effectiveNoBranch, effectivePrReview } = input;
+  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;
+  return { activePhases, phaseOrder };
+}
+
+// src/commands/run/phase-bootstrap.ts
+async function runInitGate(input) {
+  const { queue, issuesConfig, publishSessionStart, publisher } = input;
+  const sessionStartedAt = isoNow();
+  if (queue?.preChecked !== true) {
+    if (isVerbose()) {
+      printInfo("Running prerequisite checks...");
+    }
+    const initCode = await runInit(issuesConfig.preferredProvider, { compact: !isVerbose() });
+    if (initCode !== 0) {
+      publishSessionStart(PIPELINE_PHASES, sessionStartedAt);
+      publisher.publish({ type: "phase:start", at: sessionStartedAt, phase: "init" });
       publisher.publish({
-        type: "log",
+        type: "phase:end",
         at: isoNow(),
-        level: "warn",
-        message: `Interrupted during issue #${issueNumber}. A checkpoint was saved; resume with \`issue-flow resume ${issueNumber}\`.`
+        phase: "init",
+        success: false,
+        error: "Prerequisites not met"
       });
-      publisher.publish({ type: "session:end", at: isoNow(), status: "failed" });
+      printError("Prerequisites not met. Fix the issues above and try again.");
+      return { kind: "done", result: failure(1) };
     }
+  }
+  return { kind: "ok", sessionStartedAt };
+}
+async function beginBootstrapLocals(issueNumber, paths, runOptions) {
+  const { continueNumbering, startUs } = resolveStoryNumbering(runOptions);
+  const executeRetry = resolveExecuteRetry(runOptions);
+  const tasksPath = paths.tasksFile;
+  const sessionId = randomUUID();
+  bindDiagnosticContext({
+    sessionId,
+    issue: issueNumber,
+    executionId: null,
+    phase: null,
+    story: null,
+    harness: null,
+    model: null
   });
-  const releaseClose = onShutdown({
-    phase: "close",
-    run: async () => {
-      await publisher.close();
-    }
+  const [initialBranch, initialCommit] = await Promise.all([
+    getCurrentBranch().catch(() => ""),
+    getHeadCommit()
+  ]);
+  return {
+    continueNumbering,
+    startUs,
+    executeRetry,
+    tasksPath,
+    sessionId,
+    initialBranch,
+    initialCommit
+  };
+}
+async function resolvePrimaryIssue(issueNumber, queue, issuesConfig) {
+  const resolution = await resolveCommandIssue(issueNumber, queue?.resolved, {
+    config: issuesConfig
+  });
+  if (!resolution.ok) {
+    return { kind: "done", result: failure(resolution.code) };
+  }
+  return { kind: "ok", resolvedIssue: resolution.resolved };
+}
+async function bootstrapThroughIssueResolution(issueNumber, paths, mode, publisher, input) {
+  const { from, noBranch, prReview, queue } = input;
+  const {
+    continueNumbering,
+    startUs,
+    executeRetry,
+    tasksPath,
+    sessionId,
+    initialBranch,
+    initialCommit
+  } = await beginBootstrapLocals(issueNumber, paths, input.runOptions);
+  let publishedIssueNumber = toIssueNumber(issueNumber);
+  const publishSessionStart = (phases, at, info) => {
+    publisher.publish({
+      type: "session:start",
+      at,
+      sessionId,
+      issueNumber: publishedIssueNumber,
+      issueUrl: info?.issueUrl,
+      branch: info?.branch,
+      branchCreated: info?.branchCreated,
+      startCommit: info?.startCommit,
+      phases: [...phases],
+      configuration: configurationSnapshot,
+      environment: {
+        node: process.version,
+        platform: process.platform,
+        agent: agentSummary.defaultProvider,
+        model: agentSummary.defaultModel,
+        cliVersion: getPackageVersion()
+      }
+    });
+  };
+  const { agentSummary, configurationSnapshot } = await buildAgentConfiguration(prReview);
+  printInfo(
+    `Issue Flow v${getPackageVersion()} \xB7 starting pipeline for issue #${issueNumber} (mode: ${mode}, agent: ${agentSummary.label})`
+  );
+  const issuesConfig = await loadIssuesConfig();
+  const initGate = await runInitGate({
+    queue,
+    issuesConfig,
+    publishSessionStart,
+    publisher
   });
+  if (initGate.kind === "done") return initGate;
+  const sessionStartedAt = initGate.sessionStartedAt;
+  const resolved = await resolvePrimaryIssue(issueNumber, queue, issuesConfig);
+  if (resolved.kind === "done") return resolved;
+  const resolvedIssue = resolved.resolvedIssue;
+  publishedIssueNumber = resolvedIssue.issue.number;
+  return {
+    kind: "continue",
+    issueNumber,
+    paths,
+    mode,
+    publisher,
+    input,
+    from,
+    noBranch,
+    prReview,
+    queue,
+    continueNumbering,
+    startUs,
+    executeRetry,
+    tasksPath,
+    sessionId,
+    initialBranch,
+    initialCommit,
+    publishedIssueNumber,
+    publishSessionStart,
+    agentSummary,
+    configurationSnapshot,
+    sessionStartedAt,
+    resolvedIssue
+  };
+}
+
+// src/commands/run/phase-prepare.ts
+async function loadModesAndPhases(input) {
+  const { noBranch, prReview, tasksPath, queue } = input;
+  let persistedFlags = null;
   try {
-    result = await runPipelinePhases(issueNumber, paths, mode, publisher, input);
-    if (result.code !== 0) {
-      await reportIfOversized(issueNumber, paths, result);
+    const existingPlan = await loadTaskPlan(tasksPath);
+    persistedFlags = {
+      noBranch: existingPlan.noBranch ?? false,
+      prReviewEnabled: existingPlan.prReview?.enabled ?? false,
+      issueUrl: existingPlan.issueUrl || void 0,
+      branchName: existingPlan.branchName || void 0,
+      userStories: existingPlan.userStories
+    };
+  } catch {
+  }
+  const modes = resolveBranchAndReviewModes({
+    noBranch,
+    prReview,
+    persisted: persistedFlags
+  });
+  for (const warning of modes.warnings) {
+    printWarning(warning);
+  }
+  const { effectiveNoBranch, effectivePrReview } = modes;
+  const planIssueUrl = modes.planIssueUrl;
+  const planBranch = modes.planBranch;
+  const planStories = modes.planStories;
+  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 {
     }
-    return result;
-  } finally {
-    releaseCheckpoint();
-    releaseClose();
-    if (result.queue === void 0) {
-      publisher.publish({
-        type: "session:end",
-        at: isoNow(),
-        status: result.code === 0 ? "completed" : "failed"
-      });
+  }
+  const inQueue = queue !== void 0;
+  const finalPr = queue?.finalPr;
+  const { activePhases, phaseOrder } = selectPhaseLists({
+    finalPr: finalPr !== void 0,
+    inQueue,
+    effectiveNoBranch,
+    effectivePrReview
+  });
+  return {
+    effectiveNoBranch,
+    effectivePrReview,
+    planIssueUrl,
+    planBranch,
+    planStories,
+    inQueue,
+    finalPr,
+    activePhases,
+    phaseOrder
+  };
+}
+async function openPhaseSession(input) {
+  const {
+    issueNumber,
+    tasksPath,
+    queue,
+    finalPr,
+    effectiveNoBranch,
+    planIssueUrl,
+    planStories,
+    initialBranch,
+    initialCommit,
+    activePhases,
+    sessionStartedAt,
+    resolvedIssue,
+    publisher,
+    publishSessionStart
+  } = input;
+  let planBranch = input.planBranch;
+  const queueCommitScope = queue === void 0 ? void 0 : `issue-${issueNumber}`;
+  let producedBranch = null;
+  const plannedExecutionBranch = planBranch ?? null;
+  const branchExistedBeforeExecution = effectiveNoBranch || planBranch === void 0 || planBranch === null ? null : await localBranchExists(planBranch).catch(() => null);
+  if (queue !== void 0 && finalPr === void 0 && !effectiveNoBranch) {
+    producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
+    if (producedBranch !== null) {
+      planBranch = producedBranch;
     }
-    await publisher.close();
-    writeDiagnostic({
-      level: result.code === 0 ? "info" : "error",
-      message: `Issue Flow session ${result.code === 0 ? "completed" : "failed"}`,
-      context: { code: result.code, failedPhase: result.failedPhase }
-    });
-    await flushDiagnostics();
-    setSessionPublisher(void 0);
   }
+  publishSessionStart(activePhases, sessionStartedAt, {
+    issueUrl: planIssueUrl ?? resolvedIssue.issue.remoteRef ?? void 0,
+    branch: effectiveNoBranch ? initialBranch : planBranch,
+    branchCreated: effectiveNoBranch ? false : branchExistedBeforeExecution === true ? false : null,
+    startCommit: initialCommit
+  });
+  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);
+  return {
+    queueCommitScope,
+    producedBranch,
+    plannedExecutionBranch,
+    branchExistedBeforeExecution,
+    planBranch
+  };
+}
+async function maybeHandoffToQueue(input) {
+  const { queue, issueNumber, requested, resolvedIssue, noBranch, prReview, runOptions } = input;
+  if (queue !== void 0) return null;
+  const decision = await decideQueue({
+    requested: requested ?? [issueNumber],
+    resolved: resolvedIssue,
+    noBranch: noBranch ?? false,
+    prReview: prReview ?? false,
+    runOptions: runOptions ?? {}
+  });
+  if (decision.kind === "stop") {
+    return { kind: "done", result: failure(decision.code) };
+  }
+  if (decision.kind === "queue") {
+    return {
+      kind: "done",
+      result: {
+        ...failure(0),
+        queue: { plan: decision.plan, resumed: decision.resumed, resolved: resolvedIssue }
+      }
+    };
+  }
+  return null;
+}
+async function preparePhaseRun(issueNumber, paths, mode, publisher, input) {
+  const boot = await bootstrapThroughIssueResolution(issueNumber, paths, mode, publisher, input);
+  if (boot.kind === "done") return boot;
+  const {
+    from,
+    noBranch,
+    prReview,
+    queue,
+    continueNumbering,
+    startUs,
+    executeRetry,
+    tasksPath,
+    initialBranch,
+    initialCommit,
+    publishSessionStart,
+    agentSummary,
+    sessionStartedAt,
+    resolvedIssue
+  } = boot;
+  const _publishedIssueNumber = boot.publishedIssueNumber;
+  const handoff = await maybeHandoffToQueue({
+    queue,
+    issueNumber,
+    requested: input.requested,
+    resolvedIssue,
+    noBranch,
+    prReview,
+    runOptions: input.runOptions
+  });
+  if (handoff !== null) return handoff;
+  const modes = await loadModesAndPhases({ noBranch, prReview, tasksPath, queue });
+  const {
+    effectiveNoBranch,
+    effectivePrReview,
+    planIssueUrl,
+    planStories,
+    inQueue,
+    finalPr,
+    activePhases,
+    phaseOrder
+  } = modes;
+  let planBranch = modes.planBranch;
+  const opened = await openPhaseSession({
+    issueNumber,
+    tasksPath,
+    queue,
+    finalPr,
+    effectiveNoBranch,
+    planBranch,
+    planIssueUrl,
+    planStories,
+    initialBranch,
+    initialCommit,
+    activePhases,
+    sessionStartedAt,
+    resolvedIssue,
+    publisher,
+    publishSessionStart
+  });
+  const { queueCommitScope, producedBranch, plannedExecutionBranch, branchExistedBeforeExecution } = opened;
+  planBranch = opened.planBranch;
+  return {
+    kind: "ready",
+    issueNumber,
+    tasksPath,
+    publisher,
+    from,
+    continueNumbering,
+    startUs,
+    executeRetry,
+    initialBranch,
+    agentSummary,
+    resolvedIssue,
+    effectiveNoBranch,
+    effectivePrReview,
+    inQueue,
+    finalPr,
+    activePhases,
+    phaseOrder,
+    queueCommitScope,
+    queue,
+    producedBranch,
+    plannedExecutionBranch,
+    branchExistedBeforeExecution
+  };
 }
+
+// src/commands/run/session.ts
+import { mkdir as mkdir3 } from "fs/promises";
+
+// src/commands/run/oversized.ts
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
 async function reportIfOversized(issueNumber, paths, result) {
   try {
     const journal = `${await readFileIfPresent(paths.rotatedEventsFile)}${await readFileIfPresent(paths.eventsFile)}`;
@@ -1249,7 +2115,7 @@ async function maybeCreateSubIssues(issueNumber, plan, reportFile) {
     printInfo("Nothing left to split: no pending story.");
     return;
   }
-  const { runGenerate } = await import("./generate-PB4L7V5N.js");
+  const { runGenerate } = await import("./generate-JGW5JSKB.js");
   for (const proposal of proposals) {
     const instruction = [
       `Create a sub-issue of #${issueNumber}: ${proposal.title}.`,
@@ -1283,366 +2149,306 @@ async function readFileIfPresent(path) {
     return "";
   }
 }
-async function pauseIssue(tasksFile, issueNumber) {
+
+// src/commands/run/session.ts
+var WRITING_PHASES = /* @__PURE__ */ new Set(["plan", "execute", "pr"]);
+async function ensureRepositoryWritable(phase) {
+  if (!WRITING_PHASES.has(phase)) return;
+  const preflight = await preflightRepository({ intent: "resume-same-phase" });
+  if (preflight.ok) return;
+  for (const line of describePreflight(preflight)) {
+    printError(line);
+  }
+  throw new Error(`The repository is not in a state the ${phase} phase can write to`);
+}
+async function claimRunOwnership(target, detached = false) {
+  let lockFile;
   try {
-    const plan = await loadTaskPlan(tasksFile);
-    await saveTaskPlan(tasksFile, {
-      ...plan,
-      runState: {
-        ...plan.runState ?? {
-          currentPhase: null,
-          attempt: 0,
-          lastHeartbeatAt: null,
-          blockedReason: null,
-          owner: null
-        },
-        status: "paused",
-        lastHeartbeatAt: isoNow()
-      }
-    });
+    lockFile = (await resolveProjectPaths()).runLockFile;
   } catch {
-    printWarning(`Could not write a checkpoint for issue #${issueNumber}.`);
+    return { ok: true, interruptedBy: null, release: async () => {
+    } };
   }
-}
-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 executeRetry = {
-    retryLimit: input.runOptions?.retryLimit,
-    retryForever: input.runOptions?.retryForever
-  };
-  const tasksPath = paths.tasksFile;
-  const sessionId = randomUUID();
-  bindDiagnosticContext({
-    sessionId,
-    issue: issueNumber,
-    executionId: null,
-    phase: null,
-    story: null,
-    harness: null,
-    model: null
-  });
-  const [initialBranch, initialCommit] = await Promise.all([
-    getCurrentBranch().catch(() => ""),
-    getHeadCommit()
-  ]);
-  let publishedIssueNumber = toIssueNumber(issueNumber);
-  const publishSessionStart = (phases, at, info) => {
-    publisher.publish({
-      type: "session:start",
-      at,
-      sessionId,
-      issueNumber: publishedIssueNumber,
-      issueUrl: info?.issueUrl,
-      branch: info?.branch,
-      branchCreated: info?.branchCreated,
-      startCommit: info?.startCommit,
-      phases: [...phases],
-      configuration: configurationSnapshot,
-      environment: {
-        node: process.version,
-        platform: process.platform,
-        agent: agentSummary.defaultProvider,
-        model: agentSummary.defaultModel,
-        cliVersion: getPackageVersion()
+  const result = await acquireRunLock(lockFile, { target, detached });
+  if (!result.ok) return result;
+  return {
+    ok: true,
+    interruptedBy: result.handle.reclaimedFrom,
+    release: () => result.handle.release()
+  };
+}
+async function pauseIssue(tasksFile, issueNumber) {
+  try {
+    const plan = await loadTaskPlan(tasksFile);
+    await saveTaskPlan(tasksFile, {
+      ...plan,
+      runState: {
+        ...plan.runState ?? {
+          currentPhase: null,
+          attempt: 0,
+          lastHeartbeatAt: null,
+          blockedReason: null,
+          owner: null
+        },
+        status: "paused",
+        lastHeartbeatAt: isoNow()
       }
     });
-  };
-  const agentSummary = await describeRunAgents(
-    prReview ? ["prd", "plan", "execute", "review", "pr", "pr-review"] : ["prd", "plan", "execute", "review", "pr"]
-  );
-  const fallbacks = getActiveResilienceConfig().providers?.chain ?? [];
-  const configurationSnapshot = {
-    precedence: ["default", "global", "project", "env", "cli", "step override"],
-    defaultProvider: {
-      value: agentSummary.defaultProvider,
-      source: agentSummary.defaultOrigin.provider
-    },
-    defaultModel: {
-      value: agentSummary.defaultModel,
-      source: agentSummary.defaultOrigin.model
-    },
-    phases: Object.entries(agentSummary.byPhase).map(([phase, resolved]) => ({
-      phase,
-      provider: { value: resolved.provider, source: resolved.origin.provider },
-      model: { value: resolved.model, source: resolved.origin.model }
-    })),
-    fallbacks,
-    overrides: Object.entries(agentSummary.byPhase).filter(
-      ([, resolved]) => resolved.provider !== agentSummary.defaultProvider || resolved.model !== agentSummary.defaultModel
-    ).map(
-      ([phase, resolved]) => `${phase}: ${resolved.provider}${resolved.model ? ` \xB7 ${resolved.model}` : ""}`
-    )
-  };
-  printInfo(
-    `Issue Flow v${getPackageVersion()} \xB7 starting pipeline for issue #${issueNumber} (mode: ${mode}, agent: ${agentSummary.label})`
-  );
-  const issuesConfig = await loadIssuesConfig();
-  const sessionStartedAt = isoNow();
-  if (queue?.preChecked !== true) {
-    if (isVerbose()) {
-      printInfo("Running prerequisite checks...");
-    }
-    const initCode = await runInit(issuesConfig.preferredProvider, { compact: !isVerbose() });
-    if (initCode !== 0) {
-      publishSessionStart(PIPELINE_PHASES, sessionStartedAt);
-      publisher.publish({ type: "phase:start", at: sessionStartedAt, phase: "init" });
+  } catch {
+    printWarning(`Could not write a checkpoint for issue #${issueNumber}.`);
+  }
+}
+async function createSessionPublisher(input) {
+  const { paths, persistSnapshot, journalEnabled, webConfig, maxFileBytes } = input;
+  const surfaces = [];
+  if (persistSnapshot || journalEnabled) {
+    await mkdir3(paths.issueDir, { recursive: true });
+  }
+  if (persistSnapshot) {
+    surfaces.push(
+      new FilePublisher(paths.sessionFile, {
+        logLimit: webConfig.logLimit,
+        includeLogs: webConfig.includeLogs
+      })
+    );
+  }
+  if (journalEnabled) {
+    surfaces.push(
+      new JournalPublisher(paths.eventsFile, paths.rotatedEventsFile, {
+        logLimit: webConfig.logLimit,
+        includeLogs: webConfig.includeLogs,
+        ...maxFileBytes === void 0 ? {} : { maxFileBytes }
+      })
+    );
+  }
+  return surfaces.length === 0 ? new MemoryPublisher() : surfaces.length === 1 ? surfaces[0] : new MultiPublisher(surfaces);
+}
+function registerIssueShutdownHooks(input) {
+  const { paths, issueNumber, publisher } = input;
+  const releaseCheckpoint = onShutdown({
+    phase: "checkpoint",
+    run: async () => {
+      await pauseIssue(paths.tasksFile, issueNumber);
       publisher.publish({
-        type: "phase:end",
+        type: "log",
         at: isoNow(),
-        phase: "init",
-        success: false,
-        error: "Prerequisites not met"
+        level: "warn",
+        message: `Interrupted during issue #${issueNumber}. A checkpoint was saved; resume with \`issue-flow resume ${issueNumber}\`.`
       });
-      printError("Prerequisites not met. Fix the issues above and try again.");
-      return failure(1);
+      publisher.publish({ type: "session:end", at: isoNow(), status: "failed" });
     }
-  }
-  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 }
-      };
+  const releaseClose = onShutdown({
+    phase: "close",
+    run: async () => {
+      await publisher.close();
     }
+  });
+  return { releaseCheckpoint, releaseClose };
+}
+async function closeIssueSession(input) {
+  const { releaseCheckpoint, releaseClose, result, publisher } = input;
+  releaseCheckpoint();
+  releaseClose();
+  if (result.queue === void 0) {
+    publisher.publish({
+      type: "session:end",
+      at: isoNow(),
+      status: result.code === 0 ? "completed" : "failed"
+    });
   }
-  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 {
+  await publisher.close();
+  writeDiagnostic({
+    level: result.code === 0 ? "info" : "error",
+    message: `Issue Flow session ${result.code === 0 ? "completed" : "failed"}`,
+    context: { code: result.code, failedPhase: result.failedPhase }
+  });
+  await flushDiagnostics();
+  setSessionPublisher(void 0);
+}
+async function applySessionSideEffects(input) {
+  const { publisher, interruptedBy, webConfig, restartWeb } = input;
+  if (interruptedBy !== void 0) {
+    publisher.publish({
+      type: "log",
+      at: isoNow(),
+      level: "warn",
+      message: `Previous run interrupted: ${describeRunLockOwner(interruptedBy)}. Its lock was stale and has been taken over.`
+    });
   }
-  if (effectiveNoBranch && effectivePrReview) {
-    printWarning(
-      "This pipeline runs with --no-branch and opens no PR. Skipping the pr-review phase."
+  if (webConfig.enabled) {
+    await ensureWebMonitor(
+      {
+        publisher,
+        port: webConfig.port,
+        host: webConfig.host,
+        refreshSeconds: webConfig.refreshSeconds
+      },
+      { restart: restartWeb === true }
     );
-    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 {
-    }
+}
+async function runIssueSession(issueNumber, mode, input, runPipelinePhases2) {
+  resetAgentInvocationState();
+  const paths = await resolveIssuePaths(issueNumber);
+  try {
+    const project = await resolveProjectPaths();
+    bindDiagnosticContext({
+      project: project.projectId,
+      projectRoot: await getProjectRoot(),
+      issue: issueNumber,
+      sessionId: null,
+      executionId: null,
+      phase: null,
+      story: null,
+      harness: null,
+      model: null
+    });
+  } 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;
-  let plannedExecutionBranch = planBranch ?? null;
-  let branchExistedBeforeExecution = effectiveNoBranch || planBranch === void 0 || planBranch === null ? null : await localBranchExists(planBranch).catch(() => null);
-  if (queue !== void 0 && finalPr === void 0 && !effectiveNoBranch) {
-    producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
-    if (producedBranch !== null) {
-      planBranch = producedBranch;
-    }
+  const resilience = await initResilienceConfig();
+  const configuredInactivity = resilience.watchdog?.inactivityTimeoutMs;
+  if (configuredInactivity !== void 0 && getInactivityTimeout() === void 0) {
+    setInactivityTimeout(configuredInactivity);
   }
-  publishSessionStart(activePhases, sessionStartedAt, {
-    issueUrl: planIssueUrl ?? resolvedIssue.issue.remoteRef ?? void 0,
-    branch: effectiveNoBranch ? initialBranch : planBranch,
-    branchCreated: effectiveNoBranch ? false : branchExistedBeforeExecution === true ? false : null,
-    startCommit: initialCommit
+  const webConfig = await loadWebConfig();
+  const journalEnabled = resilience.journal?.enabled === true;
+  const persistSnapshot = webConfig.enabled || input.runOptions?.detachedChild === true;
+  const publisher = await createSessionPublisher({
+    paths,
+    persistSnapshot,
+    journalEnabled,
+    webConfig,
+    maxFileBytes: resilience.journal?.maxFileBytes
   });
-  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 {
+  setSessionPublisher(publisher);
+  await applySessionSideEffects({
+    publisher,
+    interruptedBy: input.interruptedBy,
+    webConfig,
+    restartWeb: input.restartWeb
+  });
+  let result = {
+    code: 1,
+    failedPhase: null,
+    branchName: null,
+    storyCount: 0,
+    elapsedSeconds: 0
+  };
+  const { releaseCheckpoint, releaseClose } = registerIssueShutdownHooks({
+    paths,
+    issueNumber,
+    publisher
+  });
+  try {
+    result = await runPipelinePhases2(issueNumber, paths, mode, publisher, input);
+    if (result.code !== 0) {
+      await reportIfOversized(issueNumber, paths, result);
     }
+    return result;
+  } finally {
+    await closeIssueSession({ releaseCheckpoint, releaseClose, result, publisher });
   }
-  if (from) {
+}
+
+// src/commands/run/phase-runners.ts
+function createPlanRunner(input, makeRunner) {
+  const {
+    issueNumber,
+    tasksPath,
+    publisher,
+    resolvedIssue,
+    queue,
+    continueNumbering,
+    startUs,
+    effectiveNoBranch,
+    effectivePrReview,
+    initialBranch,
+    branchState
+  } = input;
+  return async () => {
+    await makeRunner(
+      () => runPlan(issueNumber, resolvedIssue, {
+        continueFlag: continueNumbering,
+        startUs,
+        ...effectiveNoBranch && initialBranch ? { branchName: initialBranch } : {}
+      }),
+      "plan"
+    )();
     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);
+      if (!effectiveNoBranch) {
+        branchState.plannedExecutionBranch = plan.branchName;
+        branchState.branchExistedBeforeExecution = await localBranchExists(plan.branchName).catch(
+          () => null
+        );
+        publisher.publish({
+          type: "git:update",
+          at: isoNow(),
+          branchCreated: branchState.branchExistedBeforeExecution === true ? false : null
+        });
       }
-    }
-  }
-  const startIdx = Math.max(phaseOrder.indexOf(startPhase), 0);
-  const makeRunner = (fn, phase) => async () => {
-    await ensureRepositoryWritable(phase);
-    const code = await fn();
-    if (code !== 0) {
-      throw new Error(`Phase ${phase} failed with exit code ${code}`);
+      publishStorySeed(publisher, plan.userStories, isoNow());
+      if (effectiveNoBranch || effectivePrReview) {
+        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) {
+      branchState.producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
     }
   };
-  const runners = {
-    prd: makeRunner(() => runPrd(issueNumber, resolvedIssue), "prd"),
-    plan: async () => {
-      await makeRunner(
-        () => runPlan(issueNumber, resolvedIssue, {
-          continueFlag: continueNumbering,
-          startUs,
-          ...effectiveNoBranch && initialBranch ? { branchName: initialBranch } : {}
-        }),
-        "plan"
-      )();
+}
+function createReviewRunner(input) {
+  const { issueNumber, tasksPath, publisher, resolvedIssue, queueCommitScope, executeRetry } = input;
+  return 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);
-        if (!effectiveNoBranch) {
-          plannedExecutionBranch = plan.branchName;
-          branchExistedBeforeExecution = await localBranchExists(plan.branchName).catch(() => null);
-          publisher.publish({
-            type: "git:update",
-            at: isoNow(),
-            branchCreated: branchExistedBeforeExecution === true ? false : null
-          });
-        }
-        publishStorySeed(publisher, plan.userStories, isoNow());
-        if (effectiveNoBranch || effectivePrReview) {
-          if (effectiveNoBranch) plan.noBranch = true;
-          if (effectivePrReview) {
-            plan.prReview = { ...plan.prReview, enabled: true, rounds: plan.prReview?.rounds ?? 0 };
-          }
-          await saveTaskPlan(tasksPath, plan);
-        }
+        plan.correctionCycle = cycle;
+        await saveTaskPlan(tasksPath, plan);
       } catch {
       }
-      if (queue !== void 0 && !effectiveNoBranch) {
-        producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
-      }
-    },
-    execute: makeRunner(
-      () => runExecute(void 0, {
+      const execCode = await runExecute(void 0, {
         issue: issueNumber,
         commitScope: queueCommitScope,
         ...executeRetry
-      }),
-      "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,
-          ...executeRetry
-        });
-        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`);
+      });
+      if (execCode !== 0) {
+        throw new Error("Correction execution failed");
       }
-    },
-    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"
-    )
+      code = await runReview(issueNumber, resolvedIssue);
+    }
+    if (code !== 0) {
+      throw new Error(`Review failed after ${maxCycles} correction cycles`);
+    }
   };
-  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(
+}
+function instrumentPhaseRunners(runners, input) {
+  const { publisher, issueNumber, branchState } = input;
+  return Object.fromEntries(
     Object.entries(runners).map(([phase, fn]) => [
       phase,
       async () => {
         publisher.publish({ type: "phase:start", at: isoNow(), phase });
         try {
           await fn();
-          if (phase === "execute" && branchExistedBeforeExecution === false && plannedExecutionBranch !== null && await getCurrentBranch().catch(() => "") === plannedExecutionBranch) {
+          if (phase === "execute" && branchState.branchExistedBeforeExecution === false && branchState.plannedExecutionBranch !== null && await getCurrentBranch().catch(() => "") === branchState.plannedExecutionBranch) {
             publisher.publish({ type: "git:update", at: isoNow(), branchCreated: true });
           }
           await publishGitState(publisher);
@@ -1661,447 +2467,257 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
       }
     ])
   );
-  const phaseSuffixes = {};
-  for (const [phase, resolved] of Object.entries(agentSummary.byPhase)) {
-    if (resolved.provider !== agentSummary.defaultProvider) {
-      phaseSuffixes[phase] = resolved.model ? `${resolved.provider} \xB7 ${resolved.model}` : resolved.provider;
-    }
-  }
-  const result = await runPipelineWithRenderer({
-    phases: phaseOrder,
-    startIndex: startIdx,
-    verbose: isVerbose(),
-    runners: instrumentedRunners,
-    tasksPath,
-    phaseSuffixes
-  });
-  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(),
-    verification: verificationForSummary(getSessionPublisher().snapshot().verification)
-  });
-  return {
-    code: 0,
-    failedPhase: null,
-    branchName: branchName === "unknown" ? null : branchName,
-    storyCount,
-    elapsedSeconds: result.overallElapsedSeconds
-  };
-}
-async function detachAfterConfirm(requested, noBranch, prReview, options) {
-  const childFlags = [...process.argv.slice(2)];
-  if (options.yes !== true && options.only !== true) {
-    try {
-      const issuesConfig = await loadIssuesConfig();
-      const resolution = await resolveCommandIssue(requested[0], void 0, {
-        config: issuesConfig
-      });
-      if (resolution.ok) {
-        const decision = await decideQueue({
-          requested,
-          resolved: resolution.resolved,
-          noBranch: noBranch ?? false,
-          prReview: prReview ?? false,
-          runOptions: options
-        });
-        if (decision.kind === "stop") return decision.code;
-        if (decision.kind === "queue" && !childFlags.includes("--yes")) childFlags.push("--yes");
-        if (decision.kind === "single" && !childFlags.includes("--only")) childFlags.push("--only");
-      }
-    } catch {
-    }
-  }
-  const paths = await resolveIssuePaths(requested[0]);
-  const { pid, logFile } = await spawnDetachedRun({ paths, argv: childFlags });
-  printSuccess(`Detached run started (pid ${pid}).`);
-  printInfo(`Log: ${logFile}`);
-  printInfo("Follow with: issue-flow ps");
-  printInfo(`Stop with: kill ${pid}`);
-  return 0;
-}
-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,
-        cascade: input.runOptions.cascade
-      }
-    });
-  } 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;
-  const resilience = getActiveResilienceConfig();
-  const failureMode = options.runOptions?.onIssueFailure ?? resilience.queue?.onIssueFailure ?? "stop";
-  const maxIssueAttempts = resilience.queue?.maxIssueAttempts ?? DEFAULT_MAX_ISSUE_ATTEMPTS;
-  const exhausted = /* @__PURE__ */ new Set();
-  const failedIds = /* @__PURE__ */ new Set();
-  try {
-    while (true) {
-      const entry = nextQueueIssue(plan, { exclude: exhausted });
-      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) {
-        const failure2 = {
-          phase: result.failedPhase,
-          error: {
-            category: "queue_issue_failed",
-            message: `Issue #${entry.id} failed${result.failedPhase === null ? "" : ` in phase ${result.failedPhase}`}`,
-            at: isoNow()
-          }
-        };
-        const where = result.failedPhase === null ? "" : ` (phase ${result.failedPhase})`;
-        if (failureMode === "stop") {
-          plan = markQueueIssueFailed(plan, entry.id, failure2);
-          await saveExecutionPlan(planFile, plan);
-          printError(
-            `Queue stopped at issue #${entry.id}${where}. The branch and every commit made so far were kept.`
-          );
-          printInfo(`Resume with: issue-flow run ${plan.requested.join(",")}`);
-          return result.code;
-        }
-        if (failureMode === "block") {
-          plan = markQueueIssueBlocked(
-            plan,
-            entry.id,
-            `Failed${where} and --on-issue-failure block was in force`,
-            failure2
-          );
-          await saveExecutionPlan(planFile, plan);
-          exhausted.add(entry.id);
-          failedIds.add(entry.id);
-          printWarning(
-            `Issue #${entry.id} failed${where} and is blocked for review. Continuing with the rest of the queue.`
-          );
-          continue;
-        }
-        const attempts = entry.attempts + 1;
-        if (attempts >= maxIssueAttempts) {
-          plan = markQueueIssueFailed(plan, entry.id, failure2);
-          exhausted.add(entry.id);
-          failedIds.add(entry.id);
-          printWarning(
-            `Issue #${entry.id} failed${where} after ${attempts} attempt(s). Continuing with the rest of the queue.`
-          );
-        } else {
-          plan = markQueueIssueSkipped(plan, entry.id, failure2);
-          printWarning(
-            `Issue #${entry.id} failed${where}. Skipping it for now and coming back at the end of the queue.`
-          );
-        }
-        await saveExecutionPlan(planFile, plan);
-        continue;
-      }
-      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
-      });
-    }
-    const code = await finishQueue(
-      plan,
-      planFile,
-      summaries,
-      startedAtMs,
-      queueUsage,
-      options,
-      resolvedPrimary
-    );
-    if (failedIds.size > 0) {
-      printError(
-        `${failedIds.size} issue(s) did not finish: ${[...failedIds].map((id) => `#${id}`).join(", ")}.`
-      );
-      printInfo(`Resume with: issue-flow run ${plan.requested.join(",")}`);
-      return code === 0 ? 1 : code;
+function buildInstrumentedPhaseRunners(input) {
+  const {
+    issueNumber,
+    tasksPath,
+    publisher,
+    resolvedIssue,
+    finalPr,
+    executeRetry,
+    effectivePrReview,
+    queueCommitScope,
+    branchState
+  } = input;
+  const makeRunner = (fn, phase) => async () => {
+    await ensureRepositoryWritable(phase);
+    const code = await fn();
+    if (code !== 0) {
+      throw new Error(`Phase ${phase} failed with exit code ${code}`);
     }
-    return code;
-  } finally {
-    queueUsage.end();
+  };
+  const runners = {
+    prd: makeRunner(() => runPrd(issueNumber, resolvedIssue), "prd"),
+    plan: createPlanRunner(input, makeRunner),
+    execute: makeRunner(
+      () => runExecute(void 0, {
+        issue: issueNumber,
+        commitScope: queueCommitScope,
+        ...executeRetry
+      }),
+      "execute"
+    ),
+    review: createReviewRunner(input),
+    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 = instrumentPhaseRunners(runners, {
+    publisher,
+    issueNumber,
+    branchState
+  });
+  return { instrumentedRunners, reviewBox };
 }
-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)
+
+// src/commands/run/phase-start.ts
+async function resolveStartPhase(input) {
+  const { from, activePhases, effectiveNoBranch, tasksPath } = input;
+  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}`);
       }
-    });
-    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);
+      return { ok: false };
     }
-  }
-  await saveExecutionPlan(planFile, current);
-  if (review?.requestedChanges === true) {
-    printInfo("Issues left open until the review blockers are addressed.");
+    startPhase = from;
   } 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`);
+      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 {
     }
   }
-  return {
-    issues: plan.issues.map((entry) => ({
-      id: entry.id,
-      number: entry.number,
-      title: entry.title,
-      url: entry.url,
-      source: entry.source,
-      parent: entry.parent,
-      role: entry.role,
-      complete: entry.status === "completed"
-    })),
-    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;
+  if (from) {
     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);
+      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 { ok: false };
+      }
     } catch {
-      printWarning(`Could not record the Pull Request on issue #${entry.id}'s task plan.`);
+      if (startPhase !== "prd") {
+        printError(`Cannot resume from ${startPhase}: no pipeline state found`);
+        return { ok: false };
+      }
     }
   }
-  return pullRequest;
+  return { ok: true, startPhase };
 }
-function failure(code) {
-  return { code, failedPhase: null, branchName: null, storyCount: 0, elapsedSeconds: 0 };
+
+// src/commands/run/phases.ts
+async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
+  const prepared = await preparePhaseRun(issueNumber, paths, mode, publisher, input);
+  if (prepared.kind === "done") {
+    return prepared.result;
+  }
+  const {
+    tasksPath,
+    from,
+    continueNumbering,
+    startUs,
+    executeRetry,
+    initialBranch,
+    agentSummary,
+    resolvedIssue,
+    effectiveNoBranch,
+    effectivePrReview,
+    inQueue,
+    finalPr,
+    activePhases,
+    phaseOrder,
+    queueCommitScope,
+    queue
+  } = prepared;
+  let { producedBranch, plannedExecutionBranch, branchExistedBeforeExecution } = prepared;
+  const startResolved = await resolveStartPhase({
+    from,
+    activePhases,
+    effectiveNoBranch,
+    tasksPath
+  });
+  if (!startResolved.ok) {
+    return failure(1);
+  }
+  const startPhase = startResolved.startPhase;
+  const startIdx = Math.max(phaseOrder.indexOf(startPhase), 0);
+  const branchState = {
+    producedBranch,
+    plannedExecutionBranch,
+    branchExistedBeforeExecution
+  };
+  const { instrumentedRunners, reviewBox } = buildInstrumentedPhaseRunners({
+    issueNumber,
+    tasksPath,
+    publisher,
+    resolvedIssue,
+    queue,
+    finalPr,
+    continueNumbering,
+    startUs,
+    executeRetry,
+    effectiveNoBranch,
+    effectivePrReview,
+    initialBranch,
+    queueCommitScope,
+    branchState
+  });
+  const phaseSuffixes = phaseSuffixesFor(agentSummary);
+  const result = await runPipelineWithRenderer({
+    phases: phaseOrder,
+    startIndex: startIdx,
+    verbose: isVerbose(),
+    runners: instrumentedRunners,
+    tasksPath,
+    phaseSuffixes
+  });
+  producedBranch = branchState.producedBranch;
+  plannedExecutionBranch = branchState.plannedExecutionBranch;
+  branchExistedBeforeExecution = branchState.branchExistedBeforeExecution;
+  if (!result.success) {
+    printError(`Phase ${result.failedPhase} failed`);
+    return {
+      ...failure(1),
+      failedPhase: result.failedPhase ?? null,
+      branchName: producedBranch,
+      elapsedSeconds: result.overallElapsedSeconds
+    };
+  }
+  return finalizeSuccessfulIssueRun({
+    issueNumber,
+    tasksPath,
+    resolvedIssue,
+    review: reviewBox.outcome,
+    inQueue,
+    finalPr,
+    producedBranch,
+    effectiveNoBranch,
+    elapsedSeconds: result.overallElapsedSeconds
+  });
 }
-async function closeIssue(issueNumber, source) {
-  try {
-    const provider = getProvider(source);
-    if (provider.close !== void 0) {
-      printInfo("Closing issue...");
-      await provider.close(issueNumber);
+function phaseSuffixesFor(agentSummary) {
+  const phaseSuffixes = {};
+  for (const [phase, resolved] of Object.entries(agentSummary.byPhase)) {
+    if (resolved.provider !== agentSummary.defaultProvider) {
+      phaseSuffixes[phase] = resolved.model ? `${resolved.provider} \xB7 ${resolved.model}` : resolved.provider;
     }
-  } catch {
-    printWarning("Failed to close issue automatically");
   }
+  return phaseSuffixes;
 }
-async function adoptQueueBranch(tasksPath, queueBranch) {
+
+// src/commands/run.ts
+var runIssueSession2 = (issueNumber, mode, input) => runIssueSession(issueNumber, mode, input, runPipelinePhases);
+async function runPipeline(issue, mode, from, noBranch, prReview, options = {}) {
+  let requested;
   try {
-    const plan = await loadTaskPlan(tasksPath);
-    if (queueBranch === null || queueBranch === "") {
-      return plan.branchName === "" ? null : plan.branchName;
+    requested = parseIssueArguments(typeof issue === "string" ? [issue] : issue);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (options.background === true && options.detachedChild !== true) {
+    const reason = backgroundRejection(mode);
+    if (reason !== null) {
+      printError(reason);
+      return 1;
     }
-    if (plan.branchName !== queueBranch) {
-      plan.branchName = queueBranch;
-      await saveTaskPlan(tasksPath, plan);
+    return detachAfterConfirm(requested, noBranch, prReview, options);
+  }
+  const ownership = await claimRunOwnership(requested[0], options.detachedChild === true);
+  if (!ownership.ok) {
+    printError(
+      `Another issue-flow run owns this project: ${describeRunLockOwner(ownership.owner)}.`
+    );
+    printInfo("Wait for it to finish, or stop that process before running again.");
+    return 1;
+  }
+  try {
+    const first = await runIssueSession2(requested[0], mode, {
+      from,
+      noBranch,
+      prReview,
+      requested,
+      runOptions: options,
+      restartWeb: options.restartWeb,
+      ...ownership.interruptedBy === null ? {} : { interruptedBy: ownership.interruptedBy }
+    });
+    if (first.queue === void 0) {
+      return first.code;
     }
-    return queueBranch;
-  } catch {
-    return queueBranch;
+    return runQueue(
+      first.queue.plan,
+      { mode, from, noBranch, prReview, runOptions: options },
+      first.queue.resolved,
+      runIssueSession2
+    );
+  } finally {
+    await ownership.release();
   }
 }
 
@@ -2110,4 +2726,4 @@ export {
   publishIssueDetails,
   runPipeline
 };
-//# sourceMappingURL=chunk-OLUOZLU5.js.map
+//# sourceMappingURL=chunk-CWSQVHVV.js.map