issue-flow 0.12.0 → 0.13.0

package/dist/chunk-XEYH6ZZI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resilience/errors.ts"],"sourcesContent":["/**\n * Failure taxonomy.\n *\n * Every failure the pipeline reacts to is classified here, from a structured\n * `FailureSignal`, into one `FailureKind`. The point is that the decision to\n * retry stops depending on `String.includes` over an error message: text is the\n * last resort of `classify()`, not its first move.\n *\n * The invariants of this layer — above all, that `task_execution` is never\n * retried here — are in `src/resilience/AGENTS.md`.\n */\n\n/** What went wrong, in the terms the retry policy is written in. */\nexport type FailureKind =\n  | 'network'\n  | 'timeout'\n  | 'stalled'\n  | 'rate_limit'\n  | 'provider_down'\n  | 'provider_crash'\n  | 'authentication'\n  | 'configuration'\n  | 'repository_state'\n  | 'task_execution'\n  | 'internal'\n  | 'unknown';\n\n/** Which subsystem produced the failure. */\nexport type FailureSource = 'agent' | 'github' | 'git' | 'filesystem' | 'internal';\n\n/**\n * The raw evidence of a failure, as the caller observed it.\n *\n * Everything is optional but `source`: a caller hands over what it actually\n * has. `execa` supplies `exitCode`, `signal`, `timedOut` and — on the thrown\n * error — `errno`; an HTTP client supplies `httpStatus` and `retryAfter`.\n */\nexport interface FailureSignal {\n  source: FailureSource;\n  exitCode?: number | null;\n  /** POSIX signal name that terminated the process (`SIGTERM`, `SIGKILL`). */\n  signal?: string | null;\n  /** `execa`'s own verdict that it killed the child on the configured limit. */\n  timedOut?: boolean;\n  stdout?: string;\n  stderr?: string;\n  /** `ENOTFOUND`, `ECONNRESET`, `ETIMEDOUT`, `EAI_AGAIN`… */\n  errno?: string;\n  httpStatus?: number;\n  /** A server's `Retry-After` header: delay in seconds, or an HTTP date. */\n  retryAfter?: string | number;\n  /** Set by the watchdog when a child produced no output for too long. */\n  stalled?: boolean;\n}\n\n/** The verdict. `retryable` is advice; the attempt budget belongs to the policy. */\nexport interface ClassifiedFailure {\n  kind: FailureKind;\n  message: string;\n  retryable: boolean;\n  source: FailureSource;\n  /** Present only when the server told us how long to wait. */\n  retryAfterMs?: number;\n}\n\n/**\n * Kinds worth another attempt: the cause is outside the work being done and is\n * expected to pass on its own.\n */\nconst RETRYABLE_KINDS: ReadonlySet<FailureKind> = new Set<FailureKind>([\n  'network',\n  'timeout',\n  'stalled',\n  'rate_limit',\n  'provider_down',\n  'provider_crash',\n]);\n\n/**\n * Kinds that no configuration may retry. Waiting cannot fix any of them: they\n * need a human, or they belong to a different loop entirely (`task_execution`\n * is the pipeline's own correction cycle — see `AGENTS.md` here).\n */\nconst HUMAN_ACTION_KINDS: ReadonlySet<FailureKind> = new Set<FailureKind>([\n  'authentication',\n  'configuration',\n  'repository_state',\n  'task_execution',\n]);\n\n/** Whether this layer considers `kind` worth retrying at all. */\nexport function isRetryableKind(kind: FailureKind): boolean {\n  return RETRYABLE_KINDS.has(kind);\n}\n\n/** Whether `kind` escalates to a human instead of being retried, ever. */\nexport function requiresHumanAction(kind: FailureKind): boolean {\n  return HUMAN_ACTION_KINDS.has(kind);\n}\n\n/* ── carrying a verdict through a throw ─────────────────────────────────── */\n\n/**\n * An `Error` that carries its own classification.\n *\n * A `catch` normally flattens a failure back into a string, which is exactly\n * the loss this layer exists to prevent: the caller that has to decide between\n * \"retry\" and \"escalate to a human\" then has nothing but a message again. Any\n * boundary that must throw — a provider, a phase — throws this instead.\n *\n * `action` is what a human has to do, and it is only ever set for a kind that\n * needs one (`gh auth login` for `authentication`). It is written at the throw\n * site because only that site knows which CLI is involved.\n */\nexport class ClassifiedError extends Error {\n  readonly failure: ClassifiedFailure;\n  readonly action: string | undefined;\n\n  constructor(message: string, failure: ClassifiedFailure, action?: string) {\n    super(message);\n    this.name = 'ClassifiedError';\n    this.failure = failure;\n    this.action = action;\n  }\n}\n\n/** The verdict an error carries, or `null` when it carries none. */\nexport function failureOf(error: unknown): ClassifiedFailure | null {\n  return error instanceof ClassifiedError ? error.failure : null;\n}\n\n/** The human action an error asks for, or `null`. */\nexport function actionOf(error: unknown): string | null {\n  return error instanceof ClassifiedError ? (error.action ?? null) : null;\n}\n\n/* ── step 1: errno ──────────────────────────────────────────────────────── */\n\nconst ERRNO_KINDS: Readonly<Record<string, FailureKind>> = {\n  ENOTFOUND: 'network',\n  EAI_AGAIN: 'network',\n  ECONNRESET: 'network',\n  ECONNREFUSED: 'network',\n  ECONNABORTED: 'network',\n  EHOSTUNREACH: 'network',\n  ENETUNREACH: 'network',\n  ENETDOWN: 'network',\n  EPIPE: 'network',\n  ETIMEDOUT: 'timeout',\n  ENOENT: 'configuration',\n  EACCES: 'configuration',\n  EPERM: 'configuration',\n};\n\nfunction kindFromErrno(errno: string | undefined): FailureKind | undefined {\n  if (!errno) return undefined;\n  return ERRNO_KINDS[errno.toUpperCase()];\n}\n\n/* ── step 2: HTTP status ────────────────────────────────────────────────── */\n\n/**\n * GitHub reports a secondary rate limit as `403`, not `429`, so the text is\n * consulted before calling a `403` an authentication failure. Everywhere else\n * the status alone decides.\n */\nfunction kindFromHttpStatus(status: number | undefined, lowered: string): FailureKind | undefined {\n  if (status === undefined || status < 400) return undefined;\n  if (status === 429) return 'rate_limit';\n  if (status === 401) return 'authentication';\n  if (status === 403)\n    return matchesAny(lowered, RATE_LIMIT_PATTERNS) ? 'rate_limit' : 'authentication';\n  if (status === 408) return 'timeout';\n  if (status >= 500) return 'provider_down';\n  return 'configuration';\n}\n\n/* ── step 3: how the process ended ──────────────────────────────────────── */\n\nconst CRASH_SIGNALS: ReadonlySet<string> = new Set(['SIGKILL', 'SIGABRT', 'SIGSEGV', 'SIGBUS']);\n\nfunction kindFromTermination(signal: FailureSignal): FailureKind | undefined {\n  if (signal.stalled === true) return 'stalled';\n  if (signal.timedOut === true) return 'timeout';\n  const name = signal.signal?.toUpperCase();\n  if (!name) return undefined;\n  if (name === 'SIGTERM') return 'timeout';\n  if (CRASH_SIGNALS.has(name)) return 'provider_crash';\n  return undefined;\n}\n\n/* ── step 4: exit codes we know the meaning of ──────────────────────────── */\n\n/**\n * Only codes whose meaning is unambiguous. `143` (SIGTERM) is deliberately\n * absent: the Claude CLI handles the signal itself and exits `143` for a\n * user's Ctrl+C just as it does for our timeout, so it decides nothing on its\n * own — `timedOut` or `signal` is what tells the two apart.\n */\nconst EXIT_CODE_KINDS: Readonly<Record<number, FailureKind>> = {\n  75: 'provider_down', // EX_TEMPFAIL\n  126: 'configuration', // found, not executable\n  127: 'configuration', // command not found\n  137: 'provider_crash', // 128 + SIGKILL, typically the OOM killer\n  139: 'provider_crash', // 128 + SIGSEGV\n};\n\nfunction kindFromExitCode(exitCode: number | null | undefined): FailureKind | undefined {\n  if (exitCode === null || exitCode === undefined) return undefined;\n  return EXIT_CODE_KINDS[exitCode];\n}\n\n/* ── step 5: text, and only as a last resort ────────────────────────────── */\n\nconst RATE_LIMIT_PATTERNS = [\n  'rate limit',\n  'rate-limit',\n  'ratelimit',\n  'too many requests',\n  'http 429',\n] as const;\n\n/**\n * Ordered on purpose. A message is scanned rule by rule and the first hit\n * wins, so the specific causes (rate limit, credentials) are consulted before\n * the generic ones, and `task_execution` comes last: an infrastructure failure\n * surfacing inside a test run is still an infrastructure failure.\n */\ntype TextPattern = string | RegExp;\n\nconst TEXT_RULES: readonly { kind: FailureKind; patterns: readonly TextPattern[] }[] = [\n  { kind: 'rate_limit', patterns: RATE_LIMIT_PATTERNS },\n  {\n    kind: 'authentication',\n    patterns: [\n      'authentication failed',\n      'authentication_error',\n      'gh auth login',\n      'not logged into',\n      'bad credentials',\n      'invalid api key',\n      'invalid_api_key',\n      'token expired',\n      'expired token',\n      'unauthorized',\n      'http 401',\n      'http 403',\n    ],\n  },\n  {\n    kind: 'network',\n    patterns: [\n      'connection reset',\n      'connection refused',\n      'connection aborted',\n      'network error',\n      'network unavailable',\n      'temporary failure',\n      'econnreset',\n      'econnrefused',\n      'enotfound',\n      'eai_again',\n      'socket hang up',\n      // What Go prints, and therefore what `gh` prints: its network errors\n      // never mention \"connection reset\", they mention the resolver.\n      'no such host',\n      'dial tcp',\n      'i/o timeout',\n      'tls handshake timeout',\n      'server misbehaving',\n      'error connecting to',\n    ],\n  },\n  // Before the timeout rule: a stall *is* a kind of timeout, and the specific\n  // reading is the useful one — it has its own budget and its own escalation.\n  { kind: 'stalled', patterns: ['produced no output for', '(stalled)'] },\n  { kind: 'timeout', patterns: ['timed out', 'timeout', 'etimedout'] },\n  {\n    kind: 'provider_down',\n    patterns: [\n      'service unavailable',\n      'temporarily unavailable',\n      'overloaded',\n      'bad gateway',\n      'gateway timeout',\n      'internal server error',\n      'http 500',\n      'http 502',\n      'http 503',\n      'http 504',\n    ],\n  },\n  {\n    kind: 'provider_crash',\n    patterns: ['segmentation fault', 'core dumped', 'out of memory', 'killed by signal'],\n  },\n  {\n    kind: 'repository_state',\n    patterns: [\n      'unmerged paths',\n      'needs merge',\n      'automatic merge failed',\n      'rebase in progress',\n      'you are in the middle of',\n      'cherry-pick is in progress',\n      'not a git repository',\n    ],\n  },\n  {\n    kind: 'configuration',\n    patterns: [\n      'command not found',\n      'unknown flag',\n      'unknown option',\n      'no such file or directory',\n      'permission check failed',\n      'user denied permission',\n      'waiting for human input',\n      'status: waiting',\n      'below the minimum',\n      'prompt exceeds',\n      'nativetimeout',\n      'agy is not installed',\n    ],\n  },\n  {\n    kind: 'task_execution',\n    patterns: [\n      'test failed',\n      'tests failed',\n      'failed tests',\n      'failing test',\n      'assertion failed',\n      'assertionerror',\n      'expect(received)',\n      'typecheck failed',\n      'npm err! test failed',\n      'lint failed',\n      'build failed',\n      'compilation failed',\n      'syntaxerror',\n      'typeerror',\n      'referenceerror',\n      // What a runner actually prints: \"Tests  3 failed | 41 passed\",\n      // \"Test Files  1 failed (12)\", \"Tests: 2 failed, 8 total\".\n      /\\b\\d+\\s+failed\\b/,\n    ],\n  },\n];\n\nfunction matchesAny(lowered: string, patterns: readonly TextPattern[]): boolean {\n  return patterns.some((pattern) =>\n    typeof pattern === 'string' ? lowered.includes(pattern) : pattern.test(lowered),\n  );\n}\n\nfunction kindFromText(lowered: string): FailureKind | undefined {\n  if (!lowered) return undefined;\n  for (const rule of TEXT_RULES) {\n    if (matchesAny(lowered, rule.patterns)) return rule.kind;\n  }\n  return undefined;\n}\n\n/* ── Retry-After ────────────────────────────────────────────────────────── */\n\nconst RETRY_AFTER_IN_TEXT = /retry[\\s-]?after:?\\s*(\\d+)/i;\n\n/**\n * `Retry-After` is either a delay in seconds or an HTTP date. Both are\n * accepted; anything else, and a date already in the past, yields nothing\n * rather than a bogus zero.\n */\nfunction parseRetryAfter(value: string | number | undefined, now: number): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value === 'number')\n    return Number.isFinite(value) && value >= 0 ? value * 1000 : undefined;\n\n  const trimmed = value.trim();\n  if (trimmed === '') return undefined;\n  if (/^\\d+$/.test(trimmed)) return Number(trimmed) * 1000;\n\n  const at = Date.parse(trimmed);\n  if (Number.isNaN(at)) return undefined;\n  return at > now ? at - now : undefined;\n}\n\nfunction resolveRetryAfterMs(signal: FailureSignal, text: string, now: number): number | undefined {\n  const explicit = parseRetryAfter(signal.retryAfter, now);\n  if (explicit !== undefined) return explicit;\n\n  const inText = RETRY_AFTER_IN_TEXT.exec(text);\n  return inText ? Number(inText[1]) * 1000 : undefined;\n}\n\n/* ── message ────────────────────────────────────────────────────────────── */\n\nfunction combineOutput(signal: FailureSignal): string {\n  return [signal.stderr, signal.stdout].filter((part) => part && part.trim() !== '').join('\\n');\n}\n\n/** The output verbatim when there is any, and a synthesised line when there is not. */\nfunction describe(signal: FailureSignal, text: string): string {\n  const trimmed = text.trim();\n  if (trimmed !== '') return trimmed;\n  if (signal.errno) return `${signal.source} failed with ${signal.errno}`;\n  if (signal.httpStatus !== undefined)\n    return `${signal.source} responded HTTP ${signal.httpStatus}`;\n  if (signal.timedOut === true) return `${signal.source} timed out`;\n  if (signal.signal) return `${signal.source} was terminated by ${signal.signal}`;\n  if (signal.exitCode !== null && signal.exitCode !== undefined) {\n    return `${signal.source} exited with code ${signal.exitCode}`;\n  }\n  return `${signal.source} failed for an unreported reason`;\n}\n\n/* ── the classifier ─────────────────────────────────────────────────────── */\n\nexport interface ClassifyOptions {\n  /** Injectable clock, so an HTTP-date `Retry-After` is testable. */\n  now?: () => number;\n}\n\n/**\n * Classify a failure by precedence: errno and HTTP status first (a machine\n * told us), then how the process ended, then an exit code we know the meaning\n * of, and only then the text — which is a heuristic and is treated as one.\n */\nexport function classify(signal: FailureSignal, options: ClassifyOptions = {}): ClassifiedFailure {\n  const now = options.now?.() ?? Date.now();\n  const text = combineOutput(signal);\n  const lowered = text.toLowerCase();\n\n  const kind =\n    kindFromErrno(signal.errno) ??\n    kindFromHttpStatus(signal.httpStatus, lowered) ??\n    kindFromTermination(signal) ??\n    kindFromExitCode(signal.exitCode) ??\n    kindFromText(lowered) ??\n    'unknown';\n\n  const retryAfterMs = resolveRetryAfterMs(signal, text, now);\n\n  return {\n    kind,\n    message: describe(signal, text),\n    retryable: isRetryableKind(kind),\n    source: signal.source,\n    ...(retryAfterMs === undefined ? {} : { retryAfterMs }),\n  };\n}\n"],"mappings":";;;AAqEA,IAAM,kBAA4C,oBAAI,IAAiB;AAAA,EACrE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAOD,IAAM,qBAA+C,oBAAI,IAAiB;AAAA,EACxE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAGM,SAAS,gBAAgB,MAA4B;AAC1D,SAAO,gBAAgB,IAAI,IAAI;AACjC;AAGO,SAAS,oBAAoB,MAA4B;AAC9D,SAAO,mBAAmB,IAAI,IAAI;AACpC;AAgBO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EAChC;AAAA,EACA;AAAA,EAET,YAAY,SAAiB,SAA4B,QAAiB;AACxE,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,UAAU;AACf,SAAK,SAAS;AAAA,EAChB;AACF;AAGO,SAAS,UAAU,OAA0C;AAClE,SAAO,iBAAiB,kBAAkB,MAAM,UAAU;AAC5D;AAGO,SAAS,SAAS,OAA+B;AACtD,SAAO,iBAAiB,kBAAmB,MAAM,UAAU,OAAQ;AACrE;AAIA,IAAM,cAAqD;AAAA,EACzD,WAAW;AAAA,EACX,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,aAAa;AAAA,EACb,UAAU;AAAA,EACV,OAAO;AAAA,EACP,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,OAAO;AACT;AAEA,SAAS,cAAc,OAAoD;AACzE,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO,YAAY,MAAM,YAAY,CAAC;AACxC;AASA,SAAS,mBAAmB,QAA4B,SAA0C;AAChG,MAAI,WAAW,UAAa,SAAS,IAAK,QAAO;AACjD,MAAI,WAAW,IAAK,QAAO;AAC3B,MAAI,WAAW,IAAK,QAAO;AAC3B,MAAI,WAAW;AACb,WAAO,WAAW,SAAS,mBAAmB,IAAI,eAAe;AACnE,MAAI,WAAW,IAAK,QAAO;AAC3B,MAAI,UAAU,IAAK,QAAO;AAC1B,SAAO;AACT;AAIA,IAAM,gBAAqC,oBAAI,IAAI,CAAC,WAAW,WAAW,WAAW,QAAQ,CAAC;AAE9F,SAAS,oBAAoB,QAAgD;AAC3E,MAAI,OAAO,YAAY,KAAM,QAAO;AACpC,MAAI,OAAO,aAAa,KAAM,QAAO;AACrC,QAAM,OAAO,OAAO,QAAQ,YAAY;AACxC,MAAI,CAAC,KAAM,QAAO;AAClB,MAAI,SAAS,UAAW,QAAO;AAC/B,MAAI,cAAc,IAAI,IAAI,EAAG,QAAO;AACpC,SAAO;AACT;AAUA,IAAM,kBAAyD;AAAA,EAC7D,IAAI;AAAA;AAAA,EACJ,KAAK;AAAA;AAAA,EACL,KAAK;AAAA;AAAA,EACL,KAAK;AAAA;AAAA,EACL,KAAK;AAAA;AACP;AAEA,SAAS,iBAAiB,UAA8D;AACtF,MAAI,aAAa,QAAQ,aAAa,OAAW,QAAO;AACxD,SAAO,gBAAgB,QAAQ;AACjC;AAIA,IAAM,sBAAsB;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAUA,IAAM,aAAiF;AAAA,EACrF,EAAE,MAAM,cAAc,UAAU,oBAAoB;AAAA,EACpD;AAAA,IACE,MAAM;AAAA,IACN,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA;AAAA,MAGA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA,EAGA,EAAE,MAAM,WAAW,UAAU,CAAC,0BAA0B,WAAW,EAAE;AAAA,EACrE,EAAE,MAAM,WAAW,UAAU,CAAC,aAAa,WAAW,WAAW,EAAE;AAAA,EACnE;AAAA,IACE,MAAM;AAAA,IACN,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,UAAU,CAAC,sBAAsB,eAAe,iBAAiB,kBAAkB;AAAA,EACrF;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA;AAAA,MAGA;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,WAAW,SAAiB,UAA2C;AAC9E,SAAO,SAAS;AAAA,IAAK,CAAC,YACpB,OAAO,YAAY,WAAW,QAAQ,SAAS,OAAO,IAAI,QAAQ,KAAK,OAAO;AAAA,EAChF;AACF;AAEA,SAAS,aAAa,SAA0C;AAC9D,MAAI,CAAC,QAAS,QAAO;AACrB,aAAW,QAAQ,YAAY;AAC7B,QAAI,WAAW,SAAS,KAAK,QAAQ,EAAG,QAAO,KAAK;AAAA,EACtD;AACA,SAAO;AACT;AAIA,IAAM,sBAAsB;AAO5B,SAAS,gBAAgB,OAAoC,KAAiC;AAC5F,MAAI,UAAU,OAAW,QAAO;AAChC,MAAI,OAAO,UAAU;AACnB,WAAO,OAAO,SAAS,KAAK,KAAK,SAAS,IAAI,QAAQ,MAAO;AAE/D,QAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,GAAI,QAAO;AAC3B,MAAI,QAAQ,KAAK,OAAO,EAAG,QAAO,OAAO,OAAO,IAAI;AAEpD,QAAM,KAAK,KAAK,MAAM,OAAO;AAC7B,MAAI,OAAO,MAAM,EAAE,EAAG,QAAO;AAC7B,SAAO,KAAK,MAAM,KAAK,MAAM;AAC/B;AAEA,SAAS,oBAAoB,QAAuB,MAAc,KAAiC;AACjG,QAAM,WAAW,gBAAgB,OAAO,YAAY,GAAG;AACvD,MAAI,aAAa,OAAW,QAAO;AAEnC,QAAM,SAAS,oBAAoB,KAAK,IAAI;AAC5C,SAAO,SAAS,OAAO,OAAO,CAAC,CAAC,IAAI,MAAO;AAC7C;AAIA,SAAS,cAAc,QAA+B;AACpD,SAAO,CAAC,OAAO,QAAQ,OAAO,MAAM,EAAE,OAAO,CAAC,SAAS,QAAQ,KAAK,KAAK,MAAM,EAAE,EAAE,KAAK,IAAI;AAC9F;AAGA,SAAS,SAAS,QAAuB,MAAsB;AAC7D,QAAM,UAAU,KAAK,KAAK;AAC1B,MAAI,YAAY,GAAI,QAAO;AAC3B,MAAI,OAAO,MAAO,QAAO,GAAG,OAAO,MAAM,gBAAgB,OAAO,KAAK;AACrE,MAAI,OAAO,eAAe;AACxB,WAAO,GAAG,OAAO,MAAM,mBAAmB,OAAO,UAAU;AAC7D,MAAI,OAAO,aAAa,KAAM,QAAO,GAAG,OAAO,MAAM;AACrD,MAAI,OAAO,OAAQ,QAAO,GAAG,OAAO,MAAM,sBAAsB,OAAO,MAAM;AAC7E,MAAI,OAAO,aAAa,QAAQ,OAAO,aAAa,QAAW;AAC7D,WAAO,GAAG,OAAO,MAAM,qBAAqB,OAAO,QAAQ;AAAA,EAC7D;AACA,SAAO,GAAG,OAAO,MAAM;AACzB;AAcO,SAAS,SAAS,QAAuB,UAA2B,CAAC,GAAsB;AAChG,QAAM,MAAM,QAAQ,MAAM,KAAK,KAAK,IAAI;AACxC,QAAM,OAAO,cAAc,MAAM;AACjC,QAAM,UAAU,KAAK,YAAY;AAEjC,QAAM,OACJ,cAAc,OAAO,KAAK,KAC1B,mBAAmB,OAAO,YAAY,OAAO,KAC7C,oBAAoB,MAAM,KAC1B,iBAAiB,OAAO,QAAQ,KAChC,aAAa,OAAO,KACpB;AAEF,QAAM,eAAe,oBAAoB,QAAQ,MAAM,GAAG;AAE1D,SAAO;AAAA,IACL;AAAA,IACA,SAAS,SAAS,QAAQ,IAAI;AAAA,IAC9B,WAAW,gBAAgB,IAAI;AAAA,IAC/B,QAAQ,OAAO;AAAA,IACf,GAAI,iBAAiB,SAAY,CAAC,IAAI,EAAE,aAAa;AAAA,EACvD;AACF;","names":[]}

package/dist/cli.js

@@ -1,25 +1,36 @@
 #!/usr/bin/env node
 import {
   DEFAULT_INACTIVITY_TIMEOUT_MS,
-  installShutdownHandlers
-} from "./chunk-M66SJHQQ.js";
-import {
+  installShutdownHandlers,
+  parseAgentPhaseFlag,
+  setAgentCliOverrides,
   setIssuesCliOverrides,
   setResilienceCliOverrides,
+  setRoutingCliOverrides,
+  setVerifyCliOverrides,
   setWebCliOverrides
-} from "./chunk-42PJFMAR.js";
-import "./chunk-DIDUVL6O.js";
+} from "./chunk-CNBYCMSU.js";
+import "./chunk-HQAHNIAR.js";
 import {
   printError,
   setGlobalTimeout,
   setInactivityTimeout,
   setVerbose
-} from "./chunk-BYZDPR7N.js";
-import "./chunk-CD5ULRVC.js";
+} from "./chunk-IYV6KNVF.js";
+import "./chunk-6FDFRNXZ.js";
+import "./chunk-P3LRUNC6.js";
+import "./chunk-DIG5XKQQ.js";
+import {
+  isAgentProviderId
+} from "./chunk-NEZZ6KDR.js";
+import "./chunk-TX5WIVYP.js";
+import "./chunk-KQHB7ZT3.js";
+import "./chunk-7Z4Y3VKM.js";
+import "./chunk-XEYH6ZZI.js";
 
 // src/cli.ts
 import { createRequire } from "module";
-import { Command, InvalidArgumentError } from "commander";
+import { Command, InvalidArgumentError, Option } from "commander";
 
 // src/cli-options.ts
 function resolveNoBranch(options) {
@@ -37,9 +48,15 @@ function resolveQueueScopeFlags(options) {
       "--yes cannot be combined with --only: --yes runs the whole discovered hierarchy, --only runs just the issues you informed."
     );
   }
+  if (options.cascade === true && options.only === true) {
+    throw new CliFlagError(
+      "--cascade cannot be combined with --only: --cascade runs the container hierarchy, --only runs just the issues you informed."
+    );
+  }
   return {
     yes: options.yes === true ? true : void 0,
-    only: options.only === true ? true : void 0
+    only: options.only === true ? true : void 0,
+    cascade: options.cascade === true ? true : void 0
   };
 }
 function resolveRunPhaseFlags(options) {
@@ -156,6 +173,16 @@ function parseInteger(value) {
   }
   return parsed;
 }
+function parseUsd(value) {
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("Must be a non-negative number.");
+  }
+  return parsed;
+}
+function collectString(value, previous) {
+  return [...previous, value];
+}
 function parseQueueFailureMode(value) {
   if (value === "stop" || value === "skip" || value === "block") return value;
   throw new InvalidArgumentError("Must be one of: stop, skip, block.");
@@ -175,7 +202,7 @@ function withUserStoryNumberingOptions(cmd) {
   );
 }
 function withGlobalOptions(cmd) {
-  return cmd.option("-v, --verbose", "Show Claude progress output in real time").option(
+  return cmd.option("-v, --verbose", "Show agent progress output in real time").option(
     "-t, --timeout <seconds>",
     "Override headless timeout in seconds (0 = no limit)",
     parseInteger
@@ -183,7 +210,67 @@ function withGlobalOptions(cmd) {
     "--inactivity-timeout <seconds>",
     "Stop the agent after this many seconds with no output (0 = no watchdog)",
     parseInteger
-  );
+  ).option(
+    "--agent <provider>",
+    "Run every phase on this agent (claude|codex|cursor|antigravity)"
+  ).option("--agent-model <model>", "Override the model for every phase").option(
+    "--agent-phase <phase>=<provider>[:<model>]",
+    "Override one phase (repeatable)",
+    collectAgentPhase,
+    {}
+  ).option("--verify-level <level>", "Acceptance-contract level: L0 | L1 | L2 | L3 | L5").option("--no-cross-verify", "Keep L2 off even when a trigger would fire").option("--no-escalation", "Keep routing.escalation.enabled off").option("--max-cost <usd>", "Issue cost ceiling in USD (Issue Flow enforces it)", parseUsd).option("--max-duration <seconds>", "Issue duration ceiling in seconds", parseInteger);
+}
+function collectAgentPhase(value, previous) {
+  const parsed = parseAgentPhaseFlag(value);
+  return { ...previous, [parsed.phase]: parsed.block };
+}
+function resolveAgentOverrides(opts) {
+  const overrides = {};
+  if (typeof opts.agent === "string") {
+    if (!isAgentProviderId(opts.agent)) {
+      throw new InvalidArgumentError("Must be one of: claude, codex, cursor, antigravity.");
+    }
+    overrides.forceProvider = opts.agent;
+  }
+  if (typeof opts.agentModel === "string") {
+    overrides.forceModel = opts.agentModel;
+  }
+  if (opts.agentPhase && typeof opts.agentPhase === "object") {
+    overrides.phases = opts.agentPhase;
+  }
+  return overrides;
+}
+var VERIFY_LEVELS = ["L0", "L1", "L2", "L3", "L5"];
+function resolveVerifyOverrides(opts) {
+  const overrides = {};
+  if (typeof opts.verifyLevel === "string") {
+    if (!VERIFY_LEVELS.includes(opts.verifyLevel)) {
+      throw new InvalidArgumentError("Must be one of: L0, L1, L2, L3, L5.");
+    }
+    overrides.level = opts.verifyLevel;
+  }
+  if (opts.crossVerify === false) overrides.crossVerify = false;
+  return overrides;
+}
+function resolveRoutingOverrides(opts) {
+  const overrides = {};
+  if (opts.escalation === false) {
+    overrides.escalation = {
+      enabled: false,
+      minAttemptsBeforeEscalation: 2,
+      maxEscalations: 2,
+      maxRungs: ["effort", "model", "harness"]
+    };
+  }
+  if (typeof opts.maxCost === "number" || typeof opts.maxDuration === "number") {
+    overrides.ceilings = {
+      maxCostUsdPerIssue: typeof opts.maxCost === "number" ? opts.maxCost : null,
+      maxDurationMsPerIssue: typeof opts.maxDuration === "number" ? opts.maxDuration * 1e3 : null,
+      maxExecutionsPerIssue: null,
+      onCeiling: "block"
+    };
+  }
+  return overrides;
 }
 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");
@@ -218,7 +305,7 @@ function resolveWebOverrides(opts) {
 }
 var program = new Command();
 program.name("issue-flow").description(
-  "Unified CLI for orchestrating the full issue-flow pipeline via Claude Code Headless."
+  "Unified CLI for orchestrating the full issue-flow pipeline via Claude Code, Codex CLI, Cursor CLI or Antigravity CLI."
 ).version(version);
 program.hook("preAction", (_thisCommand, actionCommand) => {
   installShutdownHandlers();
@@ -233,6 +320,17 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
     setInactivityTimeout(opts.inactivityTimeout * 1e3);
   }
   setWebCliOverrides(resolveWebOverrides(opts));
+  try {
+    setVerifyCliOverrides(resolveVerifyOverrides(opts));
+    setAgentCliOverrides(resolveAgentOverrides(opts));
+    setRoutingCliOverrides(resolveRoutingOverrides(opts));
+  } catch (error) {
+    if (error instanceof InvalidArgumentError) {
+      printError(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
   setResilienceCliOverrides(
     resolveResilienceOverrides({
       continuous: opts.continuous,
@@ -257,19 +355,22 @@ withIssueOptions(
   withGlobalOptions(
     program.command("init").description(
       "Check prerequisites and report (or create) the conventions this repository is missing"
-    ).option("--apply", "Create the missing files instead of only reporting them").option("--json", "Emit the plan as JSON").option("--scope <dir>", "Resolve the conventions for a subdirectory (monorepo)").option("--check-only", "Only verify prerequisites, as earlier releases did")
+    ).option("--apply", "Create the missing files instead of only reporting them").option("--json", "Emit the plan as JSON").option("--scope <dir>", "Resolve the conventions for a subdirectory (monorepo)").option("--check-only", "Only verify prerequisites, as earlier releases did").option("--no-agent-prompt", "Skip the first-run agent choice")
   )
 ).action(
   async (options) => {
-    const { loadIssuesConfig } = await import("./config-PRJGWW7J.js");
-    const { runInit } = await import("./init-AJHCXJBP.js");
+    const { loadIssuesConfig } = await import("./config-MEM2IWWN.js");
+    const { runInit } = await import("./init-OKWEC3EV.js");
     const { preferredProvider } = await loadIssuesConfig();
-    const code = await runInit(preferredProvider, options);
+    const code = await runInit(preferredProvider, {
+      ...options,
+      noAgentPrompt: options.agentPrompt === false
+    });
     process.exit(code);
   }
 );
 withGlobalOptions(
-  program.command("generate").description("Draft an issue via Claude Code Headless and create it").requiredOption("--prompt <text>", "Issue description text").option("--github", "Create the issue on GitHub").option("--local", "Create the issue under issues/<n>/ only").option("--both", "Create the issue on GitHub and mirror it locally")
+  program.command("generate").description("Draft an issue with the configured agent and create it").requiredOption("--prompt <text>", "Issue description text").option("--github", "Create the issue on GitHub").option("--local", "Create the issue under issues/<n>/ only").option("--both", "Create the issue on GitHub and mirror it locally")
 ).action(async (options) => {
   let target;
   try {
@@ -281,7 +382,7 @@ withGlobalOptions(
     }
     throw error;
   }
-  const { runGenerate } = await import("./generate-EGB4KV2B.js");
+  const { runGenerate } = await import("./generate-MVQI7A45.js");
   const code = await runGenerate(options.prompt, target);
   process.exit(code);
 });
@@ -295,7 +396,7 @@ withUserStoryNumberingOptions(
           ).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(
+          ).option("--pr-review", "Review the created Pull Request after the pr phase").option("-y, --yes", "Run the whole discovered hierarchy without confirmation").option("--cascade", "Run the children of a container, without implementing it").option("--only", "Run just the issues informed, without their hierarchy").option(
             "--retry-limit <number>",
             "Retry transient Claude failures up to N consecutive times",
             parseInteger
@@ -303,7 +404,7 @@ withUserStoryNumberingOptions(
             "--on-issue-failure <mode>",
             "In a queue, on a failing issue: stop | skip | block",
             parseQueueFailureMode
-          )
+          ).option("-d, --background", "Detach after confirmation and return the terminal").addOption(new Option("--detached-child").hideHelp())
         )
       )
     )
@@ -324,7 +425,7 @@ withUserStoryNumberingOptions(
       }
       throw error;
     }
-    const { runPipeline } = await import("./run-RXE5GDQO.js");
+    const { runPipeline } = await import("./run-YU4TR62R.js");
     const code = await runPipeline(
       issues,
       options.mode,
@@ -334,11 +435,14 @@ withUserStoryNumberingOptions(
       {
         yes: scope.yes,
         only: scope.only,
+        cascade: scope.cascade,
         continueNumbering: numbering.continueFlag,
         startUs: numbering.startUs,
         retryLimit: options.retryLimit,
         retryForever: options.retryForever,
-        onIssueFailure: options.onIssueFailure
+        onIssueFailure: options.onIssueFailure,
+        background: options.background,
+        detachedChild: options.detachedChild
       }
     );
     process.exit(code);
@@ -349,7 +453,7 @@ withIssueOptions(
     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 { runResume } = await import("./resume-QMEPMSZW.js");
   const code = await runResume(issue, {
     ...options.all === void 0 ? {} : { all: options.all },
     ...options.mode === void 0 ? {} : { mode: options.mode }
@@ -359,22 +463,47 @@ withIssueOptions(
 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");
+  const { runStatus } = await import("./operations-LU6JA3BX.js");
   process.exit(
     await runStatus(issue, { ...options.json === void 0 ? {} : { json: options.json } })
   );
 });
+withGlobalOptions(
+  program.command("usage").description("Aggregate execution telemetry from tasks.json").argument("[issue]", "Restrict the report to one issue").option("--issue <issue>", "Same as the positional argument").option("--since <date>", "Only executions started on or after this ISO date").option("--by <key>", "Group by harness, provider, model, purpose or status").option("--json", "Emit the assembled totals as JSON")
+).action(
+  async (issue, options) => {
+    const { runUsage, USAGE_GROUP_KEYS } = await import("./usage-VCFLDA5Y.js");
+    const by = options.by;
+    if (by !== void 0 && !USAGE_GROUP_KEYS.includes(by)) {
+      printError("Must be one of: harness, provider, model, purpose, status.");
+      process.exit(1);
+    }
+    process.exit(
+      await runUsage(issue ?? options.issue, {
+        ...options.since === void 0 ? {} : { since: options.since },
+        ...by === void 0 ? {} : { by },
+        ...options.json === void 0 ? {} : { json: options.json }
+      })
+    );
+  }
+);
+withGlobalOptions(
+  program.command("ps").description("Every issue-flow run active on this machine").option("--json", "Emit the listing as JSON").option("--watch", "Refresh the listing until interrupted")
+).action(async (options) => {
+  const { runPs } = await import("./ps-TNE44R5V.js");
+  process.exit(await runPs(options));
+});
 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");
+  const { runRuns } = await import("./operations-LU6JA3BX.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 { runLogs } = await import("./operations-LU6JA3BX.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, {
@@ -388,37 +517,37 @@ withGlobalOptions(
 withGlobalOptions(
   program.command("pause").description("Ask the running pipeline to stop after writing a checkpoint")
 ).action(async () => {
-  const { runPause } = await import("./operations-BYT626KQ.js");
+  const { runPause } = await import("./operations-LU6JA3BX.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");
+  const { runCancel } = await import("./operations-LU6JA3BX.js");
   process.exit(await runCancel(issue));
 });
 withIssueOptions(
   withGlobalOptions(
-    program.command("analyze").description("Analyze an issue via Claude Code Headless").argument("<issue>", "Issue number")
+    program.command("analyze").description("Analyze an issue with the configured agent").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runAnalyze } = await import("./analyze-OEET7KGE.js");
+  const { runAnalyze } = await import("./analyze-WS47UYGN.js");
   const code = await runAnalyze(issue);
   process.exit(code);
 });
 withIssueOptions(
   withGlobalOptions(
-    program.command("prd").description("Generate a PRD from an analyzed issue via Claude Code Headless").argument("<issue>", "Issue number")
+    program.command("prd").description("Generate a PRD from an analyzed issue with the configured agent").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runPrd } = await import("./prd-JQSZF7PR.js");
+  const { runPrd } = await import("./prd-5O6GYCC6.js");
   const code = await runPrd(issue);
   process.exit(code);
 });
 withUserStoryNumberingOptions(
   withIssueOptions(
     withGlobalOptions(
-      program.command("plan").description("Convert a PRD to a tasks.json task plan via Claude Code Headless").argument("<issue>", "Issue number")
+      program.command("plan").description("Convert a PRD to a tasks.json task plan with the configured agent").argument("<issue>", "Issue number")
     )
   )
 ).action(async (issue, options) => {
@@ -432,7 +561,7 @@ withUserStoryNumberingOptions(
     }
     throw error;
   }
-  const { runPlan } = await import("./plan-QOZ3RIO6.js");
+  const { runPlan } = await import("./plan-LEJJF3DE.js");
   const code = await runPlan(issue, void 0, numbering);
   process.exit(code);
 });
@@ -451,7 +580,7 @@ withWebOptions(
 ).action(
   async (positionalMaxIter, options) => {
     try {
-      const { runExecute } = await import("./execute-XBNVL753.js");
+      const { runExecute } = await import("./execute-NITIHHCK.js");
       const code = await runExecute(positionalMaxIter, options);
       process.exit(code);
     } catch (error) {
@@ -462,19 +591,19 @@ withWebOptions(
 );
 withIssueOptions(
   withGlobalOptions(
-    program.command("review").description("Validate an issue resolution via Claude Code Headless").argument("<issue>", "Issue number")
+    program.command("review").description("Validate an issue resolution with the configured agent").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runReview } = await import("./review-3F6MARWH.js");
+  const { runReview } = await import("./review-YKWD6SNN.js");
   const code = await runReview(issue);
   process.exit(code);
 });
 withIssueOptions(
   withGlobalOptions(
-    program.command("pr").description("Create a pull request via Claude Code Headless").argument("<issue>", "Issue number")
+    program.command("pr").description("Create a pull request with the configured agent").argument("<issue>", "Issue number")
   )
 ).action(async (issue) => {
-  const { runPr } = await import("./pr-EBBHD2ZX.js");
+  const { runPr } = await import("./pr-HPVUZ7S3.js");
   const code = await runPr(issue);
   process.exit(code);
 });
@@ -482,35 +611,126 @@ 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-EF5WIIGG.js");
+  const { runWebServe } = await import("./web-XVHLX62B.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-EF5WIIGG.js");
+  const { runWebStop } = await import("./web-XVHLX62B.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-6S4GFC76.js");
+  const { runPolicy } = await import("./policy-JSYEK5B2.js");
   const code = await runPolicy(options);
   process.exit(code);
 });
+var routingCommand = withGlobalOptions(
+  program.command("routing").description("Inspect the shadow router (records a recommendation, does not act)")
+);
+routingCommand.option("--json", "Emit the resolved routing config as JSON").action(async (options) => {
+  const { runRoutingInspect } = await import("./routing-2ZUMZPJB.js");
+  process.exit(await runRoutingInspect(options));
+});
+routingCommand.command("report").description("Shadow agreement between selected and actual harness").option("--issue <n>", "Issue number").option("--json", "Emit JSON").action(async (options) => {
+  const { runRoutingReport } = await import("./routing-2ZUMZPJB.js");
+  process.exit(await runRoutingReport(options));
+});
+var conventionsCommand = withGlobalOptions(
+  program.command("conventions").description("Compute the repository Git convention (branch, commit, PR title)")
+);
+conventionsCommand.command("branch").description("Print the deterministic branch name for an issue").option("--issue <n>", "Issue number").option("--title <text>", "Issue title, when the issue cannot be resolved").option("--json", "Emit JSON").action(async (options) => {
+  const { runConventionsBranch } = await import("./conventions-WV4NDXGH.js");
+  process.exit(await runConventionsBranch(options));
+});
+conventionsCommand.command("commit").description("Print a Conventional Commit message").requiredOption("--type <type>", "Change type (feat, fix, docs, \u2026)").option("--scope <scope>", "Optional scope").requiredOption("--subject <text>", "Commit subject").option("--issue <n>", "Issue number for the Refs trailer").option("--story <id>", "Story id (US-010)").option("--breaking <text>", "Breaking change description").option("--json", "Emit JSON").action(
+  async (options) => {
+    const { runConventionsCommit } = await import("./conventions-WV4NDXGH.js");
+    process.exit(await runConventionsCommit(options));
+  }
+);
+conventionsCommand.command("pr-title").description("Print the Conventional Commit Pull Request title").option("--issue <n>", "Issue number").option("--title <text>", "Issue title, when the issue cannot be resolved").option("--json", "Emit JSON").action(async (options) => {
+  const { runConventionsPrTitle } = await import("./conventions-WV4NDXGH.js");
+  process.exit(await runConventionsPrTitle(options));
+});
+var agentCommand = withGlobalOptions(
+  program.command("agent").description("Inspect the resolved agent and model for each phase").option("--json", "Emit the resolved agent configuration as JSON")
+);
+agentCommand.action(async (options) => {
+  const { runAgent } = await import("./agent-BXRIEKVM.js");
+  const code = await runAgent(options);
+  process.exit(code);
+});
+agentCommand.command("use").description("Write an agent preference to config.json or .issue-flow.json").argument("<provider>", "claude, codex, cursor or antigravity").option("--model <model>", "Model identifier for this preference").option("--global", "Write to ~/.issue-flow/config.json (default)").option("--project", "Write to .issue-flow.json in the repository").option("--phase <phase>", "Write only the override for this phase").action(
+  async (provider, options) => {
+    const { runAgentUse } = await import("./agent-BXRIEKVM.js");
+    const code = await runAgentUse(provider, options);
+    process.exit(code);
+  }
+);
 withGlobalOptions(
-  program.command("pr-review").description("Review a Pull Request as a whole via Claude Code Headless").argument("[pr]", "Pull Request number (discovered from the session when omitted)").option("--issue <n>", "Issue the Pull Request belongs to").option("--round <n>", "Rewrite a specific review round instead of appending a new one").option("--yes", "Skip the confirmation of the discovered Pull Request").option(
+  program.command("pr-review").description("Review a Pull Request as a whole with the configured agent").argument("[pr]", "Pull Request number (discovered from the session when omitted)").option("--issue <n>", "Issue the Pull Request belongs to").option("--round <n>", "Rewrite a specific review round instead of appending a new one").option("--yes", "Skip the confirmation of the discovered Pull Request").option(
     "--fail-on <level>",
     "Verdict that fails the command: request-changes | suggestions | none"
   )
 ).action(
   async (pr, options) => {
-    const { runPrReview } = await import("./pr-review-VVMW5PO4.js");
+    const { runPrReview } = await import("./pr-review-R2QZBT3F.js");
     const code = await runPrReview(pr, options);
     process.exit(code);
   }
 );
+withGlobalOptions(
+  program.command("bench").description("Measure the corpus: synthetic (CI) or real (paid, on demand)").option("--mode <mode>", "synthetic (default, free) or real (fixtures + harness)").option(
+    "--task <class>",
+    "Corpus class (repeatable): trivial, small, medium, analysis",
+    collectString,
+    []
+  ).option("--arm <name>", "Experiment arm (repeatable). Default: baseline", collectString, []).option("--repeats <n>", "Repetitions per cell (default 5)", parseInteger).option(
+    "--campaign-max-cost <usd>",
+    "Campaign cost ceiling in USD (evaluateCeilings)",
+    parseUsd
+  ).option(
+    "--campaign-max-duration <ms>",
+    "Campaign duration ceiling in milliseconds",
+    parseInteger
+  ).option("--out <path>", "Write the markdown report to this path").option("--yes", "Skip the paid-campaign confirmation").option("--repo <path>", "Investigation escape; does not produce a publishable row").option("--json", "Also emit the campaign JSON")
+).action(
+  async (options) => {
+    if (options.mode !== void 0 && options.mode !== "synthetic" && options.mode !== "real") {
+      printError("Unknown bench mode. Use 'synthetic' or 'real'.");
+      process.exit(1);
+    }
+    const { runBench } = await import("./bench-SA3BOME5.js");
+    process.exit(
+      await runBench({
+        ...options.mode === void 0 ? {} : { mode: options.mode },
+        ...options.task === void 0 || options.task.length === 0 ? {} : { task: options.task },
+        ...options.arm === void 0 || options.arm.length === 0 ? {} : { arm: options.arm },
+        ...options.repeats === void 0 ? {} : { repeats: options.repeats },
+        ...options.campaignMaxCost === void 0 ? {} : { maxCost: options.campaignMaxCost },
+        ...options.campaignMaxDuration === void 0 ? {} : { maxDuration: options.campaignMaxDuration },
+        ...options.out === void 0 ? {} : { out: options.out },
+        ...options.yes === void 0 ? {} : { yes: options.yes },
+        ...options.repo === void 0 ? {} : { repo: options.repo },
+        ...options.json === void 0 ? {} : { json: options.json }
+      })
+    );
+  }
+);
+program.action(async () => {
+  const { listLiveRuns } = await import("./registry-LGPE53QD.js");
+  const runs = await listLiveRuns();
+  if (runs.length === 0) {
+    program.help();
+    return;
+  }
+  const { runPs } = await import("./ps-TNE44R5V.js");
+  process.exit(await runPs());
+});
 program.parse();
 //# sourceMappingURL=cli.js.map