issue-flow 0.18.0 → 0.20.0

package/dist/{chunk-V7QOIQYC.js → chunk-G442RDFX.js}

@@ -1,26 +1,23 @@
 #!/usr/bin/env node
 import {
   getShutdownSignal
-} from "./chunk-QF7VEL3M.js";
+} from "./chunk-YC24E66P.js";
 import {
   printRetry
-} from "./chunk-XZUEFTUP.js";
-import {
-  fixedBackoffPolicy,
-  withRetry
-} from "./chunk-YVPZUN6X.js";
+} from "./chunk-DBLXLKGU.js";
 import {
   getSessionPublisher
-} from "./chunk-DUS5ZNKL.js";
+} from "./chunk-DIMDAYZS.js";
 import {
   isoNow
-} from "./chunk-SOM4QA6C.js";
+} from "./chunk-JCR5C5A7.js";
 import {
-  classify
-} from "./chunk-XEYH6ZZI.js";
+  classify,
+  fixedBackoffPolicy,
+  withRetry
+} from "./chunk-KUA6KBBD.js";
 
 // src/core/phase-runner.ts
-import { readFile } from "fs/promises";
 var DEFAULT_PHASE_RETRY_LIMIT = 3;
 var DEFAULT_BACKOFF_BASE_SECONDS = 15;
 var DEFAULT_BACKOFF_MAX_SECONDS = 120;
@@ -62,16 +59,6 @@ function phaseFailure(result) {
     retryable: result.transient === true
   };
 }
-async function readFileWithGrace(path, delaysMs = [300, 800]) {
-  for (let i = 0; ; i++) {
-    try {
-      return await readFile(path, "utf-8");
-    } catch (err) {
-      if (i >= delaysMs.length) throw err;
-      await new Promise((resolve) => setTimeout(resolve, delaysMs[i]));
-    }
-  }
-}
 
 // src/utils/retry.ts
 function isTransientFailure(exitCode, output) {
@@ -80,7 +67,6 @@ function isTransientFailure(exitCode, output) {
 
 export {
   runPhaseWithRetry,
-  readFileWithGrace,
   isTransientFailure
 };
-//# sourceMappingURL=chunk-V7QOIQYC.js.map
+//# sourceMappingURL=chunk-G442RDFX.js.map

package/dist/{chunk-V7QOIQYC.js.map → chunk-G442RDFX.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/core/phase-runner.ts","../src/utils/retry.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { type ClassifiedFailure, classify } from '../resilience/errors.js';\nimport { fixedBackoffPolicy, withRetry } from '../resilience/retry.js';\nimport { printRetry } from '../ui/logger.js';\nimport { getSessionPublisher } from './session-publisher.js';\nimport { getShutdownSignal } from './shutdown.js';\nimport { isoNow } from './state-manager.js';\n\nexport interface PhaseAttemptResult {\n  ok: boolean;\n  /** Whether a failed attempt is worth retrying. Ignored when ok is true. */\n  transient?: boolean;\n  error?: string;\n}\n\nexport interface PhaseRetryOptions {\n  phase: string;\n  attempt: (attemptNumber: number) => Promise<PhaseAttemptResult>;\n  retryLimit?: number;\n  backoffBaseSeconds?: number;\n  backoffMaxSeconds?: number;\n  /** Cuts a pending backoff short, so a phase stops waiting on shutdown. */\n  signal?: AbortSignal;\n}\n\nconst DEFAULT_PHASE_RETRY_LIMIT = 3;\nconst DEFAULT_BACKOFF_BASE_SECONDS = 15;\nconst DEFAULT_BACKOFF_MAX_SECONDS = 120;\n\n/**\n * Bounded retry wrapper for single-shot phases (prd, plan, pr) that invoke\n * the Claude CLI once and validate an artifact. Applied to phases that\n * previously aborted the whole pipeline on the first failure with no chance\n * to recover. Non-transient failures (or exhausting the retry budget) still\n * end the phase — this bounds recovery attempts, it never retries forever.\n *\n * The loop itself is `resilience/retry.ts:withRetry`, shared with the\n * `execute` loop of `core/engine.ts`. What stays here is what is specific to a\n * phase: the caller's `transient` verdict, the `retry` event and the printed\n * line. With no options supplied the effective numbers are the ones this\n * module has always used — 3 attempts, 15s doubling to 120s, no jitter.\n */\nexport async function runPhaseWithRetry(options: PhaseRetryOptions): Promise<PhaseAttemptResult> {\n  const retryLimit = options.retryLimit ?? DEFAULT_PHASE_RETRY_LIMIT;\n  const backoffBaseSeconds = options.backoffBaseSeconds ?? DEFAULT_BACKOFF_BASE_SECONDS;\n  const backoffMaxSeconds = options.backoffMaxSeconds ?? DEFAULT_BACKOFF_MAX_SECONDS;\n\n  if (retryLimit < 1) return { ok: false, error: 'Phase never attempted' };\n\n  const outcome = await withRetry<PhaseAttemptResult>((attempt) => options.attempt(attempt), {\n    policy: fixedBackoffPolicy(retryLimit, backoffBaseSeconds, backoffMaxSeconds),\n    // The caller's own signal when it has one, and the process-wide shutdown\n    // otherwise: a backoff nobody can interrupt is a `Ctrl+C` that appears to\n    // do nothing for two minutes.\n    signal: options.signal ?? getShutdownSignal(),\n    evaluate: (result) => (result.ok ? null : phaseFailure(result)),\n    onAttempt: ({ attempt, failure, willRetry, delayMs }) => {\n      if (failure === null || !willRetry) return;\n\n      const delaySeconds = delayMs / 1000;\n      getSessionPublisher().publish({\n        type: 'retry',\n        at: isoNow(),\n        attempt,\n        delaySeconds,\n        reason: failure.message,\n        kind: failure.kind,\n      });\n      printRetry(\n        `Phase ${options.phase} hit a recoverable failure (attempt ${attempt}/${retryLimit}): ${failure.message}. Retrying in ${delaySeconds}s.`,\n      );\n    },\n  });\n\n  return outcome.value;\n}\n\n/**\n * Turn a phase's own verdict into the classified failure `withRetry` decides\n * on.\n *\n * `transient` stays authoritative: the phases build it with\n * `isTransientFailure()` over the CLI's output, but a phase can also fail on\n * something it alone can see — a PRD file that never appeared — and that\n * judgement is not recoverable from the error text. `classify()` is consulted\n * only to name the *kind*, which is what the `retry` event now reports.\n */\nfunction phaseFailure(result: PhaseAttemptResult): ClassifiedFailure {\n  const message = result.error ?? 'Phase failed';\n  return {\n    ...classify({ source: 'agent', stdout: message }),\n    message,\n    retryable: result.transient === true,\n  };\n}\n\n/**\n * Re-read a file a few times with short delays before giving up. Absorbs a\n * brief filesystem-visibility lag between the Claude CLI's Write tool\n * completing and this process observing the result, without spending a full\n * phase retry (and a new Claude invocation) on what may just be a timing gap.\n */\nexport async function readFileWithGrace(\n  path: string,\n  delaysMs: number[] = [300, 800],\n): Promise<string> {\n  for (let i = 0; ; i++) {\n    try {\n      return await readFile(path, 'utf-8');\n    } catch (err) {\n      if (i >= delaysMs.length) throw err;\n      await new Promise((resolve) => setTimeout(resolve, delaysMs[i]));\n    }\n  }\n}\n","import { classify } from '../resilience/errors.js';\n\n/**\n * Determine if an agent invocation failure is transient (retryable).\n *\n * This is a thin adapter over `resilience/errors.ts:classify()` — the taxonomy\n * is the single source of truth, and this signature survives only because\n * `core/engine.ts` and the phase commands are written against it. A caller\n * that has more evidence than an exit code and a blob of text (an `errno`, an\n * HTTP status, `timedOut`) should call `classify()` directly and keep it.\n */\nexport function isTransientFailure(exitCode: number, output: string): boolean {\n  return classify({ source: 'agent', exitCode, stdout: output }).retryable;\n}\n\n/**\n * Calculate retry delay using exponential backoff.\n *\n * delay = baseSeconds * 2^(attempt-1), capped at maxSeconds\n *\n * @param attempt - The retry attempt number (1-based)\n * @param baseSeconds - Base delay in seconds (default: 30)\n * @param maxSeconds - Maximum delay in seconds (default: 900)\n */\nexport function retryDelaySeconds(\n  attempt: number,\n  baseSeconds: number = 30,\n  maxSeconds: number = 900,\n): number {\n  const delay = baseSeconds * 2 ** (attempt - 1);\n  return Math.min(delay, maxSeconds);\n}\n\n/**\n * Sleep for a given number of seconds.\n */\nexport function sleep(seconds: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, seconds * 1000));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AAyBzB,IAAM,4BAA4B;AAClC,IAAM,+BAA+B;AACrC,IAAM,8BAA8B;AAepC,eAAsB,kBAAkB,SAAyD;AAC/F,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,qBAAqB,QAAQ,sBAAsB;AACzD,QAAM,oBAAoB,QAAQ,qBAAqB;AAEvD,MAAI,aAAa,EAAG,QAAO,EAAE,IAAI,OAAO,OAAO,wBAAwB;AAEvE,QAAM,UAAU,MAAM,UAA8B,CAAC,YAAY,QAAQ,QAAQ,OAAO,GAAG;AAAA,IACzF,QAAQ,mBAAmB,YAAY,oBAAoB,iBAAiB;AAAA;AAAA;AAAA;AAAA,IAI5E,QAAQ,QAAQ,UAAU,kBAAkB;AAAA,IAC5C,UAAU,CAAC,WAAY,OAAO,KAAK,OAAO,aAAa,MAAM;AAAA,IAC7D,WAAW,CAAC,EAAE,SAAS,SAAS,WAAW,QAAQ,MAAM;AACvD,UAAI,YAAY,QAAQ,CAAC,UAAW;AAEpC,YAAM,eAAe,UAAU;AAC/B,0BAAoB,EAAE,QAAQ;AAAA,QAC5B,MAAM;AAAA,QACN,IAAI,OAAO;AAAA,QACX;AAAA,QACA;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,MAAM,QAAQ;AAAA,MAChB,CAAC;AACD;AAAA,QACE,SAAS,QAAQ,KAAK,uCAAuC,OAAO,IAAI,UAAU,MAAM,QAAQ,OAAO,iBAAiB,YAAY;AAAA,MACtI;AAAA,IACF;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;AAYA,SAAS,aAAa,QAA+C;AACnE,QAAM,UAAU,OAAO,SAAS;AAChC,SAAO;AAAA,IACL,GAAG,SAAS,EAAE,QAAQ,SAAS,QAAQ,QAAQ,CAAC;AAAA,IAChD;AAAA,IACA,WAAW,OAAO,cAAc;AAAA,EAClC;AACF;AAQA,eAAsB,kBACpB,MACA,WAAqB,CAAC,KAAK,GAAG,GACb;AACjB,WAAS,IAAI,KAAK,KAAK;AACrB,QAAI;AACF,aAAO,MAAM,SAAS,MAAM,OAAO;AAAA,IACrC,SAAS,KAAK;AACZ,UAAI,KAAK,SAAS,OAAQ,OAAM;AAChC,YAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,SAAS,CAAC,CAAC,CAAC;AAAA,IACjE;AAAA,EACF;AACF;;;ACvGO,SAAS,mBAAmB,UAAkB,QAAyB;AAC5E,SAAO,SAAS,EAAE,QAAQ,SAAS,UAAU,QAAQ,OAAO,CAAC,EAAE;AACjE;","names":[]}
+{"version":3,"sources":["../src/core/phase-runner.ts","../src/utils/retry.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { type ClassifiedFailure, classify } from '../resilience/errors.js';\nimport { fixedBackoffPolicy, withRetry } from '../resilience/retry.js';\nimport { printRetry } from '../ui/logger.js';\nimport { getSessionPublisher } from './session-publisher.js';\nimport { getShutdownSignal } from './shutdown.js';\nimport { isoNow } from './state-manager.js';\n\nexport interface PhaseAttemptResult {\n  ok: boolean;\n  /** Whether a failed attempt is worth retrying. Ignored when ok is true. */\n  transient?: boolean;\n  error?: string;\n}\n\nexport interface PhaseRetryOptions {\n  phase: string;\n  attempt: (attemptNumber: number) => Promise<PhaseAttemptResult>;\n  retryLimit?: number;\n  backoffBaseSeconds?: number;\n  backoffMaxSeconds?: number;\n  /** Cuts a pending backoff short, so a phase stops waiting on shutdown. */\n  signal?: AbortSignal;\n}\n\nconst DEFAULT_PHASE_RETRY_LIMIT = 3;\nconst DEFAULT_BACKOFF_BASE_SECONDS = 15;\nconst DEFAULT_BACKOFF_MAX_SECONDS = 120;\n\n/**\n * Bounded retry wrapper for single-shot phases (prd, plan, pr) that invoke\n * the Claude CLI once and validate an artifact. Applied to phases that\n * previously aborted the whole pipeline on the first failure with no chance\n * to recover. Non-transient failures (or exhausting the retry budget) still\n * end the phase — this bounds recovery attempts, it never retries forever.\n *\n * The loop itself is `resilience/retry.ts:withRetry`, shared with the\n * `execute` loop of `core/engine.ts`. What stays here is what is specific to a\n * phase: the caller's `transient` verdict, the `retry` event and the printed\n * line. With no options supplied the effective numbers are the ones this\n * module has always used — 3 attempts, 15s doubling to 120s, no jitter.\n */\nexport async function runPhaseWithRetry(options: PhaseRetryOptions): Promise<PhaseAttemptResult> {\n  const retryLimit = options.retryLimit ?? DEFAULT_PHASE_RETRY_LIMIT;\n  const backoffBaseSeconds = options.backoffBaseSeconds ?? DEFAULT_BACKOFF_BASE_SECONDS;\n  const backoffMaxSeconds = options.backoffMaxSeconds ?? DEFAULT_BACKOFF_MAX_SECONDS;\n\n  if (retryLimit < 1) return { ok: false, error: 'Phase never attempted' };\n\n  const outcome = await withRetry<PhaseAttemptResult>((attempt) => options.attempt(attempt), {\n    policy: fixedBackoffPolicy(retryLimit, backoffBaseSeconds, backoffMaxSeconds),\n    // The caller's own signal when it has one, and the process-wide shutdown\n    // otherwise: a backoff nobody can interrupt is a `Ctrl+C` that appears to\n    // do nothing for two minutes.\n    signal: options.signal ?? getShutdownSignal(),\n    evaluate: (result) => (result.ok ? null : phaseFailure(result)),\n    onAttempt: ({ attempt, failure, willRetry, delayMs }) => {\n      if (failure === null || !willRetry) return;\n\n      const delaySeconds = delayMs / 1000;\n      getSessionPublisher().publish({\n        type: 'retry',\n        at: isoNow(),\n        attempt,\n        delaySeconds,\n        reason: failure.message,\n        kind: failure.kind,\n      });\n      printRetry(\n        `Phase ${options.phase} hit a recoverable failure (attempt ${attempt}/${retryLimit}): ${failure.message}. Retrying in ${delaySeconds}s.`,\n      );\n    },\n  });\n\n  return outcome.value;\n}\n\n/**\n * Turn a phase's own verdict into the classified failure `withRetry` decides\n * on.\n *\n * `transient` stays authoritative: the phases build it with\n * `isTransientFailure()` over the CLI's output, but a phase can also fail on\n * something it alone can see — a PRD file that never appeared — and that\n * judgement is not recoverable from the error text. `classify()` is consulted\n * only to name the *kind*, which is what the `retry` event now reports.\n */\nfunction phaseFailure(result: PhaseAttemptResult): ClassifiedFailure {\n  const message = result.error ?? 'Phase failed';\n  return {\n    ...classify({ source: 'agent', stdout: message }),\n    message,\n    retryable: result.transient === true,\n  };\n}\n\n/**\n * Re-read a file a few times with short delays before giving up. Absorbs a\n * brief filesystem-visibility lag between the Claude CLI's Write tool\n * completing and this process observing the result, without spending a full\n * phase retry (and a new Claude invocation) on what may just be a timing gap.\n */\nexport async function readFileWithGrace(\n  path: string,\n  delaysMs: number[] = [300, 800],\n): Promise<string> {\n  for (let i = 0; ; i++) {\n    try {\n      return await readFile(path, 'utf-8');\n    } catch (err) {\n      if (i >= delaysMs.length) throw err;\n      await new Promise((resolve) => setTimeout(resolve, delaysMs[i]));\n    }\n  }\n}\n","import { classify } from '../resilience/errors.js';\n\n/**\n * Determine if an agent invocation failure is transient (retryable).\n *\n * This is a thin adapter over `resilience/errors.ts:classify()` — the taxonomy\n * is the single source of truth, and this signature survives only because\n * `core/engine.ts` and the phase commands are written against it. A caller\n * that has more evidence than an exit code and a blob of text (an `errno`, an\n * HTTP status, `timedOut`) should call `classify()` directly and keep it.\n */\nexport function isTransientFailure(exitCode: number, output: string): boolean {\n  return classify({ source: 'agent', exitCode, stdout: output }).retryable;\n}\n\n/**\n * Calculate retry delay using exponential backoff.\n *\n * delay = baseSeconds * 2^(attempt-1), capped at maxSeconds\n *\n * @param attempt - The retry attempt number (1-based)\n * @param baseSeconds - Base delay in seconds (default: 30)\n * @param maxSeconds - Maximum delay in seconds (default: 900)\n */\nexport function retryDelaySeconds(\n  attempt: number,\n  baseSeconds: number = 30,\n  maxSeconds: number = 900,\n): number {\n  const delay = baseSeconds * 2 ** (attempt - 1);\n  return Math.min(delay, maxSeconds);\n}\n\n/**\n * Sleep for a given number of seconds.\n */\nexport function sleep(seconds: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, seconds * 1000));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA,IAAM,4BAA4B;AAClC,IAAM,+BAA+B;AACrC,IAAM,8BAA8B;AAepC,eAAsB,kBAAkB,SAAyD;AAC/F,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,qBAAqB,QAAQ,sBAAsB;AACzD,QAAM,oBAAoB,QAAQ,qBAAqB;AAEvD,MAAI,aAAa,EAAG,QAAO,EAAE,IAAI,OAAO,OAAO,wBAAwB;AAEvE,QAAM,UAAU,MAAM,UAA8B,CAAC,YAAY,QAAQ,QAAQ,OAAO,GAAG;AAAA,IACzF,QAAQ,mBAAmB,YAAY,oBAAoB,iBAAiB;AAAA;AAAA;AAAA;AAAA,IAI5E,QAAQ,QAAQ,UAAU,kBAAkB;AAAA,IAC5C,UAAU,CAAC,WAAY,OAAO,KAAK,OAAO,aAAa,MAAM;AAAA,IAC7D,WAAW,CAAC,EAAE,SAAS,SAAS,WAAW,QAAQ,MAAM;AACvD,UAAI,YAAY,QAAQ,CAAC,UAAW;AAEpC,YAAM,eAAe,UAAU;AAC/B,0BAAoB,EAAE,QAAQ;AAAA,QAC5B,MAAM;AAAA,QACN,IAAI,OAAO;AAAA,QACX;AAAA,QACA;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,MAAM,QAAQ;AAAA,MAChB,CAAC;AACD;AAAA,QACE,SAAS,QAAQ,KAAK,uCAAuC,OAAO,IAAI,UAAU,MAAM,QAAQ,OAAO,iBAAiB,YAAY;AAAA,MACtI;AAAA,IACF;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;AAYA,SAAS,aAAa,QAA+C;AACnE,QAAM,UAAU,OAAO,SAAS;AAChC,SAAO;AAAA,IACL,GAAG,SAAS,EAAE,QAAQ,SAAS,QAAQ,QAAQ,CAAC;AAAA,IAChD;AAAA,IACA,WAAW,OAAO,cAAc;AAAA,EAClC;AACF;;;ACnFO,SAAS,mBAAmB,UAAkB,QAAyB;AAC5E,SAAO,SAAS,EAAE,QAAQ,SAAS,UAAU,QAAQ,OAAO,CAAC,EAAE;AACjE;","names":[]}

package/dist/{chunk-QPGEFLMY.js → chunk-I64N6RL6.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import {
-  getDiagnosticsDir
-} from "./chunk-HAKDLR6N.js";
 import {
   redactSecrets
-} from "./chunk-PPZ3K4YM.js";
+} from "./chunk-VHQMMY2D.js";
+import {
+  getDiagnosticsDir
+} from "./chunk-MAJ6QDRL.js";
 
 // src/storage/diagnostics.ts
-import { appendFile, mkdir, readdir, readFile, rename, stat, unlink } from "fs/promises";
-import { join } from "path";
+import { appendFile, mkdir, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
 var MAX_FILE_BYTES = 10 * 1024 * 1024;
 var MAX_GENERATIONS = 5;
 var RETENTION_DAYS = 30;
@@ -160,4 +160,4 @@ export {
   resetDiagnosticsState,
   readDiagnostics
 };
-//# sourceMappingURL=chunk-QPGEFLMY.js.map
+//# sourceMappingURL=chunk-I64N6RL6.js.map

package/dist/{chunk-KRAGAUKD.js → chunk-JBYXJOJJ.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   ensureWebMonitor
-} from "./chunk-NEWNXZ65.js";
+} from "./chunk-V7GETODQ.js";
+import {
+  groupBy,
+  summarize
+} from "./chunk-E2H3JV2E.js";
 import {
   applyAcceptanceToPlan,
   resolveIssueDir,
   runAcceptanceGate
-} from "./chunk-ECU7YO7S.js";
-import {
-  groupBy,
-  summarize
-} from "./chunk-CRGIQFUQ.js";
+} from "./chunk-PM5YWJYO.js";
 import {
   EXECUTE_PHASE,
   elapsedSecondsSince,
@@ -18,35 +18,32 @@ import {
   publishIterationMetrics,
   publishStoryMetrics,
   resolvePolicyPlaceholders
-} from "./chunk-KMCS76ZW.js";
+} from "./chunk-KUL64XUF.js";
 import {
   applyPlaceholders,
   loadPrompt
-} from "./chunk-7F7LGMVO.js";
+} from "./chunk-BTBJ5UOO.js";
 import {
   invokeSelectedAgent
-} from "./chunk-TZYINKCC.js";
-import {
-  getPackageVersion
-} from "./chunk-C5TL7T4V.js";
+} from "./chunk-UDUUUFQF.js";
 import {
   archiveFolderName,
   commitMessage
-} from "./chunk-LGHND47K.js";
+} from "./chunk-WQSGL5LX.js";
+import {
+  getPackageVersion
+} from "./chunk-2YM2VH6R.js";
 import {
   createConfig,
   getActiveResilienceConfig,
   getShutdownSignal,
-  loadGlobalConfig,
   loadWebConfig,
   resolveAgentFor,
   resolvePaths,
   validateDependencies
-} from "./chunk-QF7VEL3M.js";
-import {
-  resolveIssuePaths
-} from "./chunk-LI35PIIS.js";
+} from "./chunk-YC24E66P.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-DBLXLKGU.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-JCR5C5A7.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-KUA6KBBD.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-KRAGAUKD.js.map
+//# sourceMappingURL=chunk-JBYXJOJJ.js.map