issue-flow 0.12.0 → 0.13.0

package/dist/{chunk-NTMMF5UD.js → chunk-OPNGPUKJ.js}

@@ -1,31 +1,20 @@
 #!/usr/bin/env node
 import {
-  ensureWebMonitor
-} from "./chunk-FJP3UQGD.js";
-import {
-  runPr
-} from "./chunk-FADTCQGM.js";
-import {
-  mostRecent,
-  prReviewDir,
-  readPrReviewIndex,
-  runPrReview
-} from "./chunk-A4SLHOW7.js";
-import {
-  runPrd
-} from "./chunk-M5UCXTIT.js";
+  formatPhaseLine,
+  loadPhaseTiming,
+  snapshotTimingFields
+} from "./chunk-37N2RJW2.js";
 import {
   runReview
-} from "./chunk-XQUSIEKA.js";
+} from "./chunk-QXDNBYQF.js";
 import {
-  JournalPublisher,
-  MultiPublisher,
   PIPELINE_PHASES,
   PIPELINE_PHASES_NO_BRANCH,
   PIPELINE_PHASES_WITH_PR_REVIEW,
   PipelineManager,
   buildDependencyGraph,
   buildExecutionPlan,
+  collectCascadeIds,
   computeExecutionOrder,
   describeCycles,
   isQueueComplete,
@@ -36,250 +25,184 @@ import {
   markQueueIssueInProgress,
   markQueueIssueSkipped,
   nextQueueIssue,
-  parseJournal,
   saveExecutionPlan,
   setQueueBranch,
   setQueuePullRequest
-} from "./chunk-56KS3TFQ.js";
-import {
-  acquireRunLock,
-  describeRunLockOwner
-} from "./chunk-BAUPQXPE.js";
+} from "./chunk-7KD66LIM.js";
 import {
   runInit
-} from "./chunk-NS6R37II.js";
+} from "./chunk-BHJCGWQX.js";
 import {
   printQueueSummary,
   printRunSummary,
-  runExecute
-} from "./chunk-3QHK4YQA.js";
+  runExecute,
+  stripMarkdown
+} from "./chunk-LZ6GFQAG.js";
+import {
+  ensureWebMonitor
+} from "./chunk-IHIEXUTC.js";
+import {
+  runPlan
+} from "./chunk-TM67EHSV.js";
+import {
+  runPr
+} from "./chunk-PIVGJM6K.js";
+import {
+  mostRecent,
+  prReviewDir,
+  readPrReviewIndex,
+  runPrReview
+} from "./chunk-UJ7XWK7J.js";
 import {
   listPullRequests,
   publishGitState
-} from "./chunk-TSOLWK7Y.js";
+} from "./chunk-J62QSVP6.js";
 import {
-  runPlan
-} from "./chunk-QCPGHBSZ.js";
+  runPrd
+} from "./chunk-HJGGNLWI.js";
 import {
-  getProvider,
   resolveCommandIssue
-} from "./chunk-73ATPIYX.js";
+} from "./chunk-FZDR7CGH.js";
+import {
+  getProvider
+} from "./chunk-PV4OX5TC.js";
 import {
   beginUsageScope,
   getRunUsageTotals
-} from "./chunk-MJULIKQU.js";
+} from "./chunk-664Y3NDX.js";
 import {
-  onShutdown
-} from "./chunk-M66SJHQQ.js";
+  assessDecomposition,
+  buildDecompositionReport,
+  proposeSubIssues,
+  resetAgentInvocationState
+} from "./chunk-ARFVHC2F.js";
 import {
+  JournalPublisher,
+  MultiPublisher
+} from "./chunk-QCXPNSEL.js";
+import {
+  describeRunAgents,
   getActiveResilienceConfig,
   initResilienceConfig,
   loadIssuesConfig,
-  loadWebConfig
-} from "./chunk-42PJFMAR.js";
+  loadWebConfig,
+  onShutdown
+} from "./chunk-CNBYCMSU.js";
 import {
-  committedStoryIds,
-  describePreflight,
-  getBaseBranch,
-  preflightRepository,
   resolveIssuePaths,
   resolveProjectPaths,
-  resolveQueuePaths,
-  run
-} from "./chunk-DIDUVL6O.js";
+  resolveQueuePaths
+} from "./chunk-HQAHNIAR.js";
 import {
   FilePublisher,
-  NullPublisher,
+  MemoryPublisher,
+  formatDuration,
+  getIcons,
   getInactivityTimeout,
+  getSessionPublisher,
   isVerbose,
   printError,
   printInfo,
   printSuccess,
   printWarning,
+  setActivityCallback,
   setInactivityTimeout,
   setOutputCallback,
   setSessionPublisher,
   setStoryStageCallback,
   setStoryUpdateCallback
-} from "./chunk-BYZDPR7N.js";
+} from "./chunk-IYV6KNVF.js";
 import {
   isoNow,
   loadTaskPlan,
   saveTaskPlan
-} from "./chunk-CD5ULRVC.js";
+} 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, readFile, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { execa } from "execa";
 
-// src/core/decompose.ts
-var DECOMPOSITION_THRESHOLDS = {
-  /** Timeouts on the same phase. Two is already a pattern, not bad luck. */
-  timeoutsPerPhase: 2,
-  /** Stories in the plan. Past this, the plan is a backlog. */
-  stories: 15,
-  /** Iterations in a row that completed no story. */
-  barrenIterations: 5,
-  /** Files touched on the branch. */
-  filesTouched: 40,
-  /** Characters in the issue body. */
-  issueBodyChars: 2e4
-};
-var DECOMPOSITION_MIN_SIGNALS = 2;
-function timeoutsByPhase(journal) {
-  const counts = /* @__PURE__ */ new Map();
-  let phase = "(unknown)";
-  for (const { event } of parseJournal(journal)) {
-    if (event.type === "phase:start") {
-      phase = event.phase;
-      continue;
-    }
-    if (event.type !== "retry") continue;
-    const kind = event.kind;
-    const reason = event.reason ?? "";
-    const timedOut = kind === "timeout" || kind === "stalled" || /timed out|stalled/i.test(reason);
-    if (!timedOut) continue;
-    counts.set(phase, (counts.get(phase) ?? 0) + 1);
-  }
-  return counts;
-}
-function longestBarrenRun(journal) {
-  let passing = 0;
-  let current = 0;
-  let longest = 0;
-  for (const { event } of parseJournal(journal)) {
-    if (event.type === "iteration:start") {
-      current++;
-      longest = Math.max(longest, current);
-      continue;
-    }
-    if (event.type !== "stories:update") continue;
-    const nowPassing = event.stories.filter((story) => story.passes).length;
-    if (nowPassing > passing) current = 0;
-    passing = Math.max(passing, nowPassing);
-  }
-  return longest;
-}
-function assessDecomposition(input) {
-  const signals = [];
-  const journal = input.journal ?? "";
-  for (const [phase, count] of timeoutsByPhase(journal)) {
-    if (count >= DECOMPOSITION_THRESHOLDS.timeoutsPerPhase) {
-      signals.push({
-        id: "repeated-timeouts",
-        detail: `The '${phase}' phase timed out ${count} times (threshold: ${DECOMPOSITION_THRESHOLDS.timeoutsPerPhase}).`
-      });
-    }
-  }
-  const stories = input.plan?.userStories.length ?? 0;
-  if (stories > DECOMPOSITION_THRESHOLDS.stories) {
-    signals.push({
-      id: "story-count",
-      detail: `The plan has ${stories} user stories (threshold: ${DECOMPOSITION_THRESHOLDS.stories}).`
-    });
-  }
-  const barren = longestBarrenRun(journal);
-  if (barren >= DECOMPOSITION_THRESHOLDS.barrenIterations) {
-    signals.push({
-      id: "barren-iterations",
-      detail: `${barren} iterations in a row completed no story (threshold: ${DECOMPOSITION_THRESHOLDS.barrenIterations}).`
-    });
+// src/execution/detach.ts
+import { spawn } from "child_process";
+import { mkdir, open } from "fs/promises";
+import { dirname } from "path";
+
+// 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;
   }
-  const files = input.filesTouched ?? 0;
-  if (files > DECOMPOSITION_THRESHOLDS.filesTouched) {
-    signals.push({
-      id: "files-touched",
-      detail: `${files} files were touched on this branch (threshold: ${DECOMPOSITION_THRESHOLDS.filesTouched}).`
-    });
+  try {
+    await rename(filePath, rotatedPath);
+  } catch {
   }
-  const body = input.issueBody?.length ?? 0;
-  if (body > DECOMPOSITION_THRESHOLDS.issueBodyChars) {
-    signals.push({
-      id: "issue-size",
-      detail: `The issue body is ${body} characters (threshold: ${DECOMPOSITION_THRESHOLDS.issueBodyChars}).`
-    });
+}
+
+// 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.";
   }
-  if (input.hitMaxIterations === true) {
-    signals.push({
-      id: "max-iterations",
-      detail: "The execute loop stopped because it ran out of iterations, not because it finished."
-    });
+  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 { signals, oversized: signals.length >= DECOMPOSITION_MIN_SIGNALS };
+  return null;
 }
-var STORIES_PER_SUBISSUE = 5;
-function proposeSubIssues(plan) {
-  const pending = [...plan?.userStories ?? []].filter((story) => !story.passes).sort((a, b) => a.priority - b.priority);
-  if (pending.length === 0) return [];
-  const chunks = [];
-  for (let index = 0; index < pending.length; index += STORIES_PER_SUBISSUE) {
-    const stories = pending.slice(index, index + STORIES_PER_SUBISSUE);
-    const first = stories[0];
-    const last = stories[stories.length - 1];
-    const range = first === void 0 || last === void 0 || first.id === last.id ? first?.id ?? "" : `${first.id}\u2013${last.id}`;
-    chunks.push({
-      title: `${plan?.description ?? "Issue"} \u2014 part ${chunks.length + 1} (${range})`,
-      stories,
-      dependsOn: chunks.length === 0 ? [] : [chunks[chunks.length - 1]?.title ?? ""]
-    });
-  }
-  return chunks;
+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;
 }
-function buildDecompositionReport(input) {
-  const { issueNumber, assessment, plan, at } = input;
-  const proposals = proposeSubIssues(plan);
-  const lines = [];
-  lines.push(`# Issue #${issueNumber} looks larger than one run`, "");
-  lines.push(`Detected at ${at}.`, "");
-  lines.push(
-    "This is a report, not an action. Nothing has been split, and nothing will be",
-    "without you asking for it.",
-    ""
-  );
-  lines.push("## What was detected", "");
-  for (const signal of assessment.signals) {
-    lines.push(`- **${signal.id}** \u2014 ${signal.detail}`);
-  }
-  lines.push("");
-  if (proposals.length === 0) {
-    lines.push("## Proposed split", "");
-    lines.push(
-      "No pending user stories were found, so there is nothing to cut here.",
-      "The signals above are about the run rather than about the plan.",
-      ""
-    );
-    return `${lines.join("\n")}
-`;
-  }
-  lines.push("## Proposed split", "");
-  lines.push(
-    `The ${proposals.reduce((total, proposal) => total + proposal.stories.length, 0)} pending stories, in priority order, cut into ${proposals.length} sub-issues of at most ${STORIES_PER_SUBISSUE}. Each depends on the one before it, which is the only`,
-    "dependency shape that can be derived from the plan alone \u2014 read it as a starting",
-    "point, not as an answer.",
-    ""
-  );
-  for (const proposal of proposals) {
-    lines.push(`### ${proposal.title}`, "");
-    if (proposal.dependsOn.length > 0) {
-      lines.push(`Depends on: ${proposal.dependsOn.join(", ")}`, "");
-    }
-    for (const story of proposal.stories) {
-      lines.push(`- \`${story.id}\` ${story.title}`);
+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 {
+    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.");
     }
-    lines.push("");
+    child.unref();
+    return { pid: child.pid, logFile: input.paths.runLogFile };
+  } finally {
+    await log.close();
   }
-  lines.push("## What to do next", "");
-  lines.push(
-    "- Adjust the cut above until it matches how you would actually split the work;",
-    '- create the sub-issues (`issue-flow generate "\u2026"`) and run them as a queue;',
-    "- or decide the issue is fine as it is and re-run it \u2014 nothing here blocks that,",
-    "  beyond the report you are reading.",
-    ""
-  );
-  return `${lines.join("\n")}
-`;
 }
 
 // src/execution/confirm.ts
@@ -321,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)) {
@@ -341,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;
@@ -349,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) {
@@ -369,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;
@@ -414,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";
@@ -456,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 {
@@ -540,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)}.`
@@ -557,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 };
@@ -608,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",
@@ -656,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;
@@ -676,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;
@@ -742,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,
@@ -802,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 {
@@ -816,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] });
@@ -846,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 {
@@ -877,7 +992,15 @@ async function runPipeline(issue, mode, from, noBranch, prReview, options = {})
     printError(err instanceof Error ? err.message : String(err));
     return 1;
   }
-  const ownership = await claimRunOwnership(requested[0]);
+  if (options.background === true && options.detachedChild !== true) {
+    const reason = backgroundRejection(mode);
+    if (reason !== null) {
+      printError(reason);
+      return 1;
+    }
+    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)}.`
@@ -916,7 +1039,7 @@ async function ensureRepositoryWritable(phase) {
   }
   throw new Error(`The repository is not in a state the ${phase} phase can write to`);
 }
-async function claimRunOwnership(target) {
+async function claimRunOwnership(target, detached = false) {
   let lockFile;
   try {
     lockFile = (await resolveProjectPaths()).runLockFile;
@@ -924,7 +1047,7 @@ async function claimRunOwnership(target) {
     return { ok: true, interruptedBy: null, release: async () => {
     } };
   }
-  const result = await acquireRunLock(lockFile, { target });
+  const result = await acquireRunLock(lockFile, { target, detached });
   if (!result.ok) return result;
   return {
     ok: true,
@@ -933,6 +1056,7 @@ async function claimRunOwnership(target) {
   };
 }
 async function runIssueSession(issueNumber, mode, input) {
+  resetAgentInvocationState();
   const paths = await resolveIssuePaths(issueNumber);
   const resilience = await initResilienceConfig();
   const configuredInactivity = resilience.watchdog?.inactivityTimeoutMs;
@@ -942,10 +1066,11 @@ async function runIssueSession(issueNumber, mode, input) {
   const webConfig = await loadWebConfig();
   const surfaces = [];
   const journalEnabled = resilience.journal?.enabled === true;
-  if (webConfig.enabled || journalEnabled) {
-    await mkdir(paths.issueDir, { recursive: true });
+  const persistSnapshot = webConfig.enabled || input.runOptions?.detachedChild === true;
+  if (persistSnapshot || journalEnabled) {
+    await mkdir2(paths.issueDir, { recursive: true });
   }
-  if (webConfig.enabled) {
+  if (persistSnapshot) {
     surfaces.push(
       new FilePublisher(paths.sessionFile, {
         logLimit: webConfig.logLimit,
@@ -962,7 +1087,7 @@ async function runIssueSession(issueNumber, mode, input) {
       })
     );
   }
-  const publisher = surfaces.length === 0 ? new NullPublisher() : surfaces.length === 1 ? surfaces[0] : new MultiPublisher(surfaces);
+  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;
@@ -1045,7 +1170,7 @@ async function reportIfOversized(issueNumber, paths, result) {
       at: isoNow()
     });
     const reportFile = paths.decompositionFile;
-    await mkdir(paths.issueDir, { recursive: true });
+    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) {
@@ -1085,7 +1210,7 @@ async function maybeCreateSubIssues(issueNumber, plan, reportFile) {
     printInfo("Nothing left to split: no pending story.");
     return;
   }
-  const { runGenerate } = await import("./generate-EGB4KV2B.js");
+  const { runGenerate } = await import("./generate-MVQI7A45.js");
   for (const proposal of proposals) {
     const instruction = [
       `Create a sub-issue of #${issueNumber}: ${proposal.title}.`,
@@ -1160,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" });
@@ -1328,18 +1465,17 @@ 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);
@@ -1411,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`);
@@ -1512,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,
@@ -1522,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;
@@ -1541,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);
@@ -1760,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,
@@ -1829,4 +2011,4 @@ export {
   publishIssueDetails,
   runPipeline
 };
-//# sourceMappingURL=chunk-NTMMF5UD.js.map
+//# sourceMappingURL=chunk-OPNGPUKJ.js.map