issue-flow 0.11.0 → 0.12.0

package/dist/{run-H75MD5BQ.js → chunk-NTMMF5UD.js}

@@ -1,579 +1,285 @@
 #!/usr/bin/env node
+import {
+  ensureWebMonitor
+} from "./chunk-FJP3UQGD.js";
+import {
+  runPr
+} from "./chunk-FADTCQGM.js";
 import {
   mostRecent,
   prReviewDir,
   readPrReviewIndex,
   runPrReview
-} from "./chunk-MKD2D7WE.js";
+} from "./chunk-A4SLHOW7.js";
 import {
   runPrd
-} from "./chunk-MSPUB635.js";
+} from "./chunk-M5UCXTIT.js";
 import {
   runReview
-} from "./chunk-VCKX262Z.js";
+} from "./chunk-XQUSIEKA.js";
 import {
-  ensureWebMonitor
-} from "./chunk-GANSDJV7.js";
+  JournalPublisher,
+  MultiPublisher,
+  PIPELINE_PHASES,
+  PIPELINE_PHASES_NO_BRANCH,
+  PIPELINE_PHASES_WITH_PR_REVIEW,
+  PipelineManager,
+  buildDependencyGraph,
+  buildExecutionPlan,
+  computeExecutionOrder,
+  describeCycles,
+  isQueueComplete,
+  loadExecutionPlan,
+  markQueueIssueBlocked,
+  markQueueIssueCompleted,
+  markQueueIssueFailed,
+  markQueueIssueInProgress,
+  markQueueIssueSkipped,
+  nextQueueIssue,
+  parseJournal,
+  saveExecutionPlan,
+  setQueueBranch,
+  setQueuePullRequest
+} from "./chunk-56KS3TFQ.js";
+import {
+  acquireRunLock,
+  describeRunLockOwner
+} from "./chunk-BAUPQXPE.js";
 import {
   runInit
-} from "./chunk-RKTEV6EG.js";
+} from "./chunk-NS6R37II.js";
 import {
   printQueueSummary,
   printRunSummary,
   runExecute
-} from "./chunk-6N7LZZ5U.js";
+} from "./chunk-3QHK4YQA.js";
 import {
   listPullRequests,
   publishGitState
-} from "./chunk-LVKQ2AKT.js";
+} from "./chunk-TSOLWK7Y.js";
 import {
   runPlan
-} from "./chunk-UBIQXCVE.js";
-import {
-  runPr
-} from "./chunk-JW7WLSZ6.js";
-import "./chunk-3BOHTH4V.js";
+} from "./chunk-QCPGHBSZ.js";
 import {
-  emptyRelations,
   getProvider,
-  resolveCommandIssue,
-  uniqueIds
-} from "./chunk-AAY6KM7N.js";
-import "./chunk-PL6CNMVS.js";
-import "./chunk-HDV3YDTG.js";
+  resolveCommandIssue
+} from "./chunk-73ATPIYX.js";
 import {
   beginUsageScope,
   getRunUsageTotals
-} from "./chunk-OBLVLIUS.js";
-import "./chunk-HQYXVIH6.js";
-import "./chunk-47VIN33V.js";
+} from "./chunk-MJULIKQU.js";
+import {
+  onShutdown
+} from "./chunk-M66SJHQQ.js";
 import {
-  executionPlanSchema,
+  getActiveResilienceConfig,
+  initResilienceConfig,
   loadIssuesConfig,
-  loadWebConfig,
+  loadWebConfig
+} from "./chunk-42PJFMAR.js";
+import {
+  committedStoryIds,
+  describePreflight,
+  getBaseBranch,
+  preflightRepository,
   resolveIssuePaths,
   resolveProjectPaths,
-  resolveQueuePaths
-} from "./chunk-VQ5VN7DF.js";
+  resolveQueuePaths,
+  run
+} from "./chunk-DIDUVL6O.js";
 import {
   FilePublisher,
   NullPublisher,
+  getInactivityTimeout,
   isVerbose,
-  isoNow,
-  loadTaskPlan,
   printError,
   printInfo,
   printSuccess,
   printWarning,
-  saveTaskPlan,
+  setInactivityTimeout,
   setOutputCallback,
   setSessionPublisher,
   setStoryStageCallback,
-  setStoryUpdateCallback,
-  writeFileAtomic
-} from "./chunk-HC2MT7BX.js";
+  setStoryUpdateCallback
+} from "./chunk-BYZDPR7N.js";
+import {
+  isoNow,
+  loadTaskPlan,
+  saveTaskPlan
+} from "./chunk-CD5ULRVC.js";
 
 // src/commands/run.ts
 import { randomUUID } from "crypto";
-import { mkdir as mkdir2 } from "fs/promises";
+import { mkdir, 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"
+// 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 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;
-      }
+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;
     }
-    return null;
-  }
-  /**
-   * Get the current phase (alias for getNextPhase).
-   */
-  getCurrentPhase() {
-    return this.getNextPhase();
-  }
-  /**
-   * Check whether we can resume from a specific phase.
-   * All prerequisite phases must be complete.
-   */
-  canResume(fromPhase) {
-    const idx = this.activePhases.indexOf(fromPhase);
-    if (idx < 0) return false;
-    for (let i = 0; i < idx; i++) {
-      if (!this.isPhaseComplete(this.activePhases[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Mark a phase as complete and persist to disk.
-   */
-  async markPhaseComplete(phase) {
-    const field = PHASE_TO_FIELD[phase];
-    if (field === null) return;
-    this.plan = {
-      ...this.plan,
-      pipeline: {
-        ...this.plan.pipeline ?? {
-          prdCompleted: false,
-          jsonCompleted: false,
-          executionCompleted: false,
-          reviewCompleted: false,
-          prCreated: false
-        },
-        [field]: true
-      }
-    };
-    await saveTaskPlan(this.tasksJsonPath, this.plan);
-  }
-};
-
-// src/execution/plan.ts
-import { mkdir, readFile } from "fs/promises";
-import { dirname } from "path";
-import { ZodError } from "zod";
-
-// src/issues/graph.ts
-var DEFAULT_MAX_NODES = 25;
-var DEFAULT_MAX_DEPTH = 3;
-function dependencyEdges(graph) {
-  const edges = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (from, to) => {
-    if (from === to || !graph.nodes.has(from) || !graph.nodes.has(to)) return;
-    const key = `${from}->${to}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    edges.push({ from, to });
-  };
-  for (const node of graph.nodes.values()) {
-    for (const blocker of node.relations.blockedBy) {
-      add(blocker, node.id);
-    }
-    for (const blocked of node.relations.blocking) {
-      add(node.id, blocked);
+    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 edges;
+  return longest;
 }
-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);
+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 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);
+  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}).`
+    });
   }
-  return cycles;
-}
-function compareIds(a, b) {
-  const na = Number(a);
-  const nb = Number(b);
-  if (Number.isInteger(na) && Number.isInteger(nb)) {
-    return na - nb;
+  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}).`
+    });
   }
-  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
-      );
-    }
+  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}).`
+    });
   }
-}
-
-// src/execution/order.ts
-var PRIORITY_LABELS = {
-  high: "high",
-  medium: "medium",
-  low: "low"
-};
-var PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
-var NO_PRIORITY_RANK = 3;
-function priorityOf(labels) {
-  for (const label of labels) {
-    const normalized = label.trim().toLowerCase();
-    const direct = PRIORITY_LABELS[normalized];
-    if (direct !== void 0) return direct;
-    const qualified = /^(?:priority|prio|p)\s*[:/-]\s*(high|medium|low)$/.exec(normalized);
-    const matched = qualified?.[1];
-    if (matched !== void 0) return PRIORITY_LABELS[matched];
-  }
-  return null;
-}
-function hierarchyDepth(id, parentOf, selected) {
-  let depth = 0;
-  let current = parentOf.get(id) ?? null;
-  const seen = /* @__PURE__ */ new Set([id]);
-  while (current !== null && selected.has(current) && !seen.has(current)) {
-    depth++;
-    seen.add(current);
-    current = parentOf.get(current) ?? null;
-  }
-  return depth;
-}
-function computeExecutionOrder(graph, options = {}) {
-  const selected = new Set(
-    (options.include ?? [...graph.nodes.keys()]).filter((id) => graph.nodes.has(id))
-  );
-  const parentOf = /* @__PURE__ */ new Map();
-  const priority = /* @__PURE__ */ new Map();
-  for (const id of selected) {
-    const node = graph.nodes.get(id);
-    parentOf.set(id, node?.relations.parent ?? null);
-    priority.set(id, priorityOf(node?.issue?.labels ?? []));
-  }
-  const incoming = /* @__PURE__ */ new Map();
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const id of selected) {
-    incoming.set(id, /* @__PURE__ */ new Set());
-    outgoing.set(id, []);
-  }
-  for (const { from, to } of dependencyEdges(graph)) {
-    if (!selected.has(from) || !selected.has(to) || from === to) continue;
-    incoming.get(to)?.add(from);
-    outgoing.get(from)?.push(to);
-  }
-  const depth = /* @__PURE__ */ new Map();
-  for (const id of selected) {
-    depth.set(id, hierarchyDepth(id, parentOf, selected));
-  }
-  const rank = (id) => {
-    const value = priority.get(id) ?? null;
-    return value === null ? NO_PRIORITY_RANK : PRIORITY_RANK[value];
-  };
-  const better = (a, b) => {
-    const byHierarchy = (depth.get(a) ?? 0) - (depth.get(b) ?? 0);
-    if (byHierarchy !== 0) return byHierarchy;
-    const byPriority = rank(a) - rank(b);
-    if (byPriority !== 0) return byPriority;
-    return compareIds(a, b);
-  };
-  const ready = [...selected].filter((id) => (incoming.get(id)?.size ?? 0) === 0);
-  const order = [];
-  while (ready.length > 0) {
-    ready.sort(better);
-    const next = ready.shift();
-    order.push(next);
-    for (const dependent of outgoing.get(next) ?? []) {
-      const pending = incoming.get(dependent);
-      if (pending === void 0) continue;
-      pending.delete(next);
-      if (pending.size === 0) {
-        ready.push(dependent);
-      }
-    }
+  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}).`
+    });
   }
-  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 };
+  if (input.hitMaxIterations === true) {
+    signals.push({
+      id: "max-iterations",
+      detail: "The execute loop stopped because it ran out of iterations, not because it finished."
+    });
   }
-  return { ok: true, order };
-}
-function describeCycles(cycles) {
-  return cycles.map((cycle) => [...cycle, cycle[0]].map((id) => `#${id}`).join(" \u2192 ")).join("; ");
+  return { signals, oversized: signals.length >= DECOMPOSITION_MIN_SIGNALS };
 }
-
-// src/execution/plan.ts
-function describeIssue(issue, id) {
-  const parsed = Number.parseInt(id, 10);
-  return {
-    number: issue?.number ?? (Number.isNaN(parsed) ? null : parsed),
-    title: issue?.title ?? "",
-    url: issue?.remoteRef ?? null,
-    source: issue?.source ?? "github"
-  };
-}
-function buildExecutionPlan(input) {
-  const now = input.now ?? isoNow;
-  const at = now();
-  const scheduled = new Set(input.order);
-  const requested = new Set(input.requested);
-  const issues = input.order.map((id, index) => {
-    const node = input.graph.nodes.get(id);
-    const relations = node?.relations;
-    const described = describeIssue(node?.issue ?? null, id);
-    return {
-      id,
-      number: described.number,
-      title: described.title,
-      url: described.url,
-      source: described.source,
-      position: index + 1,
-      status: "pending",
-      origin: requested.has(id) ? "requested" : "discovered",
-      // Only the constraints that survive inside the queue: a blocker left out
-      // of it is reported in `excluded`, not enforced as a dependency.
-      dependsOn: (relations?.blockedBy ?? []).filter((blocker) => scheduled.has(blocker)),
-      parent: relations?.parent ?? null,
-      priority: priorityOf(node?.issue?.labels ?? []),
-      heuristic: (relations?.heuristic.length ?? 0) > 0,
-      failedPhase: null,
-      lastError: null,
-      startedAt: null,
-      completedAt: null
-    };
-  });
-  const excluded = [];
-  for (const node of input.graph.nodes.values()) {
-    if (scheduled.has(node.id)) continue;
-    const described = describeIssue(node.issue, node.id);
-    excluded.push({
-      id: node.id,
-      number: described.number,
-      title: described.title,
-      url: described.url,
-      reason: "Discovered in the hierarchy but not selected for this run"
+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 {
-    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
-  };
+  return chunks;
 }
-async function loadExecutionPlan(path) {
-  const raw = JSON.parse(await readFile(path, "utf-8"));
-  try {
-    return executionPlanSchema.parse(raw);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new Error(`Invalid execution-plan.json at ${path}:
-${issues}`);
-    }
-    throw err;
+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}`);
   }
-}
-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 };
+  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}`);
+    }
+    lines.push("");
+  }
+  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
@@ -1162,6 +868,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 +877,102 @@ 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;
+  const ownership = await claimRunOwnership(requested[0]);
+  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;
   }
-  return runQueue(
-    first.queue.plan,
-    { mode, from, noBranch, prReview, runOptions: options },
-    first.queue.resolved
-  );
+  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) {
+  let lockFile;
+  try {
+    lockFile = (await resolveProjectPaths()).runLockFile;
+  } catch {
+    return { ok: true, interruptedBy: null, release: async () => {
+    } };
+  }
+  const result = await acquireRunLock(lockFile, { target });
+  if (!result.ok) return result;
+  return {
+    ok: true,
+    interruptedBy: result.handle.reclaimedFrom,
+    release: () => result.handle.release()
+  };
 }
 async function runIssueSession(issueNumber, mode, input) {
   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();
+  const surfaces = [];
+  const journalEnabled = resilience.journal?.enabled === true;
+  if (webConfig.enabled || journalEnabled) {
+    await mkdir(paths.issueDir, { recursive: true });
+  }
   if (webConfig.enabled) {
-    await mkdir2(paths.issueDir, { recursive: true });
-    publisher = new FilePublisher(paths.sessionFile, {
-      logLimit: webConfig.logLimit,
-      includeLogs: webConfig.includeLogs
-    });
+    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 NullPublisher() : 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 +988,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 +1027,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 mkdir(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-EGB4KV2B.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);
@@ -1399,6 +1315,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}`);
@@ -1429,7 +1346,11 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
       }
     },
     execute: makeRunner(
-      () => runExecute(void 0, { issue: issueNumber, commitScope: queueCommitScope }),
+      () => runExecute(void 0, {
+        issue: issueNumber,
+        commitScope: queueCommitScope,
+        ...executeRetry
+      }),
       "execute"
     ),
     review: async () => {
@@ -1453,7 +1374,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");
@@ -1640,9 +1562,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 +1602,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 +1665,7 @@ async function runQueue(initialPlan, options, resolvedPrimary) {
         usage
       });
     }
-    return await finishQueue(
+    const code = await finishQueue(
       plan,
       planFile,
       summaries,
@@ -1712,6 +1674,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();
   }
@@ -1853,9 +1823,10 @@ async function adoptQueueBranch(tasksPath, queueBranch) {
     return queueBranch;
   }
 }
+
 export {
-  publishIssueDetails,
   publishStorySeed,
+  publishIssueDetails,
   runPipeline
 };
-//# sourceMappingURL=run-H75MD5BQ.js.map
+//# sourceMappingURL=chunk-NTMMF5UD.js.map