issue-flow 0.11.0 → 0.12.0

package/dist/chunk-XQUSIEKA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/review.ts"],"sourcesContent":["import { DEFAULT_HEADLESS_TIMEOUT_MS, runHeadless } from '../core/headless.js';\nimport { applyPlaceholders, loadPrompt } from '../core/prompt-resolver.js';\nimport { publishPhaseMetrics } from '../core/session-metrics.js';\nimport { loadTaskPlan, saveTaskPlan } from '../core/state-manager.js';\nimport { getGlobalTimeout } from '../core/verbose.js';\nimport { issuePlaceholders, resolveCommandIssue } from '../issues/context.js';\nimport type { ResolvedIssue } from '../issues/types.js';\nimport { resolvePolicyPlaceholders } from '../policy/placeholders.js';\nimport { resolveIssuePaths } from '../storage/resolve.js';\nimport { printError, printSuccess } from '../ui/logger.js';\n\nexport interface ReviewResult {\n  status: 'PASS' | 'FAIL';\n  findings?: string;\n}\n\n/**\n * Parse the <review-result> block from headless output.\n */\nfunction parseReviewResult(output: string): ReviewResult {\n  const match = output.match(/<review-result>([\\s\\S]*?)<\\/review-result>/);\n  if (!match) {\n    // Try to detect PASS/FAIL from the raw output\n    if (/STATUS:\\s*PASS/i.test(output)) {\n      return { status: 'PASS' };\n    }\n    if (/STATUS:\\s*FAIL/i.test(output)) {\n      const findingsMatch = output.match(/FINDINGS:([\\s\\S]*?)(?:$|<\\/)/);\n      return { status: 'FAIL', findings: findingsMatch?.[1]?.trim() ?? 'Unknown findings' };\n    }\n    // Default to PASS if no explicit status found and no errors\n    return { status: 'PASS' };\n  }\n\n  const block = match[1];\n  if (/STATUS:\\s*PASS/i.test(block)) {\n    return { status: 'PASS' };\n  }\n\n  const findingsMatch = block.match(/FINDINGS:([\\s\\S]*)/);\n  return {\n    status: 'FAIL',\n    findings: findingsMatch?.[1]?.trim() ?? 'Unknown findings',\n  };\n}\n\nexport async function runReview(issue: string, resolvedIssue?: ResolvedIssue): Promise<number> {\n  const issueNumber = issue.replace(/^#/, '');\n  const paths = await resolveIssuePaths(issueNumber);\n  const tasksPath = paths.tasksFile;\n\n  const resolution = await resolveCommandIssue(issueNumber, resolvedIssue);\n  if (!resolution.ok) {\n    return resolution.code;\n  }\n\n  const template = await loadPrompt('review');\n  const prompt = applyPlaceholders(template, {\n    // The repository's own conventions. Empty when it declares none, which is\n    // what keeps the rendered prompt identical to the pre-policy one.\n    ...(await resolvePolicyPlaceholders()),\n    __ISSUE_NUMBER__: issueNumber,\n    __TASKS_PATH__: tasksPath,\n    ...issuePlaceholders(resolution.resolved),\n  });\n\n  const startedAtMs = Date.now();\n  const result = await runHeadless({\n    prompt,\n    maxTurns: 25,\n    timeout: getGlobalTimeout() ?? DEFAULT_HEADLESS_TIMEOUT_MS,\n    // json (not text) so the CLI reports usage: the envelope's `result` field\n    // carries the same assistant text parseReviewResult() already consumed.\n    outputFormat: 'json',\n    allowedTools: ['Bash', 'Read', 'Glob', 'Grep'],\n    addDirs: [paths.issueDir],\n    statusMessage: `Reviewing issue #${issueNumber} resolution...`,\n  });\n  // Before the success check: the tokens were spent either way. A correction\n  // cycle calls runReview() again and the reducer sums both invocations.\n  publishPhaseMetrics('review', result.cost, startedAtMs);\n\n  if (!result.success) {\n    printError(`Review failed: ${result.error}`);\n    return 1;\n  }\n\n  const review = parseReviewResult(result.result);\n\n  if (review.status === 'PASS') {\n    // Update pipeline state\n    try {\n      const plan = await loadTaskPlan(tasksPath);\n      plan.pipeline.reviewCompleted = true;\n      plan.lastReviewFindings = null;\n      await saveTaskPlan(tasksPath, plan);\n    } catch {\n      // tasks.json may not exist\n    }\n\n    printSuccess('Review PASSED — implementation meets acceptance criteria');\n    return 0;\n  }\n\n  printError('Review FAILED — issues found:');\n  if (review.findings) {\n    console.log(review.findings);\n  }\n\n  // Persist the findings so a correction cycle can act on them: without this,\n  // a re-run of execute sees every userStories[].passes already true and\n  // exits immediately without attempting any fix (see engine.ts's\n  // \"already complete\" guards).\n  try {\n    const plan = await loadTaskPlan(tasksPath);\n    plan.pipeline.reviewCompleted = false;\n    plan.lastReviewFindings = review.findings ?? 'Unknown findings';\n    await saveTaskPlan(tasksPath, plan);\n  } catch {\n    // tasks.json may not exist\n  }\n\n  return 1;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,SAAS,kBAAkB,QAA8B;AACvD,QAAM,QAAQ,OAAO,MAAM,4CAA4C;AACvE,MAAI,CAAC,OAAO;AAEV,QAAI,kBAAkB,KAAK,MAAM,GAAG;AAClC,aAAO,EAAE,QAAQ,OAAO;AAAA,IAC1B;AACA,QAAI,kBAAkB,KAAK,MAAM,GAAG;AAClC,YAAMA,iBAAgB,OAAO,MAAM,8BAA8B;AACjE,aAAO,EAAE,QAAQ,QAAQ,UAAUA,iBAAgB,CAAC,GAAG,KAAK,KAAK,mBAAmB;AAAA,IACtF;AAEA,WAAO,EAAE,QAAQ,OAAO;AAAA,EAC1B;AAEA,QAAM,QAAQ,MAAM,CAAC;AACrB,MAAI,kBAAkB,KAAK,KAAK,GAAG;AACjC,WAAO,EAAE,QAAQ,OAAO;AAAA,EAC1B;AAEA,QAAM,gBAAgB,MAAM,MAAM,oBAAoB;AACtD,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,UAAU,gBAAgB,CAAC,GAAG,KAAK,KAAK;AAAA,EAC1C;AACF;AAEA,eAAsB,UAAU,OAAe,eAAgD;AAC7F,QAAM,cAAc,MAAM,QAAQ,MAAM,EAAE;AAC1C,QAAM,QAAQ,MAAM,kBAAkB,WAAW;AACjD,QAAM,YAAY,MAAM;AAExB,QAAM,aAAa,MAAM,oBAAoB,aAAa,aAAa;AACvE,MAAI,CAAC,WAAW,IAAI;AAClB,WAAO,WAAW;AAAA,EACpB;AAEA,QAAM,WAAW,MAAM,WAAW,QAAQ;AAC1C,QAAM,SAAS,kBAAkB,UAAU;AAAA;AAAA;AAAA,IAGzC,GAAI,MAAM,0BAA0B;AAAA,IACpC,kBAAkB;AAAA,IAClB,gBAAgB;AAAA,IAChB,GAAG,kBAAkB,WAAW,QAAQ;AAAA,EAC1C,CAAC;AAED,QAAM,cAAc,KAAK,IAAI;AAC7B,QAAM,SAAS,MAAM,YAAY;AAAA,IAC/B;AAAA,IACA,UAAU;AAAA,IACV,SAAS,iBAAiB,KAAK;AAAA;AAAA;AAAA,IAG/B,cAAc;AAAA,IACd,cAAc,CAAC,QAAQ,QAAQ,QAAQ,MAAM;AAAA,IAC7C,SAAS,CAAC,MAAM,QAAQ;AAAA,IACxB,eAAe,oBAAoB,WAAW;AAAA,EAChD,CAAC;AAGD,sBAAoB,UAAU,OAAO,MAAM,WAAW;AAEtD,MAAI,CAAC,OAAO,SAAS;AACnB,eAAW,kBAAkB,OAAO,KAAK,EAAE;AAC3C,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,kBAAkB,OAAO,MAAM;AAE9C,MAAI,OAAO,WAAW,QAAQ;AAE5B,QAAI;AACF,YAAM,OAAO,MAAM,aAAa,SAAS;AACzC,WAAK,SAAS,kBAAkB;AAChC,WAAK,qBAAqB;AAC1B,YAAM,aAAa,WAAW,IAAI;AAAA,IACpC,QAAQ;AAAA,IAER;AAEA,iBAAa,+DAA0D;AACvE,WAAO;AAAA,EACT;AAEA,aAAW,oCAA+B;AAC1C,MAAI,OAAO,UAAU;AACnB,YAAQ,IAAI,OAAO,QAAQ;AAAA,EAC7B;AAMA,MAAI;AACF,UAAM,OAAO,MAAM,aAAa,SAAS;AACzC,SAAK,SAAS,kBAAkB;AAChC,SAAK,qBAAqB,OAAO,YAAY;AAC7C,UAAM,aAAa,WAAW,IAAI;AAAA,EACpC,QAAQ;AAAA,EAER;AAEA,SAAO;AACT;","names":["findingsMatch"]}

package/dist/chunk-Y5ZDJ4PJ.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  getShutdownSignal
+} from "./chunk-M66SJHQQ.js";
+import {
+  classify,
+  fixedBackoffPolicy,
+  withRetry
+} from "./chunk-DIDUVL6O.js";
+import {
+  getSessionPublisher,
+  printRetry
+} from "./chunk-BYZDPR7N.js";
+import {
+  isoNow
+} from "./chunk-CD5ULRVC.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;
+async function runPhaseWithRetry(options) {
+  const retryLimit = options.retryLimit ?? DEFAULT_PHASE_RETRY_LIMIT;
+  const backoffBaseSeconds = options.backoffBaseSeconds ?? DEFAULT_BACKOFF_BASE_SECONDS;
+  const backoffMaxSeconds = options.backoffMaxSeconds ?? DEFAULT_BACKOFF_MAX_SECONDS;
+  if (retryLimit < 1) return { ok: false, error: "Phase never attempted" };
+  const outcome = await withRetry((attempt) => options.attempt(attempt), {
+    policy: fixedBackoffPolicy(retryLimit, backoffBaseSeconds, backoffMaxSeconds),
+    // The caller's own signal when it has one, and the process-wide shutdown
+    // otherwise: a backoff nobody can interrupt is a `Ctrl+C` that appears to
+    // do nothing for two minutes.
+    signal: options.signal ?? getShutdownSignal(),
+    evaluate: (result) => result.ok ? null : phaseFailure(result),
+    onAttempt: ({ attempt, failure, willRetry, delayMs }) => {
+      if (failure === null || !willRetry) return;
+      const delaySeconds = delayMs / 1e3;
+      getSessionPublisher().publish({
+        type: "retry",
+        at: isoNow(),
+        attempt,
+        delaySeconds,
+        reason: failure.message,
+        kind: failure.kind
+      });
+      printRetry(
+        `Phase ${options.phase} hit a recoverable failure (attempt ${attempt}/${retryLimit}): ${failure.message}. Retrying in ${delaySeconds}s.`
+      );
+    }
+  });
+  return outcome.value;
+}
+function phaseFailure(result) {
+  const message = result.error ?? "Phase failed";
+  return {
+    ...classify({ source: "agent", stdout: message }),
+    message,
+    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]));
+    }
+  }
+}
+
+export {
+  runPhaseWithRetry,
+  readFileWithGrace
+};
+//# sourceMappingURL=chunk-Y5ZDJ4PJ.js.map

package/dist/chunk-Y5ZDJ4PJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/phase-runner.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"],"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;","names":[]}

package/dist/cli.js

@@ -1,13 +1,21 @@
 #!/usr/bin/env node
+import {
+  DEFAULT_INACTIVITY_TIMEOUT_MS,
+  installShutdownHandlers
+} from "./chunk-M66SJHQQ.js";
 import {
   setIssuesCliOverrides,
+  setResilienceCliOverrides,
   setWebCliOverrides
-} from "./chunk-VQ5VN7DF.js";
+} from "./chunk-42PJFMAR.js";
+import "./chunk-DIDUVL6O.js";
 import {
   printError,
   setGlobalTimeout,
+  setInactivityTimeout,
   setVerbose
-} from "./chunk-HC2MT7BX.js";
+} from "./chunk-BYZDPR7N.js";
+import "./chunk-CD5ULRVC.js";
 
 // src/cli.ts
 import { createRequire } from "module";
@@ -107,6 +115,37 @@ function resolveGenerateTarget(opts) {
   return selected[0];
 }
 
+// src/resilience/cli-flags.ts
+function continuousProfile() {
+  return {
+    profile: "continuous",
+    providers: { failover: true },
+    queue: { onIssueFailure: "skip" },
+    journal: { enabled: true },
+    watchdog: { inactivityTimeoutMs: DEFAULT_INACTIVITY_TIMEOUT_MS }
+  };
+}
+function resolveResilienceOverrides(flags) {
+  const continuous = flags.continuous === true || flags.resilient === true;
+  const overrides = continuous ? continuousProfile() : {};
+  if (flags.failover === false) {
+    overrides.providers = { ...overrides.providers, failover: false };
+  }
+  if (flags.autoDecompose === true) {
+    overrides.decompose = { ...overrides.decompose, auto: true };
+  }
+  if (flags.inactivityTimeout !== void 0) {
+    overrides.watchdog = {
+      ...overrides.watchdog,
+      inactivityTimeoutMs: flags.inactivityTimeout * 1e3
+    };
+  }
+  if (flags.onIssueFailure !== void 0) {
+    overrides.queue = { ...overrides.queue, onIssueFailure: flags.onIssueFailure };
+  }
+  return overrides;
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -117,6 +156,10 @@ function parseInteger(value) {
   }
   return parsed;
 }
+function parseQueueFailureMode(value) {
+  if (value === "stop" || value === "skip" || value === "block") return value;
+  throw new InvalidArgumentError("Must be one of: stop, skip, block.");
+}
 function parseStartUs(value) {
   const parsed = parseInteger(value);
   if (parsed < 1) {
@@ -136,8 +179,15 @@ function withGlobalOptions(cmd) {
     "-t, --timeout <seconds>",
     "Override headless timeout in seconds (0 = no limit)",
     parseInteger
+  ).option(
+    "--inactivity-timeout <seconds>",
+    "Stop the agent after this many seconds with no output (0 = no watchdog)",
+    parseInteger
   );
 }
+function withResilienceOptions(cmd) {
+  return cmd.option("--continuous", "Long-running profile: keep going without supervision").option("--resilient", "Alias of --continuous").option("--no-failover", "Never migrate a phase to another agent provider").option("--auto-decompose", "Act on a decomposition report instead of only writing it");
+}
 function withWebOptions(cmd) {
   return cmd.option("--web", "Enable the web monitoring server").option("--serve", "Alias for --web").option("--port <n>", "Web server port (default: 3737)", parseInteger).option("--host <h>", "Web server host (default: 0.0.0.0)").option("--refresh <s>", "Suggested UI polling interval in seconds", parseInteger).option("--web-log-limit <n>", "Max log entries kept in the snapshot", parseInteger).option("--web-no-logs", "Exclude logs from the published snapshot");
 }
@@ -171,6 +221,7 @@ program.name("issue-flow").description(
   "Unified CLI for orchestrating the full issue-flow pipeline via Claude Code Headless."
 ).version(version);
 program.hook("preAction", (_thisCommand, actionCommand) => {
+  installShutdownHandlers();
   const opts = actionCommand.opts();
   if (opts.verbose) {
     setVerbose(true);
@@ -178,7 +229,20 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
   if (opts.timeout !== void 0) {
     setGlobalTimeout(opts.timeout * 1e3);
   }
+  if (opts.inactivityTimeout !== void 0) {
+    setInactivityTimeout(opts.inactivityTimeout * 1e3);
+  }
   setWebCliOverrides(resolveWebOverrides(opts));
+  setResilienceCliOverrides(
+    resolveResilienceOverrides({
+      continuous: opts.continuous,
+      resilient: opts.resilient,
+      failover: opts.failover,
+      autoDecompose: opts.autoDecompose,
+      inactivityTimeout: opts.inactivityTimeout,
+      onIssueFailure: opts.onIssueFailure
+    })
+  );
   try {
     setIssuesCliOverrides(resolveIssuesOverrides(opts));
   } catch (error) {
@@ -197,8 +261,8 @@ withIssueOptions(
   )
 ).action(
   async (options) => {
-    const { loadIssuesConfig } = await import("./config-4THHOXNN.js");
-    const { runInit } = await import("./init-PRMOTQ7N.js");
+    const { loadIssuesConfig } = await import("./config-PRJGWW7J.js");
+    const { runInit } = await import("./init-AJHCXJBP.js");
     const { preferredProvider } = await loadIssuesConfig();
     const code = await runInit(preferredProvider, options);
     process.exit(code);
@@ -217,20 +281,30 @@ withGlobalOptions(
     }
     throw error;
   }
-  const { runGenerate } = await import("./generate-6RA2MFJB.js");
+  const { runGenerate } = await import("./generate-EGB4KV2B.js");
   const code = await runGenerate(options.prompt, target);
   process.exit(code);
 });
 withUserStoryNumberingOptions(
-  withWebOptions(
-    withIssueOptions(
-      withGlobalOptions(
-        program.command("run").description(
-          "Execute the full pipeline: prd \u2192 plan \u2192 execute \u2192 review \u2192 pr (\u2192 pr-review, optional)"
-        ).argument("<issues...>", 'Issue number(s): 42, "42,43" or 42 43').option("--mode <mode>", "Execution mode: auto | manual", "auto").option("--from <phase>", "Resume from a specific phase").option(
-          "--no-branch",
-          "Run pipeline on current branch without creating a new branch or PR"
-        ).option("--pr-review", "Review the created Pull Request after the pr phase").option("-y, --yes", "Run the whole discovered hierarchy without confirmation").option("--only", "Run just the issues informed, without their hierarchy")
+  withResilienceOptions(
+    withWebOptions(
+      withIssueOptions(
+        withGlobalOptions(
+          program.command("run").description(
+            "Execute the full pipeline: prd \u2192 plan \u2192 execute \u2192 review \u2192 pr (\u2192 pr-review, optional)"
+          ).argument("<issues...>", 'Issue number(s): 42, "42,43" or 42 43').option("--mode <mode>", "Execution mode: auto | manual", "auto").option("--from <phase>", "Resume from a specific phase").option(
+            "--no-branch",
+            "Run pipeline on current branch without creating a new branch or PR"
+          ).option("--pr-review", "Review the created Pull Request after the pr phase").option("-y, --yes", "Run the whole discovered hierarchy without confirmation").option("--only", "Run just the issues informed, without their hierarchy").option(
+            "--retry-limit <number>",
+            "Retry transient Claude failures up to N consecutive times",
+            parseInteger
+          ).option("--retry-forever", "Retry transient Claude failures indefinitely").option(
+            "--on-issue-failure <mode>",
+            "In a queue, on a failing issue: stop | skip | block",
+            parseQueueFailureMode
+          )
+        )
       )
     )
   )
@@ -250,7 +324,7 @@ withUserStoryNumberingOptions(
       }
       throw error;
     }
-    const { runPipeline } = await import("./run-H75MD5BQ.js");
+    const { runPipeline } = await import("./run-RXE5GDQO.js");
     const code = await runPipeline(
       issues,
       options.mode,
@@ -261,18 +335,74 @@ withUserStoryNumberingOptions(
         yes: scope.yes,
         only: scope.only,
         continueNumbering: numbering.continueFlag,
-        startUs: numbering.startUs
+        startUs: numbering.startUs,
+        retryLimit: options.retryLimit,
+        retryForever: options.retryForever,
+        onIssueFailure: options.onIssueFailure
       }
     );
     process.exit(code);
   }
 );
+withIssueOptions(
+  withGlobalOptions(
+    program.command("resume").description("Resume an interrupted pipeline from the phase it stopped at").argument("[issue]", "Issue to resume. Omitted: the most recently attempted one").option("--all", "Resume every unfinished issue of this project, in order").option("--mode <mode>", "Execution mode: auto | manual", "auto")
+  )
+).action(async (issue, options) => {
+  const { runResume } = await import("./resume-PPCNQVVV.js");
+  const code = await runResume(issue, {
+    ...options.all === void 0 ? {} : { all: options.all },
+    ...options.mode === void 0 ? {} : { mode: options.mode }
+  });
+  process.exit(code);
+});
+withGlobalOptions(
+  program.command("status").description("What is running right now, in which phase, and since when").argument("[issue]", "Restrict the report to one issue").option("--json", "Emit the assembled state as JSON")
+).action(async (issue, options) => {
+  const { runStatus } = await import("./operations-BYT626KQ.js");
+  process.exit(
+    await runStatus(issue, { ...options.json === void 0 ? {} : { json: options.json } })
+  );
+});
+withGlobalOptions(
+  program.command("runs").description("History of the runs of this project, with how each ended")
+).action(async () => {
+  const { runRuns } = await import("./operations-BYT626KQ.js");
+  process.exit(await runRuns());
+});
+withGlobalOptions(
+  program.command("logs").description("Read the execution journal (events.jsonl), filtered and readable").argument("[issue]", "Issue to read. Omitted: the most recently attempted one").option("--issue <issue>", "Same as the positional argument").option("--follow", "Keep reading as the journal grows").option("--tail <n>", "How many entries to show first (default 50)", parseInteger).option("--kind <kinds>", "Only these event types, comma separated (retry, phase:end, \u2026)")
+).action(
+  async (issue, options) => {
+    const { runLogs } = await import("./operations-BYT626KQ.js");
+    const kinds = options.kind === void 0 ? void 0 : options.kind.split(",").map((kind) => kind.trim()).filter((kind) => kind !== "");
+    process.exit(
+      await runLogs(issue ?? options.issue, {
+        ...kinds === void 0 ? {} : { kind: kinds },
+        ...options.follow === void 0 ? {} : { follow: options.follow },
+        ...options.tail === void 0 ? {} : { tail: options.tail }
+      })
+    );
+  }
+);
+withGlobalOptions(
+  program.command("pause").description("Ask the running pipeline to stop after writing a checkpoint")
+).action(async () => {
+  const { runPause } = await import("./operations-BYT626KQ.js");
+  process.exit(await runPause());
+});
+withGlobalOptions(
+  program.command("cancel").description("Stop the run and mark the issue so a resume does not pick it up").argument("[issue]", "Issue to cancel. Omitted: the most recently attempted one")
+).action(async (issue) => {
+  const { runCancel } = await import("./operations-BYT626KQ.js");
+  process.exit(await runCancel(issue));
+});
 withIssueOptions(
   withGlobalOptions(
     program.command("analyze").description("Analyze an issue via Claude Code Headless").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runAnalyze } = await import("./analyze-7B5TORNK.js");
+  const { runAnalyze } = await import("./analyze-OEET7KGE.js");
   const code = await runAnalyze(issue);
   process.exit(code);
 });
@@ -281,7 +411,7 @@ withIssueOptions(
     program.command("prd").description("Generate a PRD from an analyzed issue via Claude Code Headless").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runPrd } = await import("./prd-V3MWDIHK.js");
+  const { runPrd } = await import("./prd-JQSZF7PR.js");
   const code = await runPrd(issue);
   process.exit(code);
 });
@@ -302,7 +432,7 @@ withUserStoryNumberingOptions(
     }
     throw error;
   }
-  const { runPlan } = await import("./plan-KENR6MJ3.js");
+  const { runPlan } = await import("./plan-QOZ3RIO6.js");
   const code = await runPlan(issue, void 0, numbering);
   process.exit(code);
 });
@@ -321,7 +451,7 @@ withWebOptions(
 ).action(
   async (positionalMaxIter, options) => {
     try {
-      const { runExecute } = await import("./execute-5OEKLM5X.js");
+      const { runExecute } = await import("./execute-XBNVL753.js");
       const code = await runExecute(positionalMaxIter, options);
       process.exit(code);
     } catch (error) {
@@ -335,7 +465,7 @@ withIssueOptions(
     program.command("review").description("Validate an issue resolution via Claude Code Headless").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runReview } = await import("./review-7LN47SAN.js");
+  const { runReview } = await import("./review-3F6MARWH.js");
   const code = await runReview(issue);
   process.exit(code);
 });
@@ -344,7 +474,7 @@ withIssueOptions(
     program.command("pr").description("Create a pull request via Claude Code Headless").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runPr } = await import("./pr-KDGKG4BP.js");
+  const { runPr } = await import("./pr-EBBHD2ZX.js");
   const code = await runPr(issue);
   process.exit(code);
 });
@@ -352,21 +482,21 @@ var webCommand = program.command("web").description("Manage the web monitoring s
 webCommand.command("serve").description(
   "Run the web monitor server in the foreground (internal \u2014 spawned detached by --web)"
 ).option("--port <n>", "Web server port (default: 3737)", parseInteger).option("--host <h>", "Web server host (default: 0.0.0.0)").option("--refresh <s>", "Suggested UI polling interval in seconds", parseInteger).action(async (options) => {
-  const { runWebServe } = await import("./web-ANQQTTRD.js");
+  const { runWebServe } = await import("./web-EF5WIIGG.js");
   const code = await runWebServe(options);
   if (code !== 0) {
     process.exit(code);
   }
 });
 webCommand.command("stop").description("Stop the running web monitor server").action(async () => {
-  const { runWebStop } = await import("./web-ANQQTTRD.js");
+  const { runWebStop } = await import("./web-EF5WIIGG.js");
   const code = await runWebStop();
   process.exit(code);
 });
 withGlobalOptions(
   program.command("policy").description("Inspect the policies discovered in this repository and their provenance").option("--scope <dir>", "Resolve the policy for a subdirectory (monorepo)").option("--json", "Emit the resolved policy as JSON")
 ).action(async (options) => {
-  const { runPolicy } = await import("./policy-XQW5NUIE.js");
+  const { runPolicy } = await import("./policy-6S4GFC76.js");
   const code = await runPolicy(options);
   process.exit(code);
 });
@@ -377,7 +507,7 @@ withGlobalOptions(
   )
 ).action(
   async (pr, options) => {
-    const { runPrReview } = await import("./pr-review-CAMAB7KO.js");
+    const { runPrReview } = await import("./pr-review-VVMW5PO4.js");
     const code = await runPrReview(pr, options);
     process.exit(code);
   }