issue-flow 0.17.0 → 0.19.1

package/dist/{chunk-HJBF4WD2.js → chunk-MHA7Q3KU.js}

@@ -3,26 +3,7 @@ import {
   formatPhaseLine,
   loadPhaseTiming,
   snapshotTimingFields
-} from "./chunk-B3TSS7BT.js";
-import {
-  runPr
-} from "./chunk-LPWPFIIB.js";
-import {
-  mostRecent,
-  prReviewDir,
-  readPrReviewIndex,
-  runPrReview
-} from "./chunk-Z5O2XBWA.js";
-import {
-  listPullRequests,
-  publishGitState
-} from "./chunk-YUNBOUQH.js";
-import {
-  runPrd
-} from "./chunk-ANI2NTR4.js";
-import {
-  runReview
-} from "./chunk-MI5TREN3.js";
+} from "./chunk-KDQRNVBZ.js";
 import {
   PIPELINE_PHASES,
   PIPELINE_PHASES_NO_BRANCH,
@@ -41,51 +22,71 @@ import {
   markQueueIssueInProgress,
   markQueueIssueSkipped,
   nextQueueIssue,
+  queueNeedsFinalization,
   saveExecutionPlan,
   setQueueBranch,
   setQueuePullRequest
-} from "./chunk-A4H7P7T7.js";
+} from "./chunk-LRWIP7QS.js";
 import {
-  runInit
-} from "./chunk-ISZ54SVE.js";
+  listStoredIssueEvents
+} from "./chunk-2EYLOS5I.js";
 import {
+  SqliteSessionPublisher,
   printQueueSummary,
   printRunSummary,
   runExecute,
   stripMarkdown
-} from "./chunk-KZXQWC7U.js";
+} from "./chunk-XHCP6ZNO.js";
 import {
   ensureWebMonitor
-} from "./chunk-2SUFAE6X.js";
+} from "./chunk-PHPAK2L6.js";
 import {
   runPlan
-} from "./chunk-KZ5EY5XX.js";
+} from "./chunk-HHXWAWU6.js";
+import {
+  runPr
+} from "./chunk-2YYP7AE6.js";
+import {
+  mostRecent,
+  prReviewDir,
+  readPrReviewIndex,
+  runPrReview
+} from "./chunk-XQLNZW7I.js";
+import {
+  listPullRequests,
+  publishGitState
+} from "./chunk-ERAG5IQB.js";
+import {
+  runPrd
+} from "./chunk-2EZW4X57.js";
+import {
+  runReview
+} from "./chunk-NYDAHE3Y.js";
 import {
   resolveCommandIssue
-} from "./chunk-VE3IYNDN.js";
+} from "./chunk-WPHC6JBR.js";
+import {
+  runInit
+} from "./chunk-46S7APLQ.js";
 import {
   getProvider
-} from "./chunk-QMIQR7EE.js";
+} from "./chunk-ZAYATXJD.js";
 import {
   beginUsageScope,
   getRunUsageTotals
-} from "./chunk-HLAPOUEM.js";
+} from "./chunk-WB2FVIUS.js";
 import {
   assessDecomposition,
   buildDecompositionReport,
   proposeSubIssues,
   resetAgentInvocationState
-} from "./chunk-UK4E2FUA.js";
-import {
-  JournalPublisher,
-  MultiPublisher
-} from "./chunk-WCCZJL7W.js";
+} from "./chunk-MQTVMB7W.js";
 import {
   recommendedTarget
-} from "./chunk-D6ZBGJ3L.js";
+} from "./chunk-F2NFJ27Z.js";
 import {
   getPackageVersion
-} from "./chunk-C5TL7T4V.js";
+} from "./chunk-2YM2VH6R.js";
 import {
   describeRunAgents,
   getActiveResilienceConfig,
@@ -97,13 +98,10 @@ import {
   loadRoutingConfig,
   loadWebConfig,
   onShutdown
-} from "./chunk-HY5HLFDU.js";
-import {
-  resolveIssuePaths,
-  resolveProjectPaths,
-  resolveQueuePaths
-} from "./chunk-DV7HUC4Z.js";
+} from "./chunk-UHDXXLYH.js";
 import {
+  JournalPublisher,
+  MultiPublisher,
   formatDuration,
   getIcons,
   getInactivityTimeout,
@@ -112,51 +110,60 @@ import {
   printInfo,
   printSuccess,
   printWarning,
+  resolveIssuePaths,
+  resolveProjectPaths,
+  resolveQueuePaths,
   setActivityCallback,
   setInactivityTimeout,
   setOutputCallback,
   setStoryStageCallback,
   setStoryUpdateCallback
-} from "./chunk-XZUEFTUP.js";
+} from "./chunk-J6VJ5M2U.js";
 import {
   bindDiagnosticContext,
   flushDiagnostics,
   writeDiagnostic
-} from "./chunk-QPGEFLMY.js";
-import {
-  committedStoryIds,
-  describePreflight,
-  getBaseBranch,
-  getCurrentBranch,
-  getHeadCommit,
-  getProjectRoot,
-  localBranchExists,
-  preflightRepository,
-  run
-} from "./chunk-YVPZUN6X.js";
+} from "./chunk-7CMVL4X6.js";
 import {
   FilePublisher,
   MemoryPublisher,
   getSessionPublisher,
   setSessionPublisher
-} from "./chunk-DUS5ZNKL.js";
+} from "./chunk-DIMDAYZS.js";
 import {
+  DEFAULT_MAX_CORRECTION_CYCLES,
+  allStoriesPass,
   isoNow,
   loadTaskPlan,
   saveTaskPlan
-} from "./chunk-SOM4QA6C.js";
+} from "./chunk-GD7JZMSJ.js";
 import {
   acquireRunLock,
   describeRunLockOwner
-} from "./chunk-ICM463EO.js";
+} from "./chunk-IMB6FA2F.js";
+import {
+  getPlanRepository,
+  ingestGeneratedPlan
+} from "./chunk-7MJGYPHF.js";
+import {
+  committedStoryIds,
+  describePreflight,
+  getBaseBranch,
+  getCurrentBranch,
+  getHeadCommit,
+  getProjectRoot,
+  localBranchExists,
+  preflightRepository,
+  run
+} from "./chunk-TJVX42KY.js";
 
 // src/execution/detach.ts
-import { spawn } from "child_process";
-import { mkdir, open } from "fs/promises";
-import { dirname } from "path";
+import { spawn } from "node:child_process";
+import { mkdir, open } from "node:fs/promises";
+import { dirname } from "node:path";
 
 // src/storage/run-log.ts
-import { rename, stat } from "fs/promises";
+import { rename, stat } from "node: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;
@@ -257,7 +264,7 @@ function parseIssueArguments(values) {
 }
 
 // src/execution/confirm.ts
-import { createInterface } from "readline";
+import { createInterface } from "node:readline";
 var MAX_PROMPT_ATTEMPTS = 3;
 var QueueConfirmationError = class extends Error {
   exitCode;
@@ -513,12 +520,48 @@ async function loadResumableQueue(planFile, requested) {
   const sameRequest = plan.requested.length === requested.length && plan.requested.every((id, index) => id === requested[index]);
   return sameRequest ? plan : null;
 }
+function executableGraphIds(graph, requested) {
+  const roots = new Set(requested);
+  return [...graph.nodes.values()].filter((node) => roots.has(node.id) || node.issue?.state !== "closed").map((node) => node.id);
+}
+async function reconcileClosedDiscoveredIssues(plan, warn) {
+  let next = plan;
+  const closed = [];
+  for (const entry of plan.issues) {
+    if (entry.origin !== "discovered" || entry.status === "completed") continue;
+    try {
+      const issue = await getProvider(entry.source).get(entry.id);
+      if (issue?.state !== "closed") continue;
+      next = markQueueIssueCompleted(next, entry.id);
+      closed.push(entry.id);
+    } catch (err) {
+      warn(
+        `Could not refresh issue #${entry.id} before resuming the queue: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { plan: next, closed };
+}
 async function planQueue(input) {
   const info = input.info ?? printInfo;
   const warn = input.warn ?? printWarning;
   const single = input.requested.length === 1;
-  const resumable = await loadResumableQueue(input.planFile, input.requested);
-  if (resumable !== null && isQueueComplete(resumable)) {
+  let resumable = await loadResumableQueue(input.planFile, input.requested);
+  if (resumable !== null) {
+    if (input.closeIssue !== void 0) {
+      resumable.closeIssue = input.closeIssue;
+      await saveExecutionPlan(input.planFile, resumable);
+    }
+    const reconciled = await reconcileClosedDiscoveredIssues(resumable, warn);
+    resumable = reconciled.plan;
+    if (reconciled.closed.length > 0) {
+      await saveExecutionPlan(input.planFile, resumable);
+      info(
+        `Skipping already closed issue(s) in the resumed queue: ${reconciled.closed.map((id) => `#${id}`).join(", ")}.`
+      );
+    }
+  }
+  if (resumable !== null && isQueueComplete(resumable) && !queueNeedsFinalization(resumable)) {
     const pr = resumable.pullRequest?.url;
     info(
       `The execution queue of issue #${resumable.id} is already complete (${resumable.issues.length} issues)${pr === void 0 ? "" : ` \u2014 ${pr}`}. Nothing to run.`
@@ -543,10 +586,8 @@ async function planQueue(input) {
     known: input.known,
     warn
   });
-  if (single && graph.nodes.size <= 1) {
-    return { kind: "single" };
-  }
-  const suggested = computeExecutionOrder(graph);
+  const schedulable = executableGraphIds(graph, input.requested);
+  const suggested = computeExecutionOrder(graph, { include: schedulable });
   if (!suggested.ok) {
     if (single) {
       warn(
@@ -569,6 +610,9 @@ async function planQueue(input) {
     noBranch: input.noBranch,
     prReview: input.prReview
   });
+  if (single && suggestedPlan.issues.length === 1 && suggestedPlan.issues[0]?.role !== "container") {
+    return { kind: "single" };
+  }
   let choice;
   try {
     choice = await confirmQueue(suggestedPlan, requestedCount, {
@@ -588,7 +632,8 @@ async function planQueue(input) {
   }
   let plan = suggestedPlan;
   if (choice === "cascade") {
-    const include = collectCascadeIds(graph, input.requested);
+    const eligible = new Set(schedulable);
+    const include = collectCascadeIds(graph, input.requested).filter((id) => eligible.has(id));
     const cascadeOrder = computeExecutionOrder(graph, { include });
     if (!cascadeOrder.ok) {
       warn(`Dependency cycle between issues: ${describeCycles(cascadeOrder.cycles)}.`);
@@ -638,10 +683,57 @@ async function planQueue(input) {
       })
     );
   }
+  if (input.closeIssue !== void 0) plan.closeIssue = input.closeIssue;
   await saveExecutionPlan(input.planFile, plan);
   return { kind: "queue", plan, resumed: false };
 }
 
+// src/commands/run/closure.ts
+function requestedPhasesComplete(plan) {
+  const phases = PIPELINE_PHASES.filter(
+    (phase) => !plan.noBranch || phase !== "pr"
+  );
+  if (plan.prReview?.enabled && !plan.noBranch) phases.push("pr-review");
+  return plan.userStories.length > 0 && new PipelineManager(plan, "", phases).getNextPhase() === null && allStoriesPass(plan) && !plan.lastReviewFindings;
+}
+async function closeAndConfirm(id, source) {
+  const provider = getProvider(source);
+  if ((await provider.get(id))?.state === "closed") return;
+  if (!provider.close) throw new Error(`Provider ${source} cannot close issues`);
+  await provider.close(id);
+  if ((await provider.get(id))?.state !== "closed")
+    throw new Error(`Could not confirm closure of ${id}`);
+}
+async function persistClosureChoice(path, choice) {
+  if (choice === void 0) return;
+  const plan = await loadTaskPlan(path);
+  plan.closeIssue = choice;
+  await saveTaskPlan(path, plan);
+}
+async function finishIssueClosure(path, id, source) {
+  const plan = await loadTaskPlan(path);
+  if (!requestedPhasesComplete(plan)) return 1;
+  if (plan.closeIssue && !plan.issueClosedAt) {
+    try {
+      await closeAndConfirm(id, source);
+      plan.issueClosedAt = isoNow();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      plan.lastError = { category: "issue_closure", message, at: isoNow() };
+      plan.issueStatus = "in_progress";
+      plan.completedAt = null;
+      await saveTaskPlan(path, plan);
+      printError(`Delivery complete; issue closure pending: ${message}`);
+      return 1;
+    }
+  }
+  plan.issueStatus = "completed";
+  plan.completedAt ??= isoNow();
+  if (plan.lastError?.category === "issue_closure") plan.lastError = null;
+  await saveTaskPlan(path, plan);
+  return 0;
+}
+
 // src/commands/run/pull-request.ts
 async function primaryPrCreated(plan) {
   try {
@@ -706,17 +798,6 @@ async function propagatePullRequest(plan) {
   }
   return pullRequest;
 }
-async function closeIssue(issueNumber, source) {
-  try {
-    const provider = getProvider(source);
-    if (provider.close !== void 0) {
-      printInfo("Closing issue...");
-      await provider.close(issueNumber);
-    }
-  } catch {
-    printWarning("Failed to close issue automatically");
-  }
-}
 
 // src/commands/run/queue-failure.ts
 async function handleQueueIssueFailure(input) {
@@ -794,6 +875,7 @@ async function decideQueue(input) {
       planFile: queuePaths.planFile,
       noBranch: input.noBranch,
       prReview: input.prReview,
+      closeIssue: input.runOptions.closeIssue,
       confirm: {
         yes: input.runOptions.yes,
         only: input.runOptions.only,
@@ -845,6 +927,10 @@ async function detachAfterConfirm(requested, noBranch, prReview, options) {
 }
 async function runQueue(initialPlan, options, resolvedPrimary, runIssueSession3) {
   const planFile = (await resolveQueuePaths(initialPlan.id)).planFile;
+  if (options.runOptions?.closeIssue !== void 0) {
+    initialPlan = { ...initialPlan, closeIssue: options.runOptions.closeIssue };
+    await saveExecutionPlan(planFile, initialPlan);
+  }
   const queueUsage = beginUsageScope();
   const startedAtMs = Date.now();
   const resilience = getActiveResilienceConfig();
@@ -1012,7 +1098,7 @@ async function finishQueue(plan, planFile, summaries, startedAtMs, queueUsage, o
   let current = plan;
   let review = null;
   const alreadyOpened = current.pullRequest !== void 0 || await primaryPrCreated(current);
-  if (!current.noBranch && options.noBranch !== true && !alreadyOpened) {
+  if (!current.noBranch && options.noBranch !== true && (!alreadyOpened || current.prReview && !current.prReviewCompleted)) {
     const outcome = await runIssueSession3(current.id, options.mode, {
       prReview: options.prReview ?? current.prReview,
       queue: {
@@ -1028,17 +1114,43 @@ async function finishQueue(plan, planFile, summaries, startedAtMs, queueUsage, o
       await saveExecutionPlan(planFile, current);
       return outcome.code;
     }
+    if (current.prReview) current.prReviewCompleted = review !== null && !review.requestedChanges;
     const pullRequest = await propagatePullRequest(current);
     if (pullRequest !== null) {
       current = setQueuePullRequest(current, pullRequest);
     }
   }
   await saveExecutionPlan(planFile, current);
+  if (current.prReview && !current.prReviewCompleted && !review?.requestedChanges) {
+    printError("Consolidated PR review is still pending; resume the queue.");
+    return 1;
+  }
   if (review?.requestedChanges === true) {
     printInfo("Issues left open until the review blockers are addressed.");
-  } else {
+  } else if (current.closeIssue && (!current.prReview || current.prReviewCompleted)) {
     for (const entry of current.issues) {
-      await closeIssue(entry.id, entry.source);
+      if (entry.status !== "completed" || (current.closedIssueIds ?? []).includes(entry.id))
+        continue;
+      try {
+        await closeAndConfirm(entry.id, entry.source);
+        current.closedIssueIds = [...current.closedIssueIds ?? [], entry.id];
+        await saveExecutionPlan(planFile, current);
+      } catch (error) {
+        printError(`Issue #${entry.id} closure pending: ${String(error)}`);
+        return 1;
+      }
+    }
+  }
+  if (!review?.requestedChanges && (!current.prReview || current.prReviewCompleted)) {
+    for (const entry of current.issues.filter((entry2) => entry2.status === "completed")) {
+      try {
+        const paths = await resolveIssuePaths(entry.id);
+        const task = await loadTaskPlan(paths.tasksFile);
+        task.issueStatus = "completed";
+        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await saveTaskPlan(paths.tasksFile, task);
+      } catch {
+      }
     }
   }
   printQueueSummary({
@@ -1342,7 +1454,7 @@ async function runPipelineWithRenderer(options) {
 import { execa } from "execa";
 
 // src/commands/run/publish.ts
-import { join } from "path";
+import { join } from "node:path";
 function toIssueNumber(id) {
   const parsed = Number.parseInt(id, 10);
   return Number.isNaN(parsed) ? null : parsed;
@@ -1423,8 +1535,7 @@ async function readPrReviewOutcome(issue, tasksPath, requestedChanges) {
 }
 
 // src/commands/run/phase-finalize.ts
-async function applyReviewOutcomeAndClose(input) {
-  const { issueNumber, resolvedIssue, review, inQueue } = input;
+function reportReviewOutcome(review) {
   if (review?.requestedChanges) {
     console.log("");
     printWarning("PR review requested changes \u2014 the Pull Request is not ready to merge.");
@@ -1434,8 +1545,6 @@ async function applyReviewOutcomeAndClose(input) {
   }
   if (review?.requestedChanges) {
     printInfo("Issue left open until the review blockers are addressed.");
-  } else if (!inQueue) {
-    await closeIssue(issueNumber, resolvedIssue.source);
   }
 }
 async function resolveSummaryPrUrl(input) {
@@ -1467,7 +1576,20 @@ async function finalizeSuccessfulIssueRun(input) {
     effectiveNoBranch,
     elapsedSeconds
   } = input;
-  await applyReviewOutcomeAndClose({ issueNumber, resolvedIssue, review, inQueue });
+  reportReviewOutcome(review);
+  const closurePlan = !inQueue ? await loadTaskPlan(tasksPath).catch(() => null) : null;
+  if (!inQueue && !review?.requestedChanges && (closurePlan?.closeIssue || closurePlan?.lastError?.category === "issue_closure")) {
+    const code = await finishIssueClosure(tasksPath, issueNumber, resolvedIssue.source);
+    if (code !== 0)
+      return {
+        code,
+        failedPhase: "close",
+        branchName: producedBranch,
+        storyCount: 0,
+        elapsedSeconds,
+        review
+      };
+  }
   let branchName = "unknown";
   try {
     const proc = await execa("git", ["branch", "--show-current"], { reject: false });
@@ -1481,7 +1603,7 @@ async function finalizeSuccessfulIssueRun(input) {
     storyCount = plan.userStories.length;
     planPrUrl = plan.pullRequest?.url ?? null;
     plan.lastAttemptAt = isoNow();
-    if (!review?.requestedChanges) {
+    if (!review?.requestedChanges && !inQueue) {
       plan.issueStatus = "completed";
       plan.completedAt = isoNow();
     }
@@ -1530,7 +1652,7 @@ async function finalizeSuccessfulIssueRun(input) {
 }
 
 // src/commands/run/phase-bootstrap.ts
-import { randomUUID } from "crypto";
+import { randomUUID } from "node:crypto";
 
 // src/commands/run/phase-config.ts
 async function buildAgentConfiguration(prReview) {
@@ -1580,8 +1702,10 @@ async function buildAgentConfiguration(prReview) {
 }
 
 // src/commands/run/types.ts
-var RUNNABLE_PHASES = ["prd", "plan", "execute", "review", "pr"];
-var RUNNABLE_PHASES_NO_BRANCH = ["prd", "plan", "execute", "review"];
+var RUNNABLE_PHASES = PIPELINE_PHASES.filter((phase) => phase !== "init");
+var RUNNABLE_PHASES_NO_BRANCH = RUNNABLE_PHASES.filter(
+  (phase) => phase !== "pr"
+);
 var RUNNABLE_PHASES_WITH_PR_REVIEW = [...RUNNABLE_PHASES, "pr-review"];
 var QUEUE_PR_PHASES = ["init", "pr"];
 var QUEUE_PR_PHASES_WITH_REVIEW = [
@@ -2018,14 +2142,17 @@ async function preparePhaseRun(issueNumber, paths, mode, publisher, input) {
   };
 }
 
+// src/commands/run/phase-runners.ts
+import { existsSync } from "node:fs";
+
 // src/commands/run/session.ts
-import { mkdir as mkdir3 } from "fs/promises";
+import { mkdir as mkdir3 } from "node:fs/promises";
 
 // src/commands/run/oversized.ts
-import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile, writeFile } from "node:fs/promises";
 async function reportIfOversized(issueNumber, paths, result) {
   try {
-    const journal = `${await readFileIfPresent(paths.rotatedEventsFile)}${await readFileIfPresent(paths.eventsFile)}`;
+    const journal = await readJournal(paths);
     const plan = await loadTaskPlan(paths.tasksFile).catch(() => null);
     const assessment = assessDecomposition({
       journal,
@@ -2064,6 +2191,18 @@ async function reportIfOversized(issueNumber, paths, result) {
   } catch {
   }
 }
+async function readJournal(paths) {
+  const repository = getPlanRepository(paths.tasksFile);
+  if (repository === void 0) {
+    return `${await readFileIfPresent(paths.rotatedEventsFile)}${await readFileIfPresent(paths.eventsFile)}`;
+  }
+  const events = await listStoredIssueEvents({
+    projectId: repository.projectId,
+    issueId: repository.issueId,
+    ...repository.databaseOptions === void 0 ? {} : { databaseOptions: repository.databaseOptions }
+  });
+  return events.map((entry) => JSON.stringify(entry)).join("\n");
+}
 async function maybeCreateSubIssues(issueNumber, plan, reportFile) {
   if (getActiveResilienceConfig().decompose?.auto !== true) {
     printInfo(`Nothing was split. Read ${reportFile} and decide.`);
@@ -2081,7 +2220,7 @@ async function maybeCreateSubIssues(issueNumber, plan, reportFile) {
     printInfo("Nothing left to split: no pending story.");
     return;
   }
-  const { runGenerate } = await import("./generate-CX6KNHZS.js");
+  const { runGenerate } = await import("./generate-O7GUXLN4.js");
   for (const proposal of proposals) {
     const instruction = [
       `Create a sub-issue of #${issueNumber}: ${proposal.title}.`,
@@ -2167,6 +2306,15 @@ async function pauseIssue(tasksFile, issueNumber) {
 async function createSessionPublisher(input) {
   const { paths, persistSnapshot, journalEnabled, webConfig, maxFileBytes } = input;
   const surfaces = [];
+  const repository = getPlanRepository(paths.tasksFile);
+  if (repository !== void 0) {
+    surfaces.push(
+      new SqliteSessionPublisher(repository, {
+        logLimit: webConfig.logLimit,
+        includeLogs: webConfig.includeLogs
+      })
+    );
+  }
   if (persistSnapshot || journalEnabled) {
     await mkdir3(paths.issueDir, { recursive: true });
   }
@@ -2341,6 +2489,11 @@ function createPlanRunner(input, makeRunner) {
       }),
       "plan"
     )();
+    const repository = getPlanRepository(tasksPath);
+    if (repository !== void 0 && existsSync(tasksPath)) {
+      await ingestGeneratedPlan(repository);
+    }
+    await persistClosureChoice(tasksPath, input.closureChoice);
     try {
       const plan = await loadTaskPlan(tasksPath);
       if (!effectiveNoBranch) {
@@ -2372,14 +2525,20 @@ function createPlanRunner(input, makeRunner) {
 function createReviewRunner(input) {
   const { issueNumber, tasksPath, publisher, resolvedIssue, queueCommitScope, executeRetry } = input;
   return async () => {
-    let maxCycles = 3;
+    let maxCycles = DEFAULT_MAX_CORRECTION_CYCLES;
+    let cycle = 0;
     try {
       const plan = await loadTaskPlan(tasksPath);
       maxCycles = plan.maxCorrectionCycles;
+      cycle = plan.correctionCycle;
     } catch {
     }
     let code = await runReview(issueNumber, resolvedIssue);
-    let cycle = 0;
+    if (code !== 0 && (await loadTaskPlan(tasksPath)).lastError?.category === "review_protocol") {
+      throw new Error(
+        "Review returned an invalid result; resume review after correcting its output."
+      );
+    }
     while (code !== 0 && cycle < maxCycles) {
       cycle++;
       printWarning(`Review failed. Starting correction cycle ${cycle}/${maxCycles}...`);
@@ -2392,6 +2551,7 @@ function createReviewRunner(input) {
       }
       const execCode = await runExecute(void 0, {
         issue: issueNumber,
+        inPipeline: true,
         commitScope: queueCommitScope,
         ...executeRetry
       });
@@ -2399,6 +2559,9 @@ function createReviewRunner(input) {
         throw new Error("Correction execution failed");
       }
       code = await runReview(issueNumber, resolvedIssue);
+      if (code !== 0 && (await loadTaskPlan(tasksPath)).lastError?.category === "review_protocol") {
+        throw new Error("Review returned an invalid result; no correction was scheduled.");
+      }
     }
     if (code !== 0) {
       throw new Error(`Review failed after ${maxCycles} correction cycles`);
@@ -2459,18 +2622,25 @@ function buildInstrumentedPhaseRunners(input) {
     execute: makeRunner(
       () => runExecute(void 0, {
         issue: issueNumber,
+        inPipeline: true,
         commitScope: queueCommitScope,
         ...executeRetry
       }),
       "execute"
     ),
     review: createReviewRunner(input),
-    pr: makeRunner(
-      // The options argument is omitted outside a queue so a standalone run
-      // calls `runPr` exactly as it always did.
-      () => finalPr === void 0 ? runPr(issueNumber, resolvedIssue) : runPr(issueNumber, resolvedIssue, { queue: finalPr }),
-      "pr"
-    )
+    pr: async () => {
+      await makeRunner(
+        // The options argument is omitted outside a queue so a standalone run
+        // calls `runPr` exactly as it always did.
+        () => finalPr === void 0 ? runPr(issueNumber, resolvedIssue) : runPr(issueNumber, resolvedIssue, { queue: finalPr }),
+        "pr"
+      )();
+      const repository = getPlanRepository(tasksPath);
+      if (repository !== void 0 && existsSync(tasksPath)) {
+        await ingestGeneratedPlan(repository);
+      }
+    }
   };
   const reviewBox = { outcome: null };
   if (effectivePrReview) {
@@ -2562,6 +2732,13 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
     queue
   } = prepared;
   let { producedBranch, plannedExecutionBranch, branchExistedBeforeExecution } = prepared;
+  const closureChoice = queue ? void 0 : input.runOptions?.closeIssue;
+  try {
+    await persistClosureChoice(tasksPath, closureChoice);
+  } catch (error) {
+    if (error.code !== "ENOENT" && !String(error).includes("No SQLite task plan exists"))
+      throw error;
+  }
   const startResolved = await resolveStartPhase({
     from,
     activePhases,
@@ -2592,7 +2769,8 @@ async function runPipelinePhases(issueNumber, paths, mode, publisher, input) {
     effectivePrReview,
     initialBranch,
     queueCommitScope,
-    branchState
+    branchState,
+    closureChoice
   });
   const phaseSuffixes = phaseSuffixesFor(agentSummary);
   const result = await runPipelineWithRenderer({
@@ -2688,8 +2866,10 @@ async function runPipeline(issue, mode, from, noBranch, prReview, options = {})
 }
 
 export {
+  persistClosureChoice,
+  finishIssueClosure,
   publishStorySeed,
   publishIssueDetails,
   runPipeline
 };
-//# sourceMappingURL=chunk-HJBF4WD2.js.map
+//# sourceMappingURL=chunk-MHA7Q3KU.js.map