issue-flow 0.11.1 → 0.13.0

package/dist/{run-DBF2VWUN.js → chunk-OPNGPUKJ.js}

@@ -1,580 +1,209 @@
 #!/usr/bin/env node
 import {
-  mostRecent,
-  prReviewDir,
-  readPrReviewIndex,
-  runPrReview
-} from "./chunk-KQ4JQN7T.js";
-import {
-  runPrd
-} from "./chunk-IVHZEYAX.js";
+  formatPhaseLine,
+  loadPhaseTiming,
+  snapshotTimingFields
+} from "./chunk-37N2RJW2.js";
 import {
   runReview
-} from "./chunk-34WNTK3K.js";
+} from "./chunk-QXDNBYQF.js";
 import {
-  ensureWebMonitor
-} from "./chunk-GANSDJV7.js";
+  PIPELINE_PHASES,
+  PIPELINE_PHASES_NO_BRANCH,
+  PIPELINE_PHASES_WITH_PR_REVIEW,
+  PipelineManager,
+  buildDependencyGraph,
+  buildExecutionPlan,
+  collectCascadeIds,
+  computeExecutionOrder,
+  describeCycles,
+  isQueueComplete,
+  loadExecutionPlan,
+  markQueueIssueBlocked,
+  markQueueIssueCompleted,
+  markQueueIssueFailed,
+  markQueueIssueInProgress,
+  markQueueIssueSkipped,
+  nextQueueIssue,
+  saveExecutionPlan,
+  setQueueBranch,
+  setQueuePullRequest
+} from "./chunk-7KD66LIM.js";
 import {
   runInit
-} from "./chunk-RKTEV6EG.js";
+} from "./chunk-BHJCGWQX.js";
 import {
   printQueueSummary,
   printRunSummary,
-  runExecute
-} from "./chunk-6N7LZZ5U.js";
+  runExecute,
+  stripMarkdown
+} from "./chunk-LZ6GFQAG.js";
 import {
-  listPullRequests,
-  publishGitState
-} from "./chunk-LVKQ2AKT.js";
+  ensureWebMonitor
+} from "./chunk-IHIEXUTC.js";
 import {
   runPlan
-} from "./chunk-EY6WMHV2.js";
+} from "./chunk-TM67EHSV.js";
 import {
   runPr
-} from "./chunk-BXCPXRBR.js";
-import "./chunk-3BOHTH4V.js";
+} from "./chunk-PIVGJM6K.js";
+import {
+  mostRecent,
+  prReviewDir,
+  readPrReviewIndex,
+  runPrReview
+} from "./chunk-UJ7XWK7J.js";
+import {
+  listPullRequests,
+  publishGitState
+} from "./chunk-J62QSVP6.js";
+import {
+  runPrd
+} from "./chunk-HJGGNLWI.js";
+import {
+  resolveCommandIssue
+} from "./chunk-FZDR7CGH.js";
 import {
-  emptyRelations,
-  getProvider,
-  resolveCommandIssue,
-  uniqueIds
-} from "./chunk-AAY6KM7N.js";
-import "./chunk-EWDJENFW.js";
-import "./chunk-HDV3YDTG.js";
+  getProvider
+} from "./chunk-PV4OX5TC.js";
 import {
   beginUsageScope,
   getRunUsageTotals
-} from "./chunk-OBLVLIUS.js";
-import "./chunk-HQYXVIH6.js";
-import "./chunk-47VIN33V.js";
+} from "./chunk-664Y3NDX.js";
 import {
-  executionPlanSchema,
+  assessDecomposition,
+  buildDecompositionReport,
+  proposeSubIssues,
+  resetAgentInvocationState
+} from "./chunk-ARFVHC2F.js";
+import {
+  JournalPublisher,
+  MultiPublisher
+} from "./chunk-QCXPNSEL.js";
+import {
+  describeRunAgents,
+  getActiveResilienceConfig,
+  initResilienceConfig,
   loadIssuesConfig,
   loadWebConfig,
+  onShutdown
+} from "./chunk-CNBYCMSU.js";
+import {
   resolveIssuePaths,
   resolveProjectPaths,
   resolveQueuePaths
-} from "./chunk-VQ5VN7DF.js";
+} from "./chunk-HQAHNIAR.js";
 import {
   FilePublisher,
-  NullPublisher,
+  MemoryPublisher,
+  formatDuration,
+  getIcons,
+  getInactivityTimeout,
+  getSessionPublisher,
   isVerbose,
-  isoNow,
-  loadTaskPlan,
   printError,
   printInfo,
   printSuccess,
   printWarning,
-  saveTaskPlan,
+  setActivityCallback,
+  setInactivityTimeout,
   setOutputCallback,
   setSessionPublisher,
   setStoryStageCallback,
-  setStoryUpdateCallback,
-  writeFileAtomic
-} from "./chunk-HC2MT7BX.js";
+  setStoryUpdateCallback
+} from "./chunk-IYV6KNVF.js";
+import {
+  isoNow,
+  loadTaskPlan,
+  saveTaskPlan
+} from "./chunk-DIG5XKQQ.js";
+import {
+  acquireRunLock,
+  describeRunLockOwner
+} from "./chunk-NEZZ6KDR.js";
+import {
+  committedStoryIds,
+  describePreflight,
+  getBaseBranch,
+  preflightRepository,
+  run
+} from "./chunk-KQHB7ZT3.js";
 
 // src/commands/run.ts
 import { randomUUID } from "crypto";
-import { mkdir as mkdir2 } from "fs/promises";
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { execa } from "execa";
 
-// src/core/pipeline.ts
-var PIPELINE_PHASES = ["init", "prd", "plan", "execute", "review", "pr"];
-var PIPELINE_PHASES_WITH_PR_REVIEW = [...PIPELINE_PHASES, "pr-review"];
-var PIPELINE_PHASES_NO_BRANCH = PIPELINE_PHASES.filter(
-  (p) => p !== "pr"
-);
-var PHASE_TO_FIELD = {
-  init: null,
-  prd: "prdCompleted",
-  plan: "jsonCompleted",
-  execute: "executionCompleted",
-  review: "reviewCompleted",
-  pr: "prCreated",
-  "pr-review": "prReviewCompleted"
-};
-var PipelineManager = class {
-  tasksJsonPath;
-  plan;
-  activePhases;
-  constructor(plan, tasksJsonPath, activePhases) {
-    this.plan = plan;
-    this.tasksJsonPath = tasksJsonPath;
-    this.activePhases = activePhases ?? PIPELINE_PHASES;
-  }
-  /**
-   * Reload state from disk.
-   */
-  async reload() {
-    this.plan = await loadTaskPlan(this.tasksJsonPath);
-  }
-  /**
-   * Check if a phase is complete.
-   */
-  isPhaseComplete(phase) {
-    const field = PHASE_TO_FIELD[phase];
-    if (field === null) return true;
-    return this.plan.pipeline?.[field] ?? false;
-  }
-  /**
-   * Get the first incomplete phase in the pipeline.
-   * Returns null if all phases are complete.
-   */
-  getNextPhase() {
-    for (const phase of this.activePhases) {
-      if (!this.isPhaseComplete(phase)) {
-        return phase;
-      }
-    }
-    return null;
-  }
-  /**
-   * Get the current phase (alias for getNextPhase).
-   */
-  getCurrentPhase() {
-    return this.getNextPhase();
-  }
-  /**
-   * Check whether we can resume from a specific phase.
-   * All prerequisite phases must be complete.
-   */
-  canResume(fromPhase) {
-    const idx = this.activePhases.indexOf(fromPhase);
-    if (idx < 0) return false;
-    for (let i = 0; i < idx; i++) {
-      if (!this.isPhaseComplete(this.activePhases[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Mark a phase as complete and persist to disk.
-   */
-  async markPhaseComplete(phase) {
-    const field = PHASE_TO_FIELD[phase];
-    if (field === null) return;
-    this.plan = {
-      ...this.plan,
-      pipeline: {
-        ...this.plan.pipeline ?? {
-          prdCompleted: false,
-          jsonCompleted: false,
-          executionCompleted: false,
-          reviewCompleted: false,
-          prCreated: false
-        },
-        [field]: true
-      }
-    };
-    await saveTaskPlan(this.tasksJsonPath, this.plan);
-  }
-};
-
-// src/execution/plan.ts
-import { mkdir, readFile } from "fs/promises";
+// src/execution/detach.ts
+import { spawn } from "child_process";
+import { mkdir, open } from "fs/promises";
 import { dirname } from "path";
-import { ZodError } from "zod";
 
-// src/issues/graph.ts
-var DEFAULT_MAX_NODES = 25;
-var DEFAULT_MAX_DEPTH = 3;
-function dependencyEdges(graph) {
-  const edges = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (from, to) => {
-    if (from === to || !graph.nodes.has(from) || !graph.nodes.has(to)) return;
-    const key = `${from}->${to}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    edges.push({ from, to });
-  };
-  for (const node of graph.nodes.values()) {
-    for (const blocker of node.relations.blockedBy) {
-      add(blocker, node.id);
-    }
-    for (const blocked of node.relations.blocking) {
-      add(node.id, blocked);
-    }
-  }
-  return edges;
-}
-function findCycles(graph) {
-  const adjacency = /* @__PURE__ */ new Map();
-  for (const { from, to } of dependencyEdges(graph)) {
-    const list = adjacency.get(from);
-    if (list === void 0) {
-      adjacency.set(from, [to]);
-    } else {
-      list.push(to);
-    }
-  }
-  const cycles = [];
-  const reported = /* @__PURE__ */ new Set();
-  const state = /* @__PURE__ */ new Map();
-  const stack = [];
-  const record = (cycle) => {
-    let pivot = 0;
-    for (let i = 1; i < cycle.length; i++) {
-      if (compareIds(cycle[i], cycle[pivot]) < 0) pivot = i;
-    }
-    const normalized = [...cycle.slice(pivot), ...cycle.slice(0, pivot)];
-    const key = normalized.join("->");
-    if (reported.has(key)) return;
-    reported.add(key);
-    cycles.push(normalized);
-  };
-  const visit = (id) => {
-    state.set(id, "visiting");
-    stack.push(id);
-    for (const next of adjacency.get(id) ?? []) {
-      const status = state.get(next);
-      if (status === "visiting") {
-        record(stack.slice(stack.indexOf(next)));
-        continue;
-      }
-      if (status === void 0) {
-        visit(next);
-      }
-    }
-    stack.pop();
-    state.set(id, "done");
-  };
-  for (const id of graph.nodes.keys()) {
-    if (!state.has(id)) visit(id);
-  }
-  return cycles;
-}
-function compareIds(a, b) {
-  const na = Number(a);
-  const nb = Number(b);
-  if (Number.isInteger(na) && Number.isInteger(nb)) {
-    return na - nb;
+// src/storage/run-log.ts
+import { rename, stat } from "fs/promises";
+var DEFAULT_RUN_LOG_MAX_BYTES = 5 * 1024 * 1024;
+async function rotateRunLogIfNeeded(filePath, rotatedPath, maxBytes = DEFAULT_RUN_LOG_MAX_BYTES) {
+  if (maxBytes <= 0) return;
+  try {
+    const size = (await stat(filePath)).size;
+    if (size < maxBytes) return;
+  } catch {
+    return;
   }
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function neighbours(relations) {
-  return uniqueIds(
-    [
-      ...relations.parent === null ? [] : [relations.parent],
-      ...relations.children,
-      ...relations.blockedBy,
-      ...relations.blocking
-    ],
-    relations.id
-  );
-}
-async function buildDependencyGraph(roots, fetchRelations, options = {}) {
-  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
-  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
-  const warn = options.warn ?? (() => {
-  });
-  const known = /* @__PURE__ */ new Map();
-  for (const issue of options.known ?? []) {
-    known.set(issue.id, issue);
-  }
-  const rootIds = uniqueIds(roots);
-  const nodes = /* @__PURE__ */ new Map();
-  const queued = new Set(rootIds);
-  let truncated = false;
-  let frontier = rootIds.map((id) => ({ id, depth: 0 }));
-  while (frontier.length > 0) {
-    const next = [];
-    for (const { id, depth } of frontier) {
-      if (nodes.size >= maxNodes) {
-        truncated = true;
-        break;
-      }
-      let relations = null;
-      try {
-        relations = await fetchRelations(id);
-      } catch (err) {
-        warn(
-          `Could not read the relations of issue '${id}': ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-      let issue = known.get(id) ?? null;
-      if (issue === null && options.fetchIssue !== void 0) {
-        try {
-          issue = await options.fetchIssue(id);
-        } catch (err) {
-          warn(`Could not read issue '${id}': ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-      const resolved = relations ?? emptyRelations(id);
-      nodes.set(id, { id, relations: resolved, depth, issue, root: rootIds.includes(id) });
-      if (depth >= maxDepth) {
-        if (neighbours(resolved).some((neighbour) => !queued.has(neighbour))) {
-          truncated = true;
-        }
-        continue;
-      }
-      for (const neighbour of neighbours(resolved)) {
-        if (queued.has(neighbour)) continue;
-        queued.add(neighbour);
-        next.push({ id: neighbour, depth: depth + 1 });
-      }
-    }
-    if (nodes.size >= maxNodes && next.length > 0) {
-      truncated = true;
-      break;
-    }
-    frontier = next;
-  }
-  const graph = {
-    roots: rootIds,
-    nodes,
-    cycles: [],
-    truncated,
-    limits: { maxNodes, maxDepth }
-  };
-  linkReferencedBy(graph);
-  graph.cycles = findCycles(graph);
-  return graph;
-}
-function linkReferencedBy(graph) {
-  for (const node of graph.nodes.values()) {
-    for (const cited of node.relations.references) {
-      const target = graph.nodes.get(cited);
-      if (target === void 0 || target.id === node.id) continue;
-      target.relations.referencedBy = uniqueIds(
-        [...target.relations.referencedBy, node.id],
-        target.id
-      );
-    }
+  try {
+    await rename(filePath, rotatedPath);
+  } catch {
   }
 }
 
-// src/execution/order.ts
-var PRIORITY_LABELS = {
-  high: "high",
-  medium: "medium",
-  low: "low"
-};
-var PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
-var NO_PRIORITY_RANK = 3;
-function priorityOf(labels) {
-  for (const label of labels) {
-    const normalized = label.trim().toLowerCase();
-    const direct = PRIORITY_LABELS[normalized];
-    if (direct !== void 0) return direct;
-    const qualified = /^(?:priority|prio|p)\s*[:/-]\s*(high|medium|low)$/.exec(normalized);
-    const matched = qualified?.[1];
-    if (matched !== void 0) return PRIORITY_LABELS[matched];
+// src/execution/detach.ts
+function backgroundRejection(mode, env = process.env) {
+  if (mode === "manual") {
+    return "--background cannot be used with --mode manual: a detached run cannot answer prompts.";
   }
-  return null;
-}
-function hierarchyDepth(id, parentOf, selected) {
-  let depth = 0;
-  let current = parentOf.get(id) ?? null;
-  const seen = /* @__PURE__ */ new Set([id]);
-  while (current !== null && selected.has(current) && !seen.has(current)) {
-    depth++;
-    seen.add(current);
-    current = parentOf.get(current) ?? null;
-  }
-  return depth;
-}
-function computeExecutionOrder(graph, options = {}) {
-  const selected = new Set(
-    (options.include ?? [...graph.nodes.keys()]).filter((id) => graph.nodes.has(id))
-  );
-  const parentOf = /* @__PURE__ */ new Map();
-  const priority = /* @__PURE__ */ new Map();
-  for (const id of selected) {
-    const node = graph.nodes.get(id);
-    parentOf.set(id, node?.relations.parent ?? null);
-    priority.set(id, priorityOf(node?.issue?.labels ?? []));
-  }
-  const incoming = /* @__PURE__ */ new Map();
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const id of selected) {
-    incoming.set(id, /* @__PURE__ */ new Set());
-    outgoing.set(id, []);
-  }
-  for (const { from, to } of dependencyEdges(graph)) {
-    if (!selected.has(from) || !selected.has(to) || from === to) continue;
-    incoming.get(to)?.add(from);
-    outgoing.get(from)?.push(to);
-  }
-  const depth = /* @__PURE__ */ new Map();
-  for (const id of selected) {
-    depth.set(id, hierarchyDepth(id, parentOf, selected));
-  }
-  const rank = (id) => {
-    const value = priority.get(id) ?? null;
-    return value === null ? NO_PRIORITY_RANK : PRIORITY_RANK[value];
-  };
-  const better = (a, b) => {
-    const byHierarchy = (depth.get(a) ?? 0) - (depth.get(b) ?? 0);
-    if (byHierarchy !== 0) return byHierarchy;
-    const byPriority = rank(a) - rank(b);
-    if (byPriority !== 0) return byPriority;
-    return compareIds(a, b);
-  };
-  const ready = [...selected].filter((id) => (incoming.get(id)?.size ?? 0) === 0);
-  const order = [];
-  while (ready.length > 0) {
-    ready.sort(better);
-    const next = ready.shift();
-    order.push(next);
-    for (const dependent of outgoing.get(next) ?? []) {
-      const pending = incoming.get(dependent);
-      if (pending === void 0) continue;
-      pending.delete(next);
-      if (pending.size === 0) {
-        ready.push(dependent);
-      }
-    }
-  }
-  if (order.length !== selected.size) {
-    const cycles = graph.cycles.length > 0 ? graph.cycles : findCycles(graph);
-    const relevant = cycles.filter((cycle) => cycle.every((id) => selected.has(id)));
-    return { ok: false, cycles: relevant.length > 0 ? relevant : cycles };
+  const ci = env.CI;
+  const inCi = ci !== void 0 && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+  if (inCi || !process.stdout.isTTY) {
+    return "--background needs an interactive terminal. In CI, run in the foreground so the exit code is visible.";
   }
-  return { ok: true, order };
-}
-function describeCycles(cycles) {
-  return cycles.map((cycle) => [...cycle, cycle[0]].map((id) => `#${id}`).join(" \u2192 ")).join("; ");
-}
-
-// src/execution/plan.ts
-function describeIssue(issue, id) {
-  const parsed = Number.parseInt(id, 10);
-  return {
-    number: issue?.number ?? (Number.isNaN(parsed) ? null : parsed),
-    title: issue?.title ?? "",
-    url: issue?.remoteRef ?? null,
-    source: issue?.source ?? "github"
-  };
+  return null;
 }
-function buildExecutionPlan(input) {
-  const now = input.now ?? isoNow;
-  const at = now();
-  const scheduled = new Set(input.order);
-  const requested = new Set(input.requested);
-  const issues = input.order.map((id, index) => {
-    const node = input.graph.nodes.get(id);
-    const relations = node?.relations;
-    const described = describeIssue(node?.issue ?? null, id);
-    return {
-      id,
-      number: described.number,
-      title: described.title,
-      url: described.url,
-      source: described.source,
-      position: index + 1,
-      status: "pending",
-      origin: requested.has(id) ? "requested" : "discovered",
-      // Only the constraints that survive inside the queue: a blocker left out
-      // of it is reported in `excluded`, not enforced as a dependency.
-      dependsOn: (relations?.blockedBy ?? []).filter((blocker) => scheduled.has(blocker)),
-      parent: relations?.parent ?? null,
-      priority: priorityOf(node?.issue?.labels ?? []),
-      heuristic: (relations?.heuristic.length ?? 0) > 0,
-      failedPhase: null,
-      lastError: null,
-      startedAt: null,
-      completedAt: null
-    };
-  });
-  const excluded = [];
-  for (const node of input.graph.nodes.values()) {
-    if (scheduled.has(node.id)) continue;
-    const described = describeIssue(node.issue, node.id);
-    excluded.push({
-      id: node.id,
-      number: described.number,
-      title: described.title,
-      url: described.url,
-      reason: "Discovered in the hierarchy but not selected for this run"
-    });
-  }
-  return {
-    schemaVersion: 1,
-    id: input.requested[0] ?? input.order[0],
-    project: input.projectId,
-    requested: [...input.requested],
-    branchName: null,
-    noBranch: input.noBranch ?? false,
-    prReview: input.prReview ?? false,
-    status: "pending",
-    createdAt: at,
-    updatedAt: at,
-    truncated: input.graph.truncated,
-    issues,
-    excluded
-  };
+function childArgv(argv) {
+  const next = [];
+  for (const arg of argv) {
+    if (arg === "--background" || arg === "-d") continue;
+    next.push(arg);
+  }
+  next.push("--detached-child");
+  return next;
 }
-async function loadExecutionPlan(path) {
-  const raw = JSON.parse(await readFile(path, "utf-8"));
+async function spawnDetachedRun(input) {
+  const entryScript = input.entryScript ?? process.argv[1];
+  if (entryScript === void 0) {
+    throw new Error("Could not determine the CLI entry point to spawn a detached run.");
+  }
+  await mkdir(dirname(input.paths.runLogFile), { recursive: true });
+  await rotateRunLogIfNeeded(input.paths.runLogFile, input.paths.rotatedRunLogFile);
+  const log = await open(input.paths.runLogFile, "a");
   try {
-    return executionPlanSchema.parse(raw);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new Error(`Invalid execution-plan.json at ${path}:
-${issues}`);
+    const args = [entryScript, ...childArgv((input.argv ?? process.argv.slice(2)).slice())];
+    const spawnFn = input.spawnFn ?? spawn;
+    const child = spawnFn(input.execPath ?? process.execPath, args, {
+      detached: true,
+      stdio: ["ignore", log.fd, log.fd],
+      cwd: input.cwd ?? process.cwd(),
+      env: input.env ?? process.env
+    });
+    if (child.pid === void 0) {
+      throw new Error("The detached run started but reported no pid.");
     }
-    throw err;
+    child.unref();
+    return { pid: child.pid, logFile: input.paths.runLogFile };
+  } finally {
+    await log.close();
   }
 }
-async function saveExecutionPlan(path, plan, now = isoNow) {
-  await mkdir(dirname(path), { recursive: true });
-  const stamped = { ...plan, updatedAt: now() };
-  await writeFileAtomic(path, `${JSON.stringify(stamped, null, 2)}
-`);
-}
-function nextQueueIssue(plan) {
-  return plan.issues.find((entry) => entry.status === "in_progress") ?? plan.issues.find((entry) => entry.status === "failed") ?? plan.issues.find((entry) => entry.status === "pending") ?? null;
-}
-function queueStatus(plan) {
-  if (plan.issues.some((entry) => entry.status === "failed")) return "failed";
-  if (plan.issues.every((entry) => entry.status === "completed")) return "completed";
-  if (plan.issues.some((entry) => entry.status !== "pending")) return "in_progress";
-  return "pending";
-}
-function isQueueComplete(plan) {
-  return plan.issues.every((entry) => entry.status === "completed");
-}
-function updateIssue(plan, id, patch) {
-  const issues = plan.issues.map((entry) => entry.id === id ? { ...entry, ...patch } : entry);
-  const next = { ...plan, issues };
-  return { ...next, status: queueStatus(next) };
-}
-function markQueueIssueInProgress(plan, id, now = isoNow) {
-  const current = plan.issues.find((entry) => entry.id === id);
-  return updateIssue(plan, id, {
-    status: "in_progress",
-    // Preserved across a resume: the queue reports when the work on this Issue
-    // really began, not when it was last picked up.
-    startedAt: current?.startedAt ?? now(),
-    failedPhase: null,
-    lastError: null
-  });
-}
-function markQueueIssueCompleted(plan, id, now = isoNow) {
-  return updateIssue(plan, id, {
-    status: "completed",
-    completedAt: now(),
-    failedPhase: null,
-    lastError: null
-  });
-}
-function markQueueIssueFailed(plan, id, failure2) {
-  return updateIssue(plan, id, {
-    status: "failed",
-    failedPhase: failure2.phase,
-    lastError: failure2.error
-  });
-}
-function setQueueBranch(plan, branchName) {
-  return { ...plan, branchName };
-}
-function setQueuePullRequest(plan, pullRequest) {
-  return { ...plan, pullRequest };
-}
 
 // src/execution/confirm.ts
 import { createInterface } from "readline";
@@ -615,16 +244,25 @@ function buildQueueSummaryLines(plan) {
   const primary = plan.issues.find((entry) => entry.id === plan.id) ?? plan.issues[0];
   const lines = [];
   if (primary !== void 0) {
-    lines.push(`  Main issue:   ${issueLabel(primary)}${primary.title ? ` ${primary.title}` : ""}`);
+    const role = primary.role === "container" ? "   (container)" : "";
+    lines.push(
+      `  Main issue:   ${issueLabel(primary)}${primary.title ? ` ${primary.title}` : ""}${role}`
+    );
   }
-  lines.push(`  Total issues: ${plan.issues.length}`);
+  const executables = plan.issues.filter((entry) => entry.role !== "container").length;
+  const containers = plan.issues.length - executables;
+  lines.push(
+    containers > 0 ? `  Total issues: ${executables} executable + ${containers} container` : `  Total issues: ${plan.issues.length}`
+  );
   lines.push("  Suggested order:");
   for (const entry of plan.issues) {
     const reason = reasonFor(entry);
     const flag = entry.heuristic ? " ~" : "";
+    const external = entry.externalDependencies.length > 0 ? `  \u26A0 depends on ${entry.externalDependencies.map((id) => `#${id}`).join(", ")} (outside this scope)` : "";
+    const role = entry.role === "container" ? " (container)" : "";
     const title = entry.title === "" ? "" : ` ${entry.title}`;
     lines.push(
-      `    ${entry.position}. ${issueLabel(entry)}${title}${reason === "" ? "" : ` (${reason})`}${flag}`
+      `    ${entry.position}. ${issueLabel(entry)}${title}${role}${reason === "" ? "" : ` (${reason})`}${flag}${external}`
     );
   }
   if (plan.issues.some((entry) => entry.heuristic)) {
@@ -635,6 +273,23 @@ function buildQueueSummaryLines(plan) {
   }
   return lines;
 }
+function buildScopeSummaryLine(plan, choice) {
+  if (choice === "cancel") return null;
+  const primary = plan.requested[0] ?? plan.id;
+  if (choice === "requested") {
+    return `Scope: ${plan.requested.length} requested issue(s).`;
+  }
+  if (choice === "cascade") {
+    const executables = plan.issues.filter((entry) => entry.role !== "container").length;
+    return `Scope: hierarchy of #${primary} (${executables} executable, container not implemented).`;
+  }
+  return `Scope: ${plan.issues.length} issues from the hierarchy of #${primary}.`;
+}
+function requestedIsContainer(plan) {
+  return plan.issues.some(
+    (entry) => plan.requested.includes(entry.id) && entry.role === "container"
+  );
+}
 async function confirmQueue(plan, requestedOnlyCount, options = {}) {
   const info = options.info ?? printInfo;
   const warn = options.warn ?? printWarning;
@@ -643,19 +298,41 @@ async function confirmQueue(plan, requestedOnlyCount, options = {}) {
     (options.stdout ?? process.stdout).write(`${line}
 `);
   }
+  const container = requestedIsContainer(plan);
   if (options.only === true) {
+    if (container) {
+      warn(
+        `${plan.requested.map((id) => `#${id}`).join(", ")} is a container. --only will run it as an executable issue.`
+      );
+    }
     info(`--only: running just the ${requestedOnlyCount} issue(s) you asked for.`);
+    info(buildScopeSummaryLine(plan, "requested") ?? "");
     return "requested";
   }
+  if (options.cascade === true || options.yes === true && container) {
+    info(
+      `${options.cascade === true ? "--cascade" : "--yes"}: running the hierarchy of the container, without implementing it.`
+    );
+    info(buildScopeSummaryLine(plan, "cascade") ?? "");
+    return "cascade";
+  }
   if (options.yes === true) {
     info(`--yes: running the whole hierarchy (${plan.issues.length} issues).`);
+    info(buildScopeSummaryLine(plan, "all") ?? "");
     return "all";
   }
   const interactive = options.interactive ?? isInteractiveByDefault();
+  if (!interactive && container) {
+    throw new QueueConfirmationError(
+      `${plan.requested.map((id) => `#${id}`).join(", ")} is a container (umbrella) and the terminal is not interactive. Re-run with --cascade to execute its children, or --only to execute just that issue.`
+    );
+  }
   if (!interactive && options.singleRequest === true) {
     warn(
       `A larger structure was found, but the terminal is not interactive: running just issue ${plan.requested.map((id) => `#${id}`).join(", ")}. Re-run with --yes to execute the whole hierarchy.`
     );
+    const summary2 = buildScopeSummaryLine(plan, "requested");
+    if (summary2) info(summary2);
     return "requested";
   }
   if (!interactive) {
@@ -663,10 +340,19 @@ async function confirmQueue(plan, requestedOnlyCount, options = {}) {
       "This run involves more than one issue and the terminal is not interactive. Re-run with --yes to execute the whole hierarchy, or --only to execute just the issues you informed."
     );
   }
-  const query = `Which scope should run? [1] Only the issues informed (${requestedOnlyCount})  [2] The whole hierarchy (${plan.issues.length})  [3] Cancel: `;
-  return await ask(query, options.stdin ?? process.stdin, options.stdout ?? process.stdout, warn);
+  const query = container ? `Which scope should run? [1] The hierarchy of #${plan.id} (${plan.issues.filter((entry) => entry.role !== "container").length} issues)  [2] Include dependencies outside it  [3] Just #${plan.id} itself  [4] Cancel: ` : `Which scope should run? [1] Only the issues informed (${requestedOnlyCount})  [2] The whole hierarchy (${plan.issues.length})  [3] Cancel: `;
+  const choice = await ask(
+    query,
+    options.stdin ?? process.stdin,
+    options.stdout ?? process.stdout,
+    warn,
+    container ? "container" : "plain"
+  );
+  const summary = buildScopeSummaryLine(plan, choice);
+  if (summary) info(summary);
+  return choice;
 }
-async function ask(query, stdin, stdout, warn) {
+async function ask(query, stdin, stdout, warn, mode = "plain") {
   const rl = createInterface({ input: stdin, output: stdout });
   const queued = [];
   let pending = null;
@@ -708,6 +394,14 @@ async function ask(query, stdin, stdout, warn) {
         return "cancel";
       }
       const choice = answer.trim();
+      if (mode === "container") {
+        if (choice === "" || choice === "1") return "cascade";
+        if (choice === "2") return "all";
+        if (choice === "3") return "requested";
+        if (choice === "4") return "cancel";
+        warn(`Invalid choice: '${choice}'. Enter 1, 2, 3 or 4.`);
+        continue;
+      }
       if (choice === "1") return "requested";
       if (choice === "" || choice === "2") return "all";
       if (choice === "3") return "cancel";
@@ -750,6 +444,14 @@ async function discoverIssueGraph(roots, options = {}) {
 }
 
 // src/execution/queue.ts
+function forceRequestedExecutable(plan) {
+  return {
+    ...plan,
+    issues: plan.issues.map(
+      (entry) => plan.requested.includes(entry.id) ? { ...entry, role: "executable" } : entry
+    )
+  };
+}
 async function loadResumableQueue(planFile, requested) {
   let plan;
   try {
@@ -834,7 +536,30 @@ async function planQueue(input) {
     return { kind: "stop", code: 1 };
   }
   let plan = suggestedPlan;
-  if (choice === "requested") {
+  if (choice === "cascade") {
+    const include = collectCascadeIds(graph, input.requested);
+    const cascadeOrder = computeExecutionOrder(graph, { include });
+    if (!cascadeOrder.ok) {
+      warn(`Dependency cycle between issues: ${describeCycles(cascadeOrder.cycles)}.`);
+      return { kind: "stop", code: 1 };
+    }
+    if (cascadeOrder.order.filter(
+      (id) => suggestedPlan.issues.find((entry) => entry.id === id)?.role !== "container"
+    ).length === 0) {
+      warn(
+        `Issue #${input.requested[0]} is a container with no executable children in scope. Re-run with --only if you really want to implement it.`
+      );
+      return { kind: "stop", code: 1 };
+    }
+    plan = buildExecutionPlan({
+      projectId: input.projectId,
+      requested: input.requested,
+      graph,
+      order: cascadeOrder.order,
+      noBranch: input.noBranch,
+      prReview: input.prReview
+    });
+  } else if (choice === "requested") {
     if (!requestedOrder.ok) {
       warn(
         `Dependency cycle between the issues you informed: ${describeCycles(requestedOrder.cycles)}.`
@@ -851,14 +576,16 @@ async function planQueue(input) {
       }
       return { kind: "single" };
     }
-    plan = buildExecutionPlan({
-      projectId: input.projectId,
-      requested: input.requested,
-      graph,
-      order: requestedOrder.order,
-      noBranch: input.noBranch,
-      prReview: input.prReview
-    });
+    plan = forceRequestedExecutable(
+      buildExecutionPlan({
+        projectId: input.projectId,
+        requested: input.requested,
+        graph,
+        order: requestedOrder.order,
+        noBranch: input.noBranch,
+        prReview: input.prReview
+      })
+    );
   }
   await saveExecutionPlan(input.planFile, plan);
   return { kind: "queue", plan, resumed: false };
@@ -902,6 +629,34 @@ function parseIssueArguments(values) {
 
 // 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",
@@ -950,6 +705,13 @@ function createActiveStoryTracker(stories, storyTasks) {
     }
   };
 }
+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;
@@ -970,6 +732,31 @@ function buildExecutePhaseTask(runner, tasksPath, verbose) {
     const totalStories = stories.length;
     const initialPassed = stories.filter((s) => s.passes).length;
     task.title = `Execute (${initialPassed}/${totalStories} stories passing)`;
+    if (!executeExpandsStories(verbose)) {
+      setStoryUpdateCallback((updatedStories) => {
+        const passed = updatedStories.filter((s) => s.passes).length;
+        task.title = `Execute (${passed}/${totalStories} stories passing)`;
+        paintExecuteFocus(task);
+      });
+      setStoryStageCallback(() => {
+        paintExecuteFocus(task);
+      });
+      setActivityCallback(() => {
+        paintExecuteFocus(task);
+      });
+      setOutputCallback((line) => {
+        task.output = line;
+      });
+      try {
+        await runner();
+      } finally {
+        setOutputCallback(void 0);
+        setStoryUpdateCallback(void 0);
+        setStoryStageCallback(void 0);
+        setActivityCallback(void 0);
+      }
+      return;
+    }
     const resolvers = /* @__PURE__ */ new Map();
     setStoryUpdateCallback((updatedStories) => {
       const passed = updatedStories.filter((s) => s.passes).length;
@@ -1036,14 +823,14 @@ function buildExecutePhaseTask(runner, tasksPath, verbose) {
   };
 }
 async function runPipelineWithRenderer(options) {
-  const { phases, startIndex, verbose, runners, tasksPath } = options;
+  const { phases, startIndex, verbose, runners, tasksPath, phaseSuffixes } = options;
   const overallStart = Date.now();
   let currentPhase;
   const renderer = selectRenderer(verbose);
   const isSimple = renderer === "simple";
   const tasks = new Listr(
     phases.map((phase, index) => {
-      const label = phaseLabel(phase);
+      const label = phaseSuffixes?.[phase] ? `${phaseLabel(phase)} (${phaseSuffixes[phase]})` : phaseLabel(phase);
       const isExecutePhase = phase === "execute" && tasksPath;
       return {
         title: label,
@@ -1096,6 +883,7 @@ async function runPipelineWithRenderer(options) {
     setOutputCallback(void 0);
     setStoryUpdateCallback(void 0);
     setStoryStageCallback(void 0);
+    setActivityCallback(void 0);
   }
   const overallElapsedSeconds = Math.floor((Date.now() - overallStart) / 1e3);
   return {
@@ -1110,6 +898,35 @@ function toIssueNumber(id) {
   const parsed = Number.parseInt(id, 10);
   return Number.isNaN(parsed) ? null : parsed;
 }
+async function publishInstrumentedPhaseEnd(publisher, phase, issueNumber, success, error) {
+  const at = isoNow();
+  const startedAt = publisher.snapshot().phases.find((entry) => entry.name === phase)?.startedAt;
+  const wallMs = startedAt === null || startedAt === void 0 ? null : Math.max(0, Date.parse(at) - Date.parse(startedAt));
+  const timing = await loadPhaseTiming(phase, wallMs);
+  publisher.publish({
+    type: "phase:end",
+    at,
+    phase,
+    success,
+    ...error === void 0 ? {} : { error },
+    ...snapshotTimingFields(timing)
+  });
+  if (isVerbose()) {
+    printInfo(
+      formatPhaseLine({
+        issueNumber: toIssueNumber(issueNumber) ?? issueNumber,
+        phase,
+        iteration: timing.iteration,
+        wallMs,
+        cliDurationMs: timing.cliDurationMs,
+        harnessStartupMs: timing.harnessStartupMs,
+        ttftMs: timing.ttftMs,
+        numTurns: timing.numTurns,
+        outputTokens: timing.outputTokens
+      })
+    );
+  }
+}
 function publishStorySeed(publisher, stories, at) {
   if (stories.length === 0) return false;
   publisher.publish({ type: "stories:update", at, stories: [...stories] });
@@ -1140,6 +957,10 @@ var QUEUE_PR_PHASES_WITH_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 };
+}
 async function readPrReviewOutcome(issue, tasksPath, requestedChanges) {
   const outcome = { requestedChanges, recommendation: null, reportPath: null };
   try {
@@ -1162,6 +983,7 @@ 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 {
@@ -1170,34 +992,112 @@ async function runPipeline(issue, mode, from, noBranch, prReview, options = {})
     printError(err instanceof Error ? err.message : String(err));
     return 1;
   }
-  const first = await runIssueSession(requested[0], mode, {
-    from,
-    noBranch,
-    prReview,
-    requested,
-    runOptions: options
-  });
-  if (first.queue === void 0) {
-    return first.code;
+  if (options.background === true && options.detachedChild !== true) {
+    const reason = backgroundRejection(mode);
+    if (reason !== null) {
+      printError(reason);
+      return 1;
+    }
+    return detachAfterConfirm(requested, noBranch, prReview, options);
   }
-  return runQueue(
-    first.queue.plan,
-    { mode, from, noBranch, prReview, runOptions: options },
-    first.queue.resolved
-  );
+  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,
+      ...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();
+  }
+}
+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 {
+    lockFile = (await resolveProjectPaths()).runLockFile;
+  } 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);
+  const resilience = await initResilienceConfig();
+  const configuredInactivity = resilience.watchdog?.inactivityTimeoutMs;
+  if (configuredInactivity !== void 0 && getInactivityTimeout() === void 0) {
+    setInactivityTimeout(configuredInactivity);
+  }
   const webConfig = await loadWebConfig();
-  let publisher = new NullPublisher();
-  if (webConfig.enabled) {
+  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 });
-    publisher = new FilePublisher(paths.sessionFile, {
-      logLimit: webConfig.logLimit,
-      includeLogs: webConfig.includeLogs
-    });
   }
+  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 }
+      })
+    );
+  }
+  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.`
+    });
+  }
   if (webConfig.enabled) {
     await ensureWebMonitor({
       publisher,
@@ -1213,10 +1113,34 @@ async function runIssueSession(issueNumber, mode, input) {
     storyCount: 0,
     elapsedSeconds: 0
   };
+  const releaseCheckpoint = onShutdown({
+    phase: "checkpoint",
+    run: async () => {
+      await pauseIssue(paths.tasksFile, issueNumber);
+      publisher.publish({
+        type: "log",
+        at: isoNow(),
+        level: "warn",
+        message: `Interrupted during issue #${issueNumber}. A checkpoint was saved; resume with \`issue-flow resume ${issueNumber}\`.`
+      });
+      publisher.publish({ type: "session:end", at: isoNow(), status: "failed" });
+    }
+  });
+  const releaseClose = onShutdown({
+    phase: "close",
+    run: async () => {
+      await publisher.close();
+    }
+  });
   try {
     result = await runPipelinePhases(issueNumber, paths, mode, publisher, input);
+    if (result.code !== 0) {
+      await reportIfOversized(issueNumber, paths, result);
+    }
     return result;
   } finally {
+    releaseCheckpoint();
+    releaseClose();
     if (result.queue === void 0) {
       publisher.publish({
         type: "session:end",
@@ -1228,10 +1152,127 @@ async function runIssueSession(issueNumber, mode, input) {
     setSessionPublisher(void 0);
   }
 }
+async function reportIfOversized(issueNumber, paths, result) {
+  try {
+    const journal = `${await readFileIfPresent(paths.rotatedEventsFile)}${await readFileIfPresent(paths.eventsFile)}`;
+    const plan = await loadTaskPlan(paths.tasksFile).catch(() => null);
+    const assessment = assessDecomposition({
+      journal,
+      plan,
+      filesTouched: await countChangedFiles(),
+      hitMaxIterations: result.failedPhase === "execute" && plan?.issueStatus !== "completed"
+    });
+    if (!assessment.oversized) return;
+    const report = buildDecompositionReport({
+      issueNumber,
+      assessment,
+      plan,
+      at: isoNow()
+    });
+    const reportFile = paths.decompositionFile;
+    await mkdir2(paths.issueDir, { recursive: true });
+    await writeFile(reportFile, report, "utf-8");
+    printWarning(`Issue #${issueNumber} looks larger than one run. Report: ${reportFile}`);
+    for (const signal of assessment.signals) {
+      printWarning(`  ${signal.detail}`);
+    }
+    await maybeCreateSubIssues(issueNumber, plan, reportFile);
+    if (plan !== null) {
+      await saveTaskPlan(paths.tasksFile, {
+        ...plan,
+        runState: {
+          currentPhase: plan.runState?.currentPhase ?? result.failedPhase,
+          attempt: plan.runState?.attempt ?? 0,
+          owner: null,
+          status: "blocked",
+          blockedReason: `Looks larger than one run; see ${reportFile}`,
+          lastHeartbeatAt: isoNow()
+        }
+      });
+    }
+  } catch {
+  }
+}
+async function maybeCreateSubIssues(issueNumber, plan, reportFile) {
+  if (getActiveResilienceConfig().decompose?.auto !== true) {
+    printInfo(`Nothing was split. Read ${reportFile} and decide.`);
+    return;
+  }
+  const committed = await committedStoryIds(await getBaseBranch()).catch(() => /* @__PURE__ */ new Set());
+  if (committed.size > 0) {
+    printWarning(
+      `--auto-decompose did not run: ${committed.size} story(ies) are already committed on this branch. Splitting on top of committed work needs a person.`
+    );
+    return;
+  }
+  const proposals = proposeSubIssues(plan);
+  if (proposals.length === 0) {
+    printInfo("Nothing left to split: no pending story.");
+    return;
+  }
+  const { runGenerate } = await import("./generate-MVQI7A45.js");
+  for (const proposal of proposals) {
+    const instruction = [
+      `Create a sub-issue of #${issueNumber}: ${proposal.title}.`,
+      proposal.dependsOn.length === 0 ? "" : `It depends on: ${proposal.dependsOn.join(", ")}.`,
+      "It covers exactly these user stories, and nothing else:",
+      ...proposal.stories.map((story) => `- ${story.id} ${story.title}: ${story.description}`)
+    ].filter((line) => line !== "").join("\n");
+    const code = await runGenerate(instruction);
+    if (code !== 0) {
+      printWarning(
+        `Could not create "${proposal.title}". The report at ${reportFile} still stands.`
+      );
+      return;
+    }
+  }
+}
+async function countChangedFiles() {
+  try {
+    const base = await getBaseBranch();
+    const result = await run("git", ["diff", "--name-only", `${base}...HEAD`]);
+    if (result.exitCode !== 0) return 0;
+    return result.stdout.split("\n").filter((line) => line.trim() !== "").length;
+  } catch {
+    return 0;
+  }
+}
+async function readFileIfPresent(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+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()
+      }
+    });
+  } catch {
+    printWarning(`Could not write a checkpoint for issue #${issueNumber}.`);
+  }
+}
 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();
   let publishedIssueNumber = toIssueNumber(issueNumber);
@@ -1244,15 +1285,27 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
       issueUrl: info?.issueUrl,
       branch: info?.branch,
       phases: [...phases],
-      environment: { node: process.version, platform: process.platform }
+      environment: {
+        node: process.version,
+        platform: process.platform,
+        agent: agentSummary.defaultProvider,
+        model: agentSummary.defaultModel
+      }
     });
   };
-  printInfo(`Starting pipeline for issue #${issueNumber} (mode: ${mode})`);
+  const agentSummary = await describeRunAgents(
+    prReview ? ["prd", "plan", "execute", "review", "pr", "pr-review"] : ["prd", "plan", "execute", "review", "pr"]
+  );
+  printInfo(
+    `Starting pipeline for issue #${issueNumber} (mode: ${mode}, agent: ${agentSummary.label})`
+  );
   const issuesConfig = await loadIssuesConfig();
   const sessionStartedAt = isoNow();
   if (queue?.preChecked !== true) {
-    printInfo("Running prerequisite checks...");
-    const initCode = await runInit(issuesConfig.preferredProvider);
+    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" });
@@ -1399,6 +1452,7 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
   }
   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}`);
@@ -1411,25 +1465,28 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
         () => runPlan(issueNumber, resolvedIssue, { continueFlag: continueNumbering, startUs }),
         "plan"
       )();
-      if (effectiveNoBranch || effectivePrReview) {
-        try {
-          const plan = await loadTaskPlan(tasksPath);
-          if (effectiveNoBranch) {
-            plan.noBranch = true;
-          }
+      try {
+        const plan = await loadTaskPlan(tasksPath);
+        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 {
         }
+      } catch {
       }
       if (queue !== void 0 && !effectiveNoBranch) {
         producedBranch = await adoptQueueBranch(tasksPath, queue.plan.branchName);
       }
     },
     execute: makeRunner(
-      () => runExecute(void 0, { issue: issueNumber, commitScope: queueCommitScope }),
+      () => runExecute(void 0, {
+        issue: issueNumber,
+        commitScope: queueCommitScope,
+        ...executeRetry
+      }),
       "execute"
     ),
     review: async () => {
@@ -1453,7 +1510,8 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
         }
         const execCode = await runExecute(void 0, {
           issue: issueNumber,
-          commitScope: queueCommitScope
+          commitScope: queueCommitScope,
+          ...executeRetry
         });
         if (execCode !== 0) {
           throw new Error("Correction execution failed");
@@ -1489,27 +1547,34 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
         try {
           await fn();
           await publishGitState(publisher);
-          publisher.publish({ type: "phase:end", at: isoNow(), phase, success: true });
+          await publishInstrumentedPhaseEnd(publisher, phase, issueNumber, true);
         } catch (err) {
           await publishGitState(publisher);
-          publisher.publish({
-            type: "phase:end",
-            at: isoNow(),
+          await publishInstrumentedPhaseEnd(
+            publisher,
             phase,
-            success: false,
-            error: err instanceof Error ? err.message : String(err)
-          });
+            issueNumber,
+            false,
+            err instanceof Error ? err.message : String(err)
+          );
           throw err;
         }
       }
     ])
   );
+  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
+    tasksPath,
+    phaseSuffixes
   });
   if (!result.success) {
     printError(`Phase ${result.failedPhase} failed`);
@@ -1590,7 +1655,8 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
     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()
+    usage: getRunUsageTotals(),
+    verification: verificationForSummary(getSessionPublisher().snapshot().verification)
   });
   return {
     code: 0,
@@ -1600,6 +1666,37 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
     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;
@@ -1619,7 +1716,11 @@ async function decideQueue(input) {
       planFile: queuePaths.planFile,
       noBranch: input.noBranch,
       prReview: input.prReview,
-      confirm: { yes: input.runOptions.yes, only: input.runOptions.only }
+      confirm: {
+        yes: input.runOptions.yes,
+        only: input.runOptions.only,
+        cascade: input.runOptions.cascade
+      }
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1640,9 +1741,14 @@ async function runQueue(initialPlan, options, resolvedPrimary) {
   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);
+      const entry = nextQueueIssue(plan, { exclude: exhausted });
       if (entry === null) break;
       plan = markQueueIssueInProgress(plan, entry.id);
       await saveExecutionPlan(planFile, plan);
@@ -1675,20 +1781,55 @@ async function runQueue(initialPlan, options, resolvedPrimary) {
       }
       const usage = issueUsage.totals();
       if (result.code !== 0) {
-        plan = markQueueIssueFailed(plan, entry.id, {
+        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);
-        printError(
-          `Queue stopped at issue #${entry.id}${result.failedPhase === null ? "" : ` (phase ${result.failedPhase})`}. The branch and every commit made so far were kept.`
-        );
-        printInfo(`Resume with: issue-flow run ${plan.requested.join(",")}`);
-        return result.code;
+        continue;
       }
       if (plan.branchName === null && result.branchName !== null) {
         plan = setQueueBranch(plan, result.branchName);
@@ -1703,7 +1844,7 @@ async function runQueue(initialPlan, options, resolvedPrimary) {
         usage
       });
     }
-    return await finishQueue(
+    const code = await finishQueue(
       plan,
       planFile,
       summaries,
@@ -1712,6 +1853,14 @@ async function runQueue(initialPlan, options, resolvedPrimary) {
       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;
+    }
+    return code;
   } finally {
     queueUsage.end();
   }
@@ -1790,7 +1939,10 @@ async function buildPrQueueContext(plan) {
       number: entry.number,
       title: entry.title,
       url: entry.url,
-      source: entry.source
+      source: entry.source,
+      parent: entry.parent,
+      role: entry.role,
+      complete: entry.status === "completed"
     })),
     excluded: plan.excluded.map((entry) => ({
       id: entry.id,
@@ -1853,9 +2005,10 @@ async function adoptQueueBranch(tasksPath, queueBranch) {
     return queueBranch;
   }
 }
+
 export {
-  publishIssueDetails,
   publishStorySeed,
+  publishIssueDetails,
   runPipeline
 };
-//# sourceMappingURL=run-DBF2VWUN.js.map
+//# sourceMappingURL=chunk-OPNGPUKJ.js.map