issue-flow 0.11.1 → 0.13.0

package/dist/{chunk-6N7LZZ5U.js → chunk-LZ6GFQAG.js}

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 import {
-  publishGitState
-} from "./chunk-LVKQ2AKT.js";
+  ensureWebMonitor
+} from "./chunk-IHIEXUTC.js";
 import {
-  isTransientFailure,
-  retryDelaySeconds,
-  sleep
-} from "./chunk-HDV3YDTG.js";
+  applyAcceptanceToPlan,
+  resolveIssueDir,
+  runAcceptanceGate
+} from "./chunk-BQDQTIM7.js";
+import {
+  groupBy,
+  summarize
+} from "./chunk-CRGIQFUQ.js";
 import {
   EXECUTE_PHASE,
   elapsedSecondsSince,
@@ -14,49 +18,83 @@ import {
   publishIterationMetrics,
   publishStoryMetrics,
   resolvePolicyPlaceholders
-} from "./chunk-OBLVLIUS.js";
+} from "./chunk-664Y3NDX.js";
 import {
   applyPlaceholders,
   loadPrompt
-} from "./chunk-HQYXVIH6.js";
+} from "./chunk-MIVHK5YI.js";
+import {
+  invokeSelectedAgent
+} from "./chunk-ARFVHC2F.js";
+import {
+  archiveFolderName,
+  commitMessage
+} from "./chunk-UOCPC2Y2.js";
 import {
   createConfig,
+  getActiveResilienceConfig,
+  getShutdownSignal,
+  loadGlobalConfig,
+  loadWebConfig,
+  resolveAgentFor,
   resolvePaths,
   validateDependencies
-} from "./chunk-VQ5VN7DF.js";
+} from "./chunk-CNBYCMSU.js";
 import {
-  allStoriesPass,
-  applyStoryMetrics,
-  clearLastError,
-  divideUsage,
+  resolveIssuePaths
+} from "./chunk-HQAHNIAR.js";
+import {
+  FilePublisher,
+  NullPublisher,
   formatDuration,
-  formatTokens,
   getIcons,
+  getInactivityTimeout,
   getOutputCallback,
   getSessionPublisher,
   getStoryStageCallback,
   getStoryUpdateCallback,
   getTermWidth,
-  hasPendingCorrection,
-  initializeState,
   isVerbose,
-  isoNow,
-  loadTaskPlan,
-  markIssueCompleted,
-  markIssueInProgress,
-  parseUsage,
   printError,
   printInfo,
   printRetry,
   printSuccess,
   printWarning,
+  setSessionPublisher,
+  useColor,
+  useUnicode
+} from "./chunk-IYV6KNVF.js";
+import {
+  allStoriesPass,
+  applyStoryMetrics,
+  clearLastError,
+  divideUsage,
+  formatTokens,
+  hasPendingCorrection,
+  initializeState,
+  isoNow,
+  loadTaskPlan,
+  markIssueCompleted,
+  markIssueInProgress,
   saveTaskPlan,
   selectActiveStory,
   setLastError,
-  trimErrorMessage,
-  useColor,
-  useUnicode
-} from "./chunk-HC2MT7BX.js";
+  trimErrorMessage
+} from "./chunk-DIG5XKQQ.js";
+import {
+  committedStoryIds,
+  fixedBackoffPolicy,
+  getBaseBranch,
+  isWorkingTreeClean,
+  resolvePolicy,
+  withRetry
+} from "./chunk-KQHB7ZT3.js";
+import {
+  classify
+} from "./chunk-XEYH6ZZI.js";
+
+// src/commands/execute.ts
+import { randomUUID } from "crypto";
 
 // src/core/engine.ts
 import { existsSync } from "fs";
@@ -173,7 +211,7 @@ function printBox(lines) {
   }
   console.log(blue(`${bl}${hrule}${br}`));
 }
-function printStartupHeader(config, plan) {
+function printStartupHeader(config, plan, agent) {
   const icons = getIcons();
   const storiesTotal = plan.userStories.length;
   const storiesPassing = plan.userStories.filter((s) => s.passes).length;
@@ -181,7 +219,7 @@ function printStartupHeader(config, plan) {
   const issueLabel = config.issueNumber ? `Issue #${config.issueNumber}` : "Standalone mode";
   const maxIterLabel = config.maxIterations !== void 0 ? String(config.maxIterations) : "unlimited";
   const retryLabel = config.retryForever ? "unlimited retries" : `${config.retryLimit} consecutive retries`;
-  printBox([
+  const lines = [
     `${icons.start} Issue Flow`,
     "---",
     `Issue:       ${issueLabel}`,
@@ -189,9 +227,22 @@ function printStartupHeader(config, plan) {
     `Stories:     ${storiesPassing}/${storiesTotal} passing`,
     `Iterations:  ${maxIterLabel}`,
     `Retries:     ${retryLabel}`
-  ]);
+  ];
+  const remaining = storiesTotal - storiesPassing;
+  if (remaining > 0) {
+    const p50ExecuteSeconds = 518;
+    lines.push(
+      `Estimate:    ~${formatDuration(remaining * p50ExecuteSeconds)} (${remaining} \xD7 p50 execute)`
+    );
+  }
+  if (agent) {
+    const model = agent.model ? ` \xB7 ${agent.model}` : "";
+    const detail = agent.detail ? ` (${agent.detail})` : "";
+    lines.push(`Agent:       ${agent.provider}${model}${detail}`);
+  }
+  printBox(lines);
 }
-function printSummaryBox(status, iterations, totalRetries, elapsedSeconds, plan, extraInfo, usage) {
+function printSummaryBox(status, iterations, totalRetries, elapsedSeconds, plan, extraInfo, usage, usageByAgent) {
   const icons = getIcons();
   const storiesTotal = plan.userStories.length;
   const storiesPassing = plan.userStories.filter((s) => s.passes).length;
@@ -220,10 +271,8 @@ function printSummaryBox(status, iterations, totalRetries, elapsedSeconds, plan,
     `Iterations:  ${iterations}`,
     `Duration:    ${duration}`
   ];
-  const tokens = formatTokens(usage);
-  if (tokens !== "") {
-    boxLines.push(`Tokens:      ${tokens}`);
-  }
+  boxLines.push(...tokenBoxLines(usage, usageByAgent));
+  boxLines.push(...executionCostLines(plan));
   boxLines.push(`Retries:     ${totalRetries}`);
   if (extraInfo) {
     boxLines.push("---");
@@ -232,19 +281,79 @@ function printSummaryBox(status, iterations, totalRetries, elapsedSeconds, plan,
   console.log("");
   printBox(boxLines);
 }
+function executionCostLines(plan, prefix = "Cost:        ") {
+  const records = plan.executions ?? [];
+  if (records.length === 0) return [];
+  const lines = [];
+  const groups = groupBy(records, "harness");
+  let index = 0;
+  const pad = " ".repeat(prefix.length);
+  for (const [harness, summary] of groups) {
+    const parts = [];
+    if (summary.totalCost.reported > 0) {
+      parts.push(`$${summary.totalCost.reported.toFixed(4)} reported`);
+    }
+    if (summary.totalCost.estimated > 0) {
+      parts.push(`$${summary.totalCost.estimated.toFixed(4)} estimated`);
+    }
+    if (summary.totalCost.unknownExecutions > 0) {
+      parts.push(`${summary.totalCost.unknownExecutions} unknown`);
+    }
+    if (parts.length === 0) {
+      const totals = summarize(records).totalCost;
+      if (totals.reported === 0 && totals.estimated === 0) {
+        parts.push("not reported");
+      }
+    }
+    if (parts.length === 0) continue;
+    lines.push(`${index === 0 ? prefix : pad}${harness} \xB7 ${parts.join(" \xB7 ")}`);
+    index += 1;
+  }
+  return lines;
+}
+function tokenBoxLines(usage, usageByAgent) {
+  const agents = usageByAgent ? Object.keys(usageByAgent) : [];
+  if (agents.length > 1) {
+    const lines = [];
+    for (const [index, id] of agents.entries()) {
+      const tokens2 = formatTokens(usageByAgent?.[id]);
+      if (tokens2 === "") continue;
+      lines.push(index === 0 ? `Tokens:      ${id} \xB7 ${tokens2}` : `             ${id} \xB7 ${tokens2}`);
+    }
+    return lines;
+  }
+  const tokens = formatTokens(usage);
+  return tokens === "" ? [] : [`Tokens:      ${tokens}`];
+}
+function tokenSummaryLines(usage, usageByAgent, prefix = "  Tokens:   ") {
+  const agents = usageByAgent ? Object.keys(usageByAgent) : [];
+  if (agents.length > 1) {
+    const pad = " ".repeat(prefix.length);
+    const lines = [];
+    for (const [index, id] of agents.entries()) {
+      const tokens2 = formatTokens(usageByAgent?.[id]);
+      if (tokens2 === "") continue;
+      lines.push(`${index === 0 ? prefix : pad}${id} \xB7 ${tokens2}`);
+    }
+    return lines;
+  }
+  const tokens = formatTokens(usage);
+  return tokens === "" ? [] : [`${prefix}${tokens}`];
+}
 function buildRunSummaryLines(info) {
   const lines = [
     `  Branch:   ${info.branchName}${info.noBranch ? " (current)" : ""}`,
     `  Stories:  ${info.storyCount}`,
     `  Duration: ${formatDuration(info.elapsedSeconds)}`
   ];
-  const tokens = formatTokens(info.usage);
-  if (tokens !== "") {
-    lines.push(`  Tokens:   ${tokens}`);
-  }
+  lines.push(...tokenSummaryLines(info.usage, info.usageByAgent));
   if (!info.noBranch) {
     lines.push(`  PR:       ${info.prUrl}`);
   }
+  if (info.verification != null) {
+    const label = info.verification.verdict === "passed" ? "passed" : info.verification.verdict === "failed" ? "failed" : "unverified";
+    lines.push(`  Contract: ${label}`);
+  }
   const review = info.prReview;
   if (review) {
     const verdict = review.recommendation ?? (review.requestedChanges ? "REQUEST_CHANGES" : "unknown");
@@ -305,6 +414,14 @@ function printRunSummary(info) {
     printWarning(
       `Pipeline finished for issue #${info.issueNumber}, but the PR review requested changes.`
     );
+  } else if (info.verification?.verdict === "unverified") {
+    printWarning(
+      `Pipeline finished for issue #${info.issueNumber}, but the acceptance contract is unverified.`
+    );
+  } else if (info.verification?.verdict === "failed") {
+    printWarning(
+      `Pipeline finished for issue #${info.issueNumber}, but the acceptance contract failed.`
+    );
   } else {
     printSuccess(`Pipeline complete for issue #${info.issueNumber}!`);
   }
@@ -313,48 +430,65 @@ function printRunSummary(info) {
   }
 }
 
+// src/ui/text.ts
+function stripMarkdown(text) {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/^\s*[-*+]\s+/gm, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[ \t]{2,}/g, " ").trim();
+}
+function failureExcerpt(output, limit = 8) {
+  return output.split("\n").map((line) => stripMarkdown(line)).filter((line) => line.length > 0).slice(-limit);
+}
+
 // src/core/executor.ts
-import { execa } from "execa";
-async function executeClaude(prompt) {
-  const result = await execa(
-    "claude",
-    ["--dangerously-skip-permissions", "--print", "--output-format", "json"],
-    {
-      input: prompt,
-      reject: false,
+async function executeClaude(prompt, options = {}) {
+  let selected;
+  try {
+    selected = await invokeSelectedAgent({
+      prompt,
+      phase: "execute",
       timeout: 0,
-      // No timeout — let the engine handle iteration limits
-      stripFinalNewline: false
-    }
-  );
-  const stdout = result.stdout?.toString() ?? "";
-  const stderr = result.stderr?.toString() ?? "";
-  const exitCode = result.exitCode ?? 1;
-  let output = stdout + (stderr ? `
-${stderr}` : "");
-  let cost = null;
-  if (exitCode === 0) {
-    try {
-      const parsed = JSON.parse(stdout);
-      const text = parsed?.result;
-      output = typeof text === "string" ? text : stdout;
-      cost = parseUsage(parsed);
-    } catch {
-    }
-  }
-  const onOutput = getOutputCallback();
-  if (onOutput) {
-    const trimmed = output.trim();
-    if (trimmed) {
-      onOutput(trimmed);
-    }
+      permission: "autonomous",
+      inactivityTimeoutMs: options.inactivityTimeoutMs
+    });
+  } catch (err) {
+    return {
+      exitCode: 1,
+      output: err instanceof Error ? err.message : String(err),
+      cost: null
+    };
+  }
+  const { run } = selected;
+  let output;
+  let cost = run.usage;
+  if (!run.success || run.exitCode !== 0) {
+    output = run.rawOutput || run.error || "";
+    cost = null;
+  } else {
+    output = run.result || run.rawOutput;
   }
+  emitAgentOutput(output, !(run.success && run.exitCode === 0));
   return {
-    exitCode,
+    exitCode: run.exitCode === 0 && run.success ? 0 : run.exitCode === 0 ? 1 : run.exitCode,
     output,
     cost
   };
 }
+function emitAgentOutput(output, failed) {
+  const onOutput = getOutputCallback();
+  if (!onOutput) return;
+  const trimmed = output.trim();
+  if (!trimmed) return;
+  if (isVerbose()) {
+    for (const line of trimmed.split("\n")) {
+      if (line.trim()) onOutput(line);
+    }
+    return;
+  }
+  if (failed) {
+    for (const line of failureExcerpt(trimmed)) {
+      onOutput(line);
+    }
+  }
+}
 
 // src/core/engine.ts
 function emitLog(message) {
@@ -367,18 +501,88 @@ function emitLog(message) {
     console.log(message);
   }
 }
+function executeRetryPolicy(config) {
+  return fixedBackoffPolicy(
+    config.retryLimit + 1,
+    config.backoffBaseSeconds,
+    config.backoffMaxSeconds,
+    { retryForever: config.retryForever }
+  );
+}
 function newlyCompletedStoryIds(before, after) {
   const wasPassing = new Map(before.map((story) => [story.id, story.passes]));
   return after.filter((story) => story.passes && wasPassing.get(story.id) === false).map((story) => story.id);
 }
-function commitPlaceholders(scope, convention) {
-  const suffix = scope === void 0 || scope === "" ? "" : `(${scope})`;
+function numericIssue(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function commitPlaceholders(scope, convention, options) {
   const declared = convention !== void 0 && convention !== null && convention !== "";
+  const type = options?.type ?? "feat";
+  const issueNumber = numericIssue(options?.issueNumber);
+  const resolvedScope = scope === void 0 || scope === "" ? void 0 : scope;
+  if (declared && options?.type === void 0) {
+    const suffix = resolvedScope === void 0 ? "" : `(${resolvedScope})`;
+    return {
+      __COMMIT_MESSAGE__: commitMessage({
+        type,
+        scope: resolvedScope,
+        subject: "[Story ID] - [Story Title]",
+        issueNumber,
+        signoff: options?.signoff
+      }).replace(`${type}${suffix}:`, `<type>${suffix}:`),
+      __FIX_COMMIT_MESSAGE__: commitMessage({
+        type: "fix",
+        scope: resolvedScope,
+        subject: "address review findings",
+        issueNumber,
+        signoff: options?.signoff
+      })
+    };
+  }
   return {
-    __COMMIT_MESSAGE__: declared ? `<type>${suffix}: [Story ID] - [Story Title]` : `feat${suffix}: [Story ID] - [Story Title]`,
-    __FIX_COMMIT_MESSAGE__: `fix${suffix}: address review findings`
+    __COMMIT_MESSAGE__: commitMessage({
+      type,
+      scope: resolvedScope,
+      subject: "[Story ID] - [Story Title]",
+      issueNumber,
+      signoff: options?.signoff
+    }),
+    __FIX_COMMIT_MESSAGE__: commitMessage({
+      type: "fix",
+      scope: resolvedScope,
+      subject: "address review findings",
+      issueNumber,
+      signoff: options?.signoff
+    })
   };
 }
+function inactivityOptions() {
+  const configured = getInactivityTimeout();
+  return configured === void 0 ? {} : { inactivityTimeoutMs: configured };
+}
+async function adoptCommittedStories(tasksPath) {
+  try {
+    const plan = await loadTaskPlan(tasksPath);
+    const pending = plan.userStories.filter((story) => !story.passes);
+    if (pending.length === 0) return [];
+    if (!await isWorkingTreeClean()) return [];
+    const committed = await committedStoryIds(await getBaseBranch());
+    const adopted = pending.filter((story) => committed.has(story.id)).map((story) => story.id);
+    if (adopted.length === 0) return [];
+    await saveTaskPlan(tasksPath, {
+      ...plan,
+      userStories: plan.userStories.map(
+        (story) => adopted.includes(story.id) ? { ...story, passes: true } : story
+      )
+    });
+    return adopted;
+  } catch {
+    return [];
+  }
+}
 async function ensureProgressFile(progressFile) {
   if (!existsSync(progressFile)) {
     const content = `# Issue Flow Progress Log
@@ -402,7 +606,7 @@ async function archiveIfBranchChanged(plan, paths) {
   }
   if (currentBranch && lastBranch && currentBranch !== lastBranch) {
     const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const folderName = lastBranch.replace(/^issue\//, "").replace(/[<>:"|?*\\]/g, "_");
+    const folderName = archiveFolderName(lastBranch);
     const archiveFolder = join(archiveDir, `${dateStr}-${folderName}`);
     printInfo(`Archiving previous run: ${lastBranch}`);
     await mkdir(archiveFolder, { recursive: true });
@@ -461,111 +665,158 @@ async function runEngine(config, paths) {
     emitLog("All user stories already pass. Marking issue as completed.");
     plan = markIssueCompleted(plan);
     await saveTaskPlan(paths.prdFile, plan);
-    return 0;
+    return finishWithAcceptance(config, paths, plan);
   }
   await archiveIfBranchChanged(plan, 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 });
-  printStartupHeader(config, plan);
+  const signoff = (await loadGlobalConfig()).commit?.signoff === true;
+  const executeAgent = await resolveAgentFor("execute");
+  printStartupHeader(config, plan, {
+    provider: executeAgent.provider,
+    model: executeAgent.model,
+    ...executeAgent.codex.reasoningEffort ? { detail: executeAgent.codex.reasoningEffort } : {}
+  });
   const startTime = Date.now();
   let i = 0;
-  let retryCount = 0;
   let totalRetryCount = 0;
   while (true) {
     if (config.maxIterations !== void 0 && i >= config.maxIterations) {
       break;
     }
     i++;
-    plan = await loadTaskPlan(paths.prdFile);
-    const storiesBeforeIteration = plan.userStories;
-    const activeStoryId = selectActiveStory(plan.userStories)?.id;
-    getSessionPublisher().publish({
-      type: "iteration:start",
-      at: isoNow(),
-      iteration: i,
-      storyId: activeStoryId
-    });
-    getStoryStageCallback()?.(activeStoryId);
-    if (isVerbose()) {
-      printIterationHeader(i, config.maxIterations, plan.userStories, activeStoryId);
+    const adopted = await adoptCommittedStories(paths.prdFile);
+    if (adopted.length > 0) {
+      printInfo(
+        `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) {
+        break;
+      }
     }
-    const prompt = applyPlaceholders(promptTemplate, {
-      __PRD_FILE__: paths.prdFile,
-      __PROGRESS_FILE__: paths.progressFile,
-      ...policy,
-      // The convention comes off the projection above rather than from a second
-      // discovery: one resolution per run is the whole point of the cache.
-      ...commitPlaceholders(config.commitScope, policy.__COMMIT_CONVENTION__)
-    });
-    const iterationStartedAt = isoNow();
-    plan = markIssueInProgress(plan, iterationStartedAt);
-    await saveTaskPlan(paths.prdFile, plan);
-    const iterationStartedAtMs = Date.now();
-    const result = await executeClaude(prompt);
-    const iterationSeconds = elapsedSecondsSince(iterationStartedAtMs);
-    if (result.exitCode !== 0) {
-      publishIterationMetrics(i, result.cost, iterationSeconds);
-      const errorMessage = trimErrorMessage(result.output);
-      if (isTransientFailure(result.exitCode, result.output)) {
-        retryCount++;
-        totalRetryCount++;
+    const attempted = await withRetry(
+      async () => {
         plan = await loadTaskPlan(paths.prdFile);
-        plan = setLastError(plan, "transient_claude_failure", errorMessage);
-        await saveTaskPlan(paths.prdFile, plan);
-        if (!config.retryForever && retryCount > config.retryLimit) {
-          const elapsed3 = Math.floor((Date.now() - startTime) / 1e3);
-          plan = await loadTaskPlan(paths.prdFile);
-          printSummaryBox(
-            "failed",
-            i,
-            totalRetryCount,
-            elapsed3,
-            plan,
-            `Exceeded retry limit (${config.retryLimit}) on transient errors`,
-            getPhaseUsageTotals(EXECUTE_PHASE)
-          );
-          return result.exitCode;
+        if (plan.userStories.length > 0) {
+          getSessionPublisher().publish({
+            type: "stories:update",
+            at: isoNow(),
+            stories: plan.userStories
+          });
         }
-        const delaySeconds = retryDelaySeconds(
-          retryCount,
-          config.backoffBaseSeconds,
-          config.backoffMaxSeconds
-        );
+        const storiesBefore = plan.userStories;
+        const activeStoryId = selectActiveStory(plan.userStories)?.id;
         getSessionPublisher().publish({
-          type: "retry",
+          type: "iteration:start",
           at: isoNow(),
-          attempt: retryCount,
-          delaySeconds,
-          reason: "transient_claude_failure"
+          iteration: i,
+          storyId: activeStoryId
         });
+        getStoryStageCallback()?.(activeStoryId);
         if (isVerbose()) {
-          emitLog("");
+          printIterationHeader(i, config.maxIterations, plan.userStories, activeStoryId);
+        }
+        const prompt = applyPlaceholders(promptTemplate, {
+          __PRD_FILE__: paths.prdFile,
+          __PROGRESS_FILE__: paths.progressFile,
+          ...policy,
+          // The convention comes off the projection above rather than from a second
+          // discovery: one resolution per run is the whole point of the cache.
+          ...commitPlaceholders(config.commitScope, policy.__COMMIT_CONVENTION__, {
+            issueNumber: plan.issueNumber,
+            signoff
+          }),
+          __STORIES_PER_ITERATION__: String(config.storiesPerIteration ?? 1)
+        });
+        const startedAt = isoNow();
+        plan = markIssueInProgress(plan, startedAt);
+        await saveTaskPlan(paths.prdFile, plan);
+        const startedAtMs = Date.now();
+        const result2 = await executeClaude(prompt, inactivityOptions());
+        const seconds = elapsedSecondsSince(startedAtMs);
+        if (result2.exitCode !== 0) {
+          publishIterationMetrics(i, result2.cost, seconds);
+        }
+        return { result: result2, startedAt, seconds, storiesBefore };
+      },
+      {
+        policy: executeRetryPolicy(config),
+        // A `Ctrl+C` during a fifteen-minute backoff must stop in that instant,
+        // not fifteen minutes later. `abortableDelay` resolves `false` on the
+        // abort, which `withRetry` reports as `aborted` rather than a failure.
+        signal: getShutdownSignal(),
+        // The exit code and the output are all the evidence the CLI leaves
+        // behind, which is exactly what `isTransientFailure()` used to be given
+        // here — `classify()` is the same verdict plus the kind.
+        evaluate: ({ result: result2 }) => result2.exitCode === 0 ? null : classify({ source: "agent", exitCode: result2.exitCode, stdout: result2.output }),
+        onAttempt: async ({ value, attempt, failure, willRetry, delayMs }) => {
+          if (failure === null) return;
+          const errorMessage = trimErrorMessage(value.result.output);
+          if (!failure.retryable) {
+            plan = await loadTaskPlan(paths.prdFile);
+            plan = setLastError(plan, "fatal_claude_failure", errorMessage);
+            if (resolvePolicy(failure.kind, getActiveResilienceConfig()).onExhausted === "block") {
+              plan = {
+                ...plan,
+                runState: {
+                  currentPhase: "execute",
+                  attempt,
+                  owner: plan.runState?.owner ?? null,
+                  status: "blocked",
+                  blockedReason: errorMessage,
+                  lastHeartbeatAt: isoNow()
+                }
+              };
+            }
+            await saveTaskPlan(paths.prdFile, plan);
+            return;
+          }
+          totalRetryCount++;
+          plan = await loadTaskPlan(paths.prdFile);
+          plan = setLastError(plan, "transient_claude_failure", errorMessage);
+          await saveTaskPlan(paths.prdFile, plan);
+          if (!willRetry) return;
+          const delaySeconds = delayMs / 1e3;
+          getSessionPublisher().publish({
+            type: "retry",
+            at: isoNow(),
+            attempt,
+            delaySeconds,
+            reason: "transient_claude_failure",
+            kind: failure.kind
+          });
+          if (isVerbose()) {
+            emitLog("");
+          }
+          printRetry(
+            `Transient Claude failure on iteration ${i} (attempt ${attempt}). Retrying in ${delaySeconds}s.`
+          );
         }
-        printRetry(
-          `Transient Claude failure on iteration ${i} (attempt ${retryCount}). Retrying in ${delaySeconds}s.`
-        );
-        i--;
-        await sleep(delaySeconds);
-        continue;
       }
-      plan = await loadTaskPlan(paths.prdFile);
-      plan = setLastError(plan, "fatal_claude_failure", errorMessage);
-      await saveTaskPlan(paths.prdFile, plan);
+    );
+    const {
+      result,
+      seconds: iterationSeconds,
+      storiesBefore: storiesBeforeIteration
+    } = attempted.value;
+    const iterationStartedAt = attempted.value.startedAt;
+    if (result.exitCode !== 0) {
       const elapsed2 = Math.floor((Date.now() - startTime) / 1e3);
+      plan = await loadTaskPlan(paths.prdFile);
       printSummaryBox(
         "failed",
         i,
         totalRetryCount,
         elapsed2,
         plan,
-        `Claude CLI failed with exit code ${result.exitCode}`,
+        attempted.exhausted ? `Exceeded retry limit (${config.retryLimit}) on transient errors` : `Claude CLI failed with exit code ${result.exitCode}`,
         getPhaseUsageTotals(EXECUTE_PHASE)
       );
       return result.exitCode;
     }
-    retryCount = 0;
     plan = await loadTaskPlan(paths.prdFile);
     plan = clearLastError(plan, iterationStartedAt);
     await saveTaskPlan(paths.prdFile, plan);
@@ -594,7 +845,6 @@ async function runEngine(config, paths) {
     }
     getSessionPublisher().publish({ type: "iteration:end", at: isoNow(), iteration: i });
     publishIterationMetrics(i, result.cost, iterationSeconds);
-    await publishGitState(getSessionPublisher());
     if (result.output.includes("<promise>COMPLETE</promise>")) {
       plan = await loadTaskPlan(paths.prdFile);
       if (allStoriesPass(plan) && !hasPendingCorrection(plan)) {
@@ -610,7 +860,7 @@ async function runEngine(config, paths) {
           void 0,
           getPhaseUsageTotals(EXECUTE_PHASE)
         );
-        return 0;
+        return finishWithAcceptance(config, paths, plan);
       }
       plan = setLastError(
         plan,
@@ -626,7 +876,6 @@ async function runEngine(config, paths) {
     if (isVerbose()) {
       printSuccess(`Iteration ${i} complete. Continuing...`);
     }
-    await sleep(2);
   }
   const elapsed = Math.floor((Date.now() - startTime) / 1e3);
   plan = await loadTaskPlan(paths.prdFile);
@@ -641,6 +890,21 @@ async function runEngine(config, paths) {
   );
   return 1;
 }
+async function finishWithAcceptance(config, paths, plan) {
+  const issueDir = resolveIssueDir(config, paths);
+  const outcome = await runAcceptanceGate({
+    issueDir,
+    cwd: paths.projectRoot,
+    addDirs: config.issueNumber === void 0 ? void 0 : [issueDir],
+    skipReviewer: true
+  });
+  const applied = applyAcceptanceToPlan(plan, outcome);
+  if (applied.failed) {
+    await saveTaskPlan(paths.prdFile, applied.plan);
+    return 1;
+  }
+  return 0;
+}
 
 // src/commands/execute.ts
 async function runExecute(positionalMaxIter, options) {
@@ -661,23 +925,73 @@ async function runExecute(positionalMaxIter, options) {
     commitScope: options.commitScope
   });
   const paths = await resolvePaths(config);
-  const exitCode = await runEngine(config, paths);
-  if (exitCode === 0 && config.issueNumber) {
-    try {
-      const plan = await loadTaskPlan(paths.prdFile);
-      if (allStoriesPass(plan)) {
-        plan.pipeline.executionCompleted = true;
-        await saveTaskPlan(paths.prdFile, plan);
+  const webConfig = await loadWebConfig();
+  const inheritedPublisher = getSessionPublisher();
+  let standalonePublisher = null;
+  if (webConfig.enabled && config.issueNumber !== void 0 && inheritedPublisher instanceof NullPublisher) {
+    const issuePaths = await resolveIssuePaths(config.issueNumber, {
+      projectRoot: paths.projectRoot
+    });
+    standalonePublisher = new FilePublisher(issuePaths.sessionFile, {
+      logLimit: webConfig.logLimit,
+      includeLogs: webConfig.includeLogs
+    });
+    setSessionPublisher(standalonePublisher);
+    const numericIssue2 = /^\d+$/.test(config.issueNumber) ? Number(config.issueNumber) : null;
+    standalonePublisher.publish({
+      type: "session:start",
+      at: isoNow(),
+      sessionId: randomUUID(),
+      issueNumber: numericIssue2,
+      phases: ["execute"]
+    });
+    standalonePublisher.publish({ type: "phase:start", at: isoNow(), phase: "execute" });
+    await ensureWebMonitor({
+      publisher: standalonePublisher,
+      port: webConfig.port,
+      host: webConfig.host,
+      refreshSeconds: webConfig.refreshSeconds
+    });
+  }
+  let exitCode = null;
+  try {
+    exitCode = await runEngine(config, paths);
+    if (exitCode === 0 && config.issueNumber) {
+      try {
+        const plan = await loadTaskPlan(paths.prdFile);
+        if (allStoriesPass(plan)) {
+          plan.pipeline.executionCompleted = true;
+          await saveTaskPlan(paths.prdFile, plan);
+        }
+      } catch {
       }
-    } catch {
+    }
+    return exitCode;
+  } finally {
+    if (standalonePublisher !== null) {
+      const success = exitCode === 0;
+      standalonePublisher.publish({
+        type: "phase:end",
+        at: isoNow(),
+        phase: "execute",
+        success,
+        ...success ? {} : { error: "Execute phase failed" }
+      });
+      standalonePublisher.publish({
+        type: "session:end",
+        at: isoNow(),
+        status: success ? "completed" : "failed"
+      });
+      await standalonePublisher.close();
+      setSessionPublisher(void 0);
     }
   }
-  return exitCode;
 }
 
 export {
+  stripMarkdown,
   printQueueSummary,
   printRunSummary,
   runExecute
 };
-//# sourceMappingURL=chunk-6N7LZZ5U.js.map
+//# sourceMappingURL=chunk-LZ6GFQAG.js.map