issue-flow 0.18.0 → 0.20.0

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

@@ -3,26 +3,7 @@ import {
   formatPhaseLine,
   loadPhaseTiming,
   snapshotTimingFields
-} from "./chunk-QJ44VG5G.js";
-import {
-  runPr
-} from "./chunk-OODXFCQV.js";
-import {
-  mostRecent,
-  prReviewDir,
-  readPrReviewIndex,
-  runPrReview
-} from "./chunk-LTH6XYZ3.js";
-import {
-  listPullRequests,
-  publishGitState
-} from "./chunk-YUNBOUQH.js";
-import {
-  runPrd
-} from "./chunk-XUEMATVY.js";
-import {
-  runReview
-} from "./chunk-EG2MGDP5.js";
+} from "./chunk-ADH6RJNX.js";
 import {
   PIPELINE_PHASES,
   PIPELINE_PHASES_NO_BRANCH,
@@ -41,51 +22,71 @@ import {
   markQueueIssueInProgress,
   markQueueIssueSkipped,
   nextQueueIssue,
+  queueNeedsFinalization,
   saveExecutionPlan,
   setQueueBranch,
   setQueuePullRequest
-} from "./chunk-7UMMFOL2.js";
+} from "./chunk-Y2KOWABB.js";
 import {
-  runInit
-} from "./chunk-PMLE7KAQ.js";
+  listStoredIssueEvents
+} from "./chunk-2EYLOS5I.js";
 import {
+  SqliteSessionPublisher,
   printQueueSummary,
   printRunSummary,
   runExecute,
   stripMarkdown
-} from "./chunk-KRAGAUKD.js";
+} from "./chunk-JBYXJOJJ.js";
 import {
   ensureWebMonitor
-} from "./chunk-NEWNXZ65.js";
+} from "./chunk-V7GETODQ.js";
 import {
   runPlan
-} from "./chunk-34OCSKOB.js";
+} from "./chunk-AKL5UPR6.js";
+import {
+  runPr
+} from "./chunk-FU2FQ4JE.js";
+import {
+  mostRecent,
+  prReviewDir,
+  readPrReviewIndex,
+  runPrReview
+} from "./chunk-EYKPWHT7.js";
+import {
+  listPullRequests,
+  publishGitState
+} from "./chunk-ZPGNVBWY.js";
+import {
+  runPrd
+} from "./chunk-37O2FMAN.js";
+import {
+  runReview
+} from "./chunk-Z6RCKCVB.js";
 import {
   resolveCommandIssue
-} from "./chunk-SA6HXL4Y.js";
+} from "./chunk-7WBUEBD5.js";
+import {
+  runInit
+} from "./chunk-RMIBLFG3.js";
 import {
   getProvider
-} from "./chunk-62GVVZQO.js";
+} from "./chunk-T736DSZI.js";
 import {
   beginUsageScope,
   getRunUsageTotals
-} from "./chunk-KMCS76ZW.js";
+} from "./chunk-KUL64XUF.js";
 import {
   assessDecomposition,
   buildDecompositionReport,
   proposeSubIssues,
   resetAgentInvocationState
-} from "./chunk-TZYINKCC.js";
-import {
-  JournalPublisher,
-  MultiPublisher
-} from "./chunk-WCCZJL7W.js";
+} from "./chunk-UDUUUFQF.js";
 import {
   recommendedTarget
-} from "./chunk-ZVZMWNCG.js";
+} from "./chunk-VJ3PF6B7.js";
 import {
   getPackageVersion
-} from "./chunk-C5TL7T4V.js";
+} from "./chunk-2YM2VH6R.js";
 import {
   describeRunAgents,
   getActiveResilienceConfig,
@@ -97,13 +98,10 @@ import {
   loadRoutingConfig,
   loadWebConfig,
   onShutdown
-} from "./chunk-QF7VEL3M.js";
-import {
-  resolveIssuePaths,
-  resolveProjectPaths,
-  resolveQueuePaths
-} from "./chunk-LI35PIIS.js";
+} from "./chunk-YC24E66P.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-DBLXLKGU.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-I64N6RL6.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-JCR5C5A7.js";
 import {
   acquireRunLock,
   describeRunLockOwner
-} from "./chunk-ICM463EO.js";
+} from "./chunk-44RF3VFG.js";
+import {
+  getPlanRepository,
+  ingestGeneratedPlan
+} from "./chunk-7MJGYPHF.js";
+import {
+  committedStoryIds,
+  describePreflight,
+  getBaseBranch,
+  getCurrentBranch,
+  getHeadCommit,
+  getProjectRoot,
+  localBranchExists,
+  preflightRepository,
+  run
+} from "./chunk-KUA6KBBD.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;
@@ -541,6 +548,10 @@ async function planQueue(input) {
   const single = input.requested.length === 1;
   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) {
@@ -550,7 +561,7 @@ async function planQueue(input) {
       );
     }
   }
-  if (resumable !== null && isQueueComplete(resumable)) {
+  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.`
@@ -672,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 {
@@ -740,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) {
@@ -828,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,
@@ -879,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();
@@ -1046,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: {
@@ -1062,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({
@@ -1376,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;
@@ -1457,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.");
@@ -1468,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) {
@@ -1501,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 });
@@ -1515,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();
     }
@@ -1564,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) {
@@ -1614,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 = [
@@ -2052,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,
@@ -2098,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.`);
@@ -2115,7 +2220,7 @@ async function maybeCreateSubIssues(issueNumber, plan, reportFile) {
     printInfo("Nothing left to split: no pending story.");
     return;
   }
-  const { runGenerate } = await import("./generate-JGW5JSKB.js");
+  const { runGenerate } = await import("./generate-QATMDKOK.js");
   for (const proposal of proposals) {
     const instruction = [
       `Create a sub-issue of #${issueNumber}: ${proposal.title}.`,
@@ -2201,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 });
   }
@@ -2375,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) {
@@ -2406,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}...`);
@@ -2426,6 +2551,7 @@ function createReviewRunner(input) {
       }
       const execCode = await runExecute(void 0, {
         issue: issueNumber,
+        inPipeline: true,
         commitScope: queueCommitScope,
         ...executeRetry
       });
@@ -2433,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`);
@@ -2493,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) {
@@ -2596,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,
@@ -2626,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({
@@ -2722,8 +2866,10 @@ async function runPipeline(issue, mode, from, noBranch, prReview, options = {})
 }
 
 export {
+  persistClosureChoice,
+  finishIssueClosure,
   publishStorySeed,
   publishIssueDetails,
   runPipeline
 };
-//# sourceMappingURL=chunk-CWSQVHVV.js.map
+//# sourceMappingURL=chunk-QJHZ3HYJ.js.map