issue-flow 0.17.0 → 0.19.1

package/dist/{chunk-KZXQWC7U.js → chunk-XHCP6ZNO.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   ensureWebMonitor
-} from "./chunk-2SUFAE6X.js";
+} from "./chunk-PHPAK2L6.js";
+import {
+  groupBy,
+  summarize
+} from "./chunk-E2H3JV2E.js";
 import {
   applyAcceptanceToPlan,
   resolveIssueDir,
   runAcceptanceGate
-} from "./chunk-6YQT3SSM.js";
-import {
-  groupBy,
-  summarize
-} from "./chunk-CRGIQFUQ.js";
+} from "./chunk-IQYXXFRC.js";
 import {
   EXECUTE_PHASE,
   elapsedSecondsSince,
@@ -18,35 +18,32 @@ import {
   publishIterationMetrics,
   publishStoryMetrics,
   resolvePolicyPlaceholders
-} from "./chunk-HLAPOUEM.js";
+} from "./chunk-WB2FVIUS.js";
 import {
   applyPlaceholders,
   loadPrompt
-} from "./chunk-7F7LGMVO.js";
+} from "./chunk-XKR3VD2Z.js";
 import {
   invokeSelectedAgent
-} from "./chunk-UK4E2FUA.js";
-import {
-  getPackageVersion
-} from "./chunk-C5TL7T4V.js";
+} from "./chunk-MQTVMB7W.js";
 import {
   archiveFolderName,
   commitMessage
-} from "./chunk-E6KXCV3T.js";
+} from "./chunk-2Q6PG3MT.js";
+import {
+  getPackageVersion
+} from "./chunk-2YM2VH6R.js";
 import {
   createConfig,
   getActiveResilienceConfig,
   getShutdownSignal,
-  loadGlobalConfig,
   loadWebConfig,
   resolveAgentFor,
   resolvePaths,
   validateDependencies
-} from "./chunk-HY5HLFDU.js";
-import {
-  resolveIssuePaths
-} from "./chunk-DV7HUC4Z.js";
+} from "./chunk-UHDXXLYH.js";
 import {
+  MultiPublisher,
   formatDuration,
   getIcons,
   getInactivityTimeout,
@@ -55,33 +52,30 @@ import {
   getStoryUpdateCallback,
   getTermWidth,
   isVerbose,
+  loadGlobalConfig,
   printError,
   printInfo,
   printRetry,
   printSuccess,
   printWarning,
+  resolveIssuePaths,
   useColor,
   useUnicode
-} from "./chunk-XZUEFTUP.js";
-import {
-  committedStoryIds,
-  fixedBackoffPolicy,
-  getBaseBranch,
-  isWorkingTreeClean,
-  resolvePolicy,
-  withRetry
-} from "./chunk-YVPZUN6X.js";
+} from "./chunk-J6VJ5M2U.js";
 import {
+  DEFAULT_SESSION_HEARTBEAT_MS,
   FilePublisher,
+  MemoryPublisher,
   NullPublisher,
   getSessionPublisher,
   setSessionPublisher
-} from "./chunk-DUS5ZNKL.js";
+} from "./chunk-DIMDAYZS.js";
 import {
   allStoriesPass,
   applyStoryMetrics,
   clearLastError,
   divideUsage,
+  executionCompletion,
   formatTokens,
   hasPendingCorrection,
   initializeState,
@@ -93,18 +87,39 @@ import {
   selectActiveStory,
   setLastError,
   trimErrorMessage
-} from "./chunk-SOM4QA6C.js";
+} from "./chunk-GD7JZMSJ.js";
 import {
-  classify
-} from "./chunk-XEYH6ZZI.js";
+  executionContext,
+  inspectTaskPlan
+} from "./chunk-NP47HRX2.js";
+import {
+  getLastBranchRepository,
+  getPlanRepository,
+  ingestAgentPlan,
+  loadStoredLastBranch,
+  saveSessionEvent,
+  saveStoredLastBranch,
+  setAgentProjectionWindow,
+  touchStoredSession
+} from "./chunk-7MJGYPHF.js";
+import {
+  classify,
+  committedStoryIds,
+  fixedBackoffPolicy,
+  getBaseBranch,
+  getCurrentBranch,
+  isWorkingTreeClean,
+  resolvePolicy,
+  withRetry
+} from "./chunk-TJVX42KY.js";
 
 // src/commands/execute.ts
-import { randomUUID } from "crypto";
+import { randomUUID } from "node:crypto";
 
 // src/core/engine.ts
-import { existsSync } from "fs";
-import { cp, mkdir, readFile, writeFile } from "fs/promises";
-import { join } from "path";
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 
 // src/ui/progress.ts
 import chalk from "chalk";
@@ -602,16 +617,17 @@ Started: ${(/* @__PURE__ */ new Date()).toString()}
 }
 async function archiveIfBranchChanged(plan, paths) {
   const { lastBranchFile, archiveDir, prdFile, progressFile } = paths;
-  if (!existsSync(lastBranchFile)) {
-    return;
-  }
   const currentBranch = plan.branchName ?? "";
-  let lastBranch = "";
-  try {
-    lastBranch = (await readFile(lastBranchFile, "utf-8")).trim();
-  } catch {
-    return;
+  const repository = getLastBranchRepository(lastBranchFile);
+  let lastBranch = repository === void 0 ? null : await loadStoredLastBranch(repository);
+  if (lastBranch === null && existsSync(lastBranchFile)) {
+    try {
+      lastBranch = (await readFile(lastBranchFile, "utf-8")).trim() || null;
+    } catch {
+      return;
+    }
   }
+  if (lastBranch === null) return;
   if (currentBranch && lastBranch && currentBranch !== lastBranch) {
     const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const folderName = archiveFolderName(lastBranch);
@@ -638,10 +654,26 @@ Started: ${(/* @__PURE__ */ new Date()).toString()}
 async function trackBranch(plan, lastBranchFile) {
   const branch = plan.branchName ?? "";
   if (branch) {
+    const repository = getLastBranchRepository(lastBranchFile);
+    if (repository !== void 0) {
+      await saveStoredLastBranch(repository, branch);
+      return;
+    }
     await writeFile(lastBranchFile, `${branch}
 `, "utf-8");
   }
 }
+async function validateExecutionInput(plan) {
+  const result = inspectTaskPlan(plan);
+  if (!result.ok) return result.errors.map((error) => `${error.code}: ${error.message}`).join("\n");
+  if (plan.userStories.length === 0) return "Task plan has no stories";
+  if (plan.noBranch === true) {
+    const branch = await getCurrentBranch().catch(() => "");
+    if (!branch || branch !== plan.branchName)
+      return `Current branch must match ${plan.branchName}; refusing to switch in no-branch mode`;
+  }
+  return null;
+}
 async function runEngine(config, paths) {
   if (!existsSync(paths.prdFile)) {
     printError(`PRD file not found at ${paths.prdFile}`);
@@ -651,11 +683,17 @@ async function runEngine(config, paths) {
     return 1;
   }
   let plan = await loadTaskPlan(paths.prdFile);
+  const closure = { closeIssue: plan.closeIssue, issueClosedAt: plan.issueClosedAt };
+  const inputError = await validateExecutionInput(plan);
+  if (inputError) {
+    printError(inputError);
+    return 1;
+  }
   plan = initializeState(plan);
   await saveTaskPlan(paths.prdFile, plan);
-  if (plan.issueStatus === "completed" && allStoriesPass(plan) && !hasPendingCorrection(plan)) {
+  if (plan.issueStatus === "completed" && allStoriesPass(plan) && !hasPendingCorrection(plan) && !plan.lastError) {
     emitLog(`Issue already marked complete in ${paths.prdFile}`);
-    return 0;
+    return finishWithAcceptance(config, paths, plan);
   }
   if (plan.issueStatus === "completed" && !allStoriesPass(plan)) {
     printWarning(
@@ -669,9 +707,9 @@ async function runEngine(config, paths) {
     );
     await saveTaskPlan(paths.prdFile, plan);
   }
-  if (allStoriesPass(plan) && !hasPendingCorrection(plan)) {
+  if (allStoriesPass(plan) && !hasPendingCorrection(plan) && !plan.lastError) {
     emitLog("All user stories already pass. Marking issue as completed.");
-    plan = markIssueCompleted(plan);
+    plan = executionCompletion(markIssueCompleted(plan), config.inPipeline === true);
     await saveTaskPlan(paths.prdFile, plan);
     return finishWithAcceptance(config, paths, plan);
   }
@@ -679,7 +717,7 @@ async function runEngine(config, paths) {
   await trackBranch(plan, paths.lastBranchFile);
   await ensureProgressFile(paths.progressFile);
   const promptTemplate = await loadPrompt("execute", { projectRoot: paths.projectRoot });
-  const policy = await resolvePolicyPlaceholders({ root: paths.projectRoot });
+  const policy = await resolvePolicyPlaceholders({ root: paths.projectRoot, phase: "execute" });
   const signoff = (await loadGlobalConfig()).commit?.signoff === true;
   const executeAgent = await resolveAgentFor("execute");
   printStartupHeader(config, plan, {
@@ -701,13 +739,15 @@ async function runEngine(config, paths) {
         `Adopting ${adopted.join(", ")}: already committed on this branch with a clean tree.`
       );
       plan = await loadTaskPlan(paths.prdFile);
-      if (plan.userStories.every((story) => story.passes) && plan.lastReviewFindings === null) {
+      if (plan.userStories.every((story) => story.passes) && plan.lastReviewFindings === null && !plan.lastError) {
         break;
       }
     }
     const attempted = await withRetry(
       async () => {
         plan = await loadTaskPlan(paths.prdFile);
+        const inputError2 = await validateExecutionInput(plan);
+        if (inputError2) throw new Error(`Invalid task plan: ${inputError2}`);
         if (plan.userStories.length > 0) {
           getSessionPublisher().publish({
             type: "stories:update",
@@ -716,7 +756,8 @@ async function runEngine(config, paths) {
           });
         }
         const storiesBefore = plan.userStories;
-        const activeStoryId = selectActiveStory(plan.userStories)?.id;
+        const lastErrorBefore = plan.lastError;
+        const activeStoryId = hasPendingCorrection(plan) ? void 0 : selectActiveStory(plan.userStories)?.id;
         getSessionPublisher().publish({
           type: "iteration:start",
           at: isoNow(),
@@ -728,6 +769,10 @@ async function runEngine(config, paths) {
           printIterationHeader(i, config.maxIterations, plan.userStories, activeStoryId);
         }
         const prompt = applyPlaceholders(promptTemplate, {
+          __EXECUTION_CONTEXT__: JSON.stringify(executionContext(plan)),
+          __CORRECTION_MODE__: hasPendingCorrection(plan) ? "enabled" : "",
+          __ACTIVE_STORY__: activeStoryId ?? "Address pending review findings",
+          __EXECUTION_SCOPE__: config.inPipeline ? "This is one pipeline phase: keep issueStatus=in_progress and completedAt=null." : "Standalone execution may mark the issue completed after verification.",
           __PRD_FILE__: paths.prdFile,
           __PROGRESS_FILE__: paths.progressFile,
           ...policy,
@@ -743,17 +788,30 @@ async function runEngine(config, paths) {
         plan = markIssueInProgress(plan, startedAt);
         await saveTaskPlan(paths.prdFile, plan);
         const startedAtMs = Date.now();
-        const result2 = await executeClaude(prompt, {
-          ...inactivityOptions(),
-          iteration: i,
-          correctionCycle: plan.correctionCycle,
-          ...activeStoryId === void 0 ? {} : { storyIds: [activeStoryId] }
-        });
+        setAgentProjectionWindow(paths.prdFile, true);
+        let result2;
+        try {
+          result2 = await executeClaude(prompt, {
+            ...inactivityOptions(),
+            iteration: i,
+            correctionCycle: plan.correctionCycle,
+            ...activeStoryId === void 0 ? {} : { storyIds: [activeStoryId] }
+          });
+        } finally {
+          setAgentProjectionWindow(paths.prdFile, false);
+        }
+        const repository = getPlanRepository(paths.prdFile);
+        if (repository !== void 0) {
+          plan = await ingestAgentPlan(repository, plan);
+        } else {
+          plan = { ...await loadTaskPlan(paths.prdFile), ...closure };
+          await saveTaskPlan(paths.prdFile, plan);
+        }
         const seconds = elapsedSecondsSince(startedAtMs);
         if (result2.exitCode !== 0) {
           publishIterationMetrics(i, result2.cost, seconds);
         }
-        return { result: result2, startedAt, seconds, storiesBefore };
+        return { result: result2, startedAt, seconds, storiesBefore, lastErrorBefore };
       },
       {
         policy: executeRetryPolicy(config),
@@ -831,6 +889,22 @@ async function runEngine(config, paths) {
       return result.exitCode;
     }
     plan = await loadTaskPlan(paths.prdFile);
+    const outputError = await validateExecutionInput(plan);
+    if (outputError) {
+      printError(`Invalid execution result: ${outputError}`);
+      return 1;
+    }
+    if (plan.lastError && (JSON.stringify(plan.lastError) !== JSON.stringify(attempted.value.lastErrorBefore) || ![
+      "fatal_claude_failure",
+      "transient_claude_failure",
+      "invalid_completion_signal",
+      "task_execution"
+    ].includes(plan.lastError.category))) {
+      publishIterationMetrics(i, result.cost, iterationSeconds);
+      getSessionPublisher().publish({ type: "iteration:end", at: isoNow(), iteration: i });
+      printError(`Execution blocked: ${plan.lastError.message}`);
+      return 1;
+    }
     plan = clearLastError(plan, iterationStartedAt);
     await saveTaskPlan(paths.prdFile, plan);
     const storyUpdateCb = getStoryUpdateCallback();
@@ -861,7 +935,7 @@ async function runEngine(config, paths) {
     if (result.output.includes("<promise>COMPLETE</promise>")) {
       plan = await loadTaskPlan(paths.prdFile);
       if (allStoriesPass(plan) && !hasPendingCorrection(plan)) {
-        plan = markIssueCompleted(plan);
+        plan = executionCompletion(markIssueCompleted(plan), config.inPipeline === true);
         await saveTaskPlan(paths.prdFile, plan);
         const elapsed2 = Math.floor((Date.now() - startTime) / 1e3);
         printSummaryBox(
@@ -916,9 +990,61 @@ async function finishWithAcceptance(config, paths, plan) {
     await saveTaskPlan(paths.prdFile, applied.plan);
     return 1;
   }
+  await saveTaskPlan(
+    paths.prdFile,
+    executionCompletion(markIssueCompleted(applied.plan), config.inPipeline === true)
+  );
   return 0;
 }
 
+// src/storage/db/session-publisher.ts
+var SqliteSessionPublisher = class extends MemoryPublisher {
+  context;
+  writeChain = Promise.resolve();
+  heartbeatTimer;
+  closed = false;
+  constructor(context, options = {}) {
+    super(options);
+    this.context = context;
+    this.heartbeatTimer = setInterval(() => this.enqueueHeartbeat(), DEFAULT_SESSION_HEARTBEAT_MS);
+    this.heartbeatTimer.unref();
+  }
+  afterPublish(event) {
+    if (this.closed) return;
+    const sessionId = this.snapshot().sessionId;
+    if (sessionId === null) return;
+    const snapshot = this.snapshot();
+    const sequence = this.version();
+    this.writeChain = this.writeChain.then(async () => {
+      try {
+        await saveSessionEvent(this.context, { sessionId, sequence, event, snapshot });
+      } catch (error) {
+        this.warnOnce(error);
+      }
+    });
+  }
+  async flush() {
+    await this.writeChain;
+  }
+  async close() {
+    this.closed = true;
+    clearInterval(this.heartbeatTimer);
+    await this.flush();
+  }
+  enqueueHeartbeat() {
+    if (this.closed) return;
+    const sessionId = this.snapshot().sessionId;
+    if (sessionId === null || this.snapshot().status !== "running") return;
+    this.writeChain = this.writeChain.then(async () => {
+      try {
+        await touchStoredSession(this.context, sessionId);
+      } catch (error) {
+        this.warnOnce(error);
+      }
+    });
+  }
+};
+
 // src/commands/execute.ts
 async function runExecute(positionalMaxIter, options) {
   const errors = await validateDependencies();
@@ -932,6 +1058,7 @@ async function runExecute(positionalMaxIter, options) {
   const maxIterations = options.maxIterations ?? positionalMaxIter;
   const config = createConfig({
     issueNumber: options.issue,
+    inPipeline: options.inPipeline,
     maxIterations,
     retryLimit: options.retryLimit,
     retryForever: options.retryForever,
@@ -945,13 +1072,22 @@ async function runExecute(positionalMaxIter, options) {
     const issuePaths = await resolveIssuePaths(config.issueNumber, {
       projectRoot: paths.projectRoot
     });
-    standalonePublisher = new FilePublisher(issuePaths.sessionFile, {
+    const filePublisher = new FilePublisher(issuePaths.sessionFile, {
       logLimit: webConfig.logLimit,
       includeLogs: webConfig.includeLogs
     });
-    setSessionPublisher(standalonePublisher);
+    const repository = getPlanRepository(issuePaths.tasksFile);
+    const publisher = repository === void 0 ? filePublisher : new MultiPublisher([
+      new SqliteSessionPublisher(repository, {
+        logLimit: webConfig.logLimit,
+        includeLogs: webConfig.includeLogs
+      }),
+      filePublisher
+    ]);
+    standalonePublisher = publisher;
+    setSessionPublisher(publisher);
     const numericIssue2 = /^\d+$/.test(config.issueNumber) ? Number(config.issueNumber) : null;
-    standalonePublisher.publish({
+    publisher.publish({
       type: "session:start",
       at: isoNow(),
       sessionId: randomUUID(),
@@ -967,10 +1103,10 @@ async function runExecute(positionalMaxIter, options) {
         cliVersion: getPackageVersion()
       }
     });
-    standalonePublisher.publish({ type: "phase:start", at: isoNow(), phase: "execute" });
+    publisher.publish({ type: "phase:start", at: isoNow(), phase: "execute" });
     await ensureWebMonitor(
       {
-        publisher: standalonePublisher,
+        publisher,
         port: webConfig.port,
         host: webConfig.host,
         refreshSeconds: webConfig.refreshSeconds
@@ -1017,6 +1153,7 @@ export {
   printQueueSummary,
   printRunSummary,
   stripMarkdown,
+  SqliteSessionPublisher,
   runExecute
 };
-//# sourceMappingURL=chunk-KZXQWC7U.js.map
+//# sourceMappingURL=chunk-XHCP6ZNO.js.map