issue-flow 0.11.1 → 0.12.0

package/dist/chunk-56KS3TFQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/journal.ts","../src/core/pipeline.ts","../src/execution/plan.ts","../src/issues/graph.ts","../src/execution/order.ts"],"sourcesContent":["import { appendFile, mkdir, rename, stat, unlink } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport {\n  createInitialSnapshot,\n  MemoryPublisher,\n  type MemoryPublisherOptions,\n  reduceSessionEvent,\n  type SessionEvent,\n  type SessionPublisher,\n  type SessionReducerOptions,\n  type SessionSnapshot,\n} from './session-state.js';\n\n/**\n * Append-only journal of `SessionEvent`s.\n *\n * `session.json` is a *projection*: the reducer folds every event into one\n * snapshot and the events themselves are discarded. That is the right shape for\n * a dashboard and the wrong one for an audit — after a six-hour run, \"what\n * happened at 3am\" has no answer, because the retries, the failures and their\n * order were consumed to produce a single final state.\n *\n * This publisher writes the events instead of the state: one JSON line each, in\n * order, with a monotonic `seq`. It sits **beside** `FilePublisher`, never in\n * its place. The snapshot stays the projection; the journal is the history, and\n * replaying it through `reduceSessionEvent` reproduces the snapshot — which is\n * the property `replayJournal()` and its test exist to keep true.\n *\n * The invariant of `session-state.ts` holds here unchanged: `publish()` is\n * synchronous, never throws, and every I/O failure is swallowed after a single\n * warning. Monitoring never affects the pipeline.\n */\n\n/** One line of `events.jsonl`. */\nexport interface JournalEntry {\n  /** 1-based, monotonic within a file *and* across a rotation. */\n  seq: number;\n  event: SessionEvent;\n}\n\n/** Default ceiling before the journal rotates. */\nexport const DEFAULT_JOURNAL_MAX_BYTES = 10 * 1024 * 1024;\n\nexport interface JournalPublisherOptions extends MemoryPublisherOptions {\n  /**\n   * Rotate once the file would grow past this. Default 10 MB. `0` disables\n   * rotation, which is what a caller that manages its own retention wants.\n   */\n  maxFileBytes?: number;\n}\n\n/**\n * Publisher that appends every event to `events.jsonl`.\n *\n * Writes are serialized on a promise chain — the same discipline as\n * `FilePublisher` — so lines never interleave and the order on disk is the\n * order of `publish()`. Nothing is throttled: dropping or coalescing events is\n * exactly what the snapshot already does, and the point of the journal is that\n * it does not.\n */\nexport class JournalPublisher extends MemoryPublisher {\n  private readonly filePath: string;\n  private readonly rotatedPath: string;\n  private readonly maxFileBytes: number;\n  private seq = 0;\n  private writeChain: Promise<void> = Promise.resolve();\n  private closed = false;\n  /** Bytes in the current file. `null` until the first write measures it. */\n  private bytes: number | null = null;\n\n  constructor(filePath: string, rotatedPath: string, options: JournalPublisherOptions = {}) {\n    super(options);\n    this.filePath = filePath;\n    this.rotatedPath = rotatedPath;\n    this.maxFileBytes = options.maxFileBytes ?? DEFAULT_JOURNAL_MAX_BYTES;\n  }\n\n  protected override afterPublish(event: SessionEvent): void {\n    if (this.closed) return;\n    this.seq++;\n    const line = `${JSON.stringify({ seq: this.seq, event } satisfies JournalEntry)}\\n`;\n    this.enqueue(line);\n  }\n\n  private enqueue(line: string): void {\n    this.writeChain = this.writeChain.then(async () => {\n      try {\n        await this.appendLine(line);\n      } catch (err) {\n        this.warnOnce(err);\n      }\n    });\n  }\n\n  private async appendLine(line: string): Promise<void> {\n    const size = Buffer.byteLength(line);\n\n    if (this.bytes === null) {\n      await mkdir(dirname(this.filePath), { recursive: true });\n      this.bytes = await currentSize(this.filePath);\n    }\n\n    // Rotate *before* the write that would cross the ceiling, so a line is\n    // never split across two files: an entry that cannot be parsed whole is\n    // worse than a file slightly under its limit.\n    if (this.maxFileBytes > 0 && this.bytes > 0 && this.bytes + size > this.maxFileBytes) {\n      await this.rotate();\n    }\n\n    await appendFile(this.filePath, line, 'utf-8');\n    this.bytes += size;\n  }\n\n  /**\n   * Keep exactly one previous generation.\n   *\n   * Deliberately not a numbered cascade: two files bound the disk cost at\n   * `2 * maxFileBytes`, and a run long enough to fill 10 MB twice has already\n   * put everything a human would look for in the current file. A caller that\n   * needs full retention sets `maxFileBytes: 0` and rotates on its own terms.\n   */\n  private async rotate(): Promise<void> {\n    try {\n      await unlink(this.rotatedPath);\n    } catch {\n      // No previous generation. Nothing to remove.\n    }\n    await rename(this.filePath, this.rotatedPath);\n    this.bytes = 0;\n  }\n\n  override async flush(): Promise<void> {\n    await this.writeChain;\n  }\n\n  override async close(): Promise<void> {\n    await this.flush();\n    this.closed = true;\n  }\n}\n\n/** Size of `path` in bytes, or `0` when it does not exist yet. */\nasync function currentSize(path: string): Promise<number> {\n  try {\n    return (await stat(path)).size;\n  } catch {\n    return 0;\n  }\n}\n\n/**\n * Parse the lines of a journal, skipping what cannot be read.\n *\n * A journal is appended to by a live process and read by another, so the last\n * line may well be a partial write. Tolerating it — and any line a newer\n * release wrote in a shape this one does not know — is what makes the file\n * usable at all; the alternative is a reader that throws on a healthy run.\n */\nexport function parseJournal(content: string): JournalEntry[] {\n  const entries: JournalEntry[] = [];\n\n  for (const line of content.split('\\n')) {\n    const trimmed = line.trim();\n    if (trimmed === '') continue;\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(trimmed);\n    } catch {\n      continue;\n    }\n\n    if (!isEntry(parsed)) continue;\n    entries.push(parsed);\n  }\n\n  return entries;\n}\n\nfunction isEntry(value: unknown): value is JournalEntry {\n  if (typeof value !== 'object' || value === null) return false;\n  const candidate = value as { seq?: unknown; event?: unknown };\n  if (typeof candidate.seq !== 'number') return false;\n  const event = candidate.event;\n  return (\n    typeof event === 'object' && event !== null && typeof (event as SessionEvent).type === 'string'\n  );\n}\n\n/**\n * Rebuild the snapshot from a journal.\n *\n * This is the reproducibility contract of the file: the same reducer that\n * produced `session.json` live, run over the events in the order they were\n * written, must land on the same state. A journal that cannot do that is a log,\n * not a journal.\n */\nexport function replayJournal(\n  content: string,\n  options: SessionReducerOptions = {},\n): SessionSnapshot {\n  let snapshot = createInitialSnapshot();\n  for (const entry of parseJournal(content)) {\n    snapshot = reduceSessionEvent(snapshot, entry.event, options);\n  }\n  return snapshot;\n}\n\n/**\n * Fan one event stream out to several publishers.\n *\n * The journal sits **beside** the snapshot writer, so something has to hold\n * both. It is the composite rather than the journal that does it, because the\n * relationship is symmetric: neither surface owns the other, and dropping\n * either one has to leave the remaining one untouched.\n *\n * `snapshot()` and `version()` answer from the first member, which is the\n * primary surface. A member that fails has already swallowed its own error —\n * that is the contract of every publisher here — so the loop needs no guard of\n * its own beyond `publish()` never throwing.\n */\nexport class MultiPublisher implements SessionPublisher {\n  private readonly members: readonly SessionPublisher[];\n  private readonly primary: SessionPublisher;\n\n  constructor(members: readonly SessionPublisher[]) {\n    if (members.length === 0) {\n      throw new Error('MultiPublisher needs at least one member');\n    }\n    this.members = members;\n    this.primary = members[0] as SessionPublisher;\n  }\n\n  publish(event: SessionEvent): void {\n    for (const member of this.members) {\n      member.publish(event);\n    }\n  }\n\n  snapshot(): SessionSnapshot {\n    return this.primary.snapshot();\n  }\n\n  version(): number {\n    return this.primary.version();\n  }\n\n  async flush(): Promise<void> {\n    await Promise.all(this.members.map((member) => member.flush()));\n  }\n\n  async close(): Promise<void> {\n    await Promise.all(this.members.map((member) => member.close()));\n  }\n}\n","import type { PipelineState, TaskPlan } from '../types.js';\nimport { loadTaskPlan, saveTaskPlan } from './state-manager.js';\n\n/**\n * Ordered pipeline phases. Each phase must complete before the next can start.\n *\n * `pr-review` is deliberately NOT here: it is opt-in via `--pr-review`. Adding\n * it to the default set would make every existing `tasks.json` (which has no\n * `prReviewCompleted`) look unfinished, so `getNextPhase()` would resume into a\n * phase the user never asked for.\n */\nexport const PIPELINE_PHASES = ['init', 'prd', 'plan', 'execute', 'review', 'pr'] as const;\n\n/**\n * The default set plus the opt-in `pr-review` phase, used when the user passes\n * `--pr-review` (or the flag was persisted in `plan.prReview.enabled`).\n */\nexport const PIPELINE_PHASES_WITH_PR_REVIEW = [...PIPELINE_PHASES, 'pr-review'] as const;\n\nexport type PipelinePhase = (typeof PIPELINE_PHASES_WITH_PR_REVIEW)[number];\n\n/**\n * Pipeline phases excluding the 'pr' phase, for --no-branch mode.\n * `pr-review` is excluded too: without a branch there is no PR to review.\n */\nexport const PIPELINE_PHASES_NO_BRANCH = PIPELINE_PHASES.filter(\n  (p): p is Exclude<PipelinePhase, 'pr' | 'pr-review'> => p !== 'pr',\n);\n\n/**\n * Map pipeline phases to their corresponding PipelineState field.\n * 'init' has no persisted state — it's a runtime-only check.\n */\nconst PHASE_TO_FIELD: Record<PipelinePhase, keyof PipelineState | null> = {\n  init: null,\n  prd: 'prdCompleted',\n  plan: 'jsonCompleted',\n  execute: 'executionCompleted',\n  review: 'reviewCompleted',\n  pr: 'prCreated',\n  'pr-review': 'prReviewCompleted',\n};\n\nexport class PipelineManager {\n  private tasksJsonPath: string;\n  private plan: TaskPlan;\n  private activePhases: readonly PipelinePhase[];\n\n  constructor(plan: TaskPlan, tasksJsonPath: string, activePhases?: readonly PipelinePhase[]) {\n    this.plan = plan;\n    this.tasksJsonPath = tasksJsonPath;\n    this.activePhases = activePhases ?? PIPELINE_PHASES;\n  }\n\n  /**\n   * Reload state from disk.\n   */\n  async reload(): Promise<void> {\n    this.plan = await loadTaskPlan(this.tasksJsonPath);\n  }\n\n  /**\n   * Check if a phase is complete.\n   */\n  isPhaseComplete(phase: PipelinePhase): boolean {\n    const field = PHASE_TO_FIELD[phase];\n    if (field === null) return true; // init is always \"complete\" after running\n    return this.plan.pipeline?.[field] ?? false;\n  }\n\n  /**\n   * Get the first incomplete phase in the pipeline.\n   * Returns null if all phases are complete.\n   */\n  getNextPhase(): PipelinePhase | null {\n    for (const phase of this.activePhases) {\n      if (!this.isPhaseComplete(phase)) {\n        return phase;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Get the current phase (alias for getNextPhase).\n   */\n  getCurrentPhase(): PipelinePhase | null {\n    return this.getNextPhase();\n  }\n\n  /**\n   * Check whether we can resume from a specific phase.\n   * All prerequisite phases must be complete.\n   */\n  canResume(fromPhase: PipelinePhase): boolean {\n    const idx = this.activePhases.indexOf(fromPhase);\n    if (idx < 0) return false;\n\n    // All active phases before fromPhase must be complete\n    for (let i = 0; i < idx; i++) {\n      if (!this.isPhaseComplete(this.activePhases[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Mark a phase as complete and persist to disk.\n   */\n  async markPhaseComplete(phase: PipelinePhase): Promise<void> {\n    const field = PHASE_TO_FIELD[phase];\n    if (field === null) return; // init has no persisted state\n\n    this.plan = {\n      ...this.plan,\n      pipeline: {\n        ...(this.plan.pipeline ?? {\n          prdCompleted: false,\n          jsonCompleted: false,\n          executionCompleted: false,\n          reviewCompleted: false,\n          prCreated: false,\n        }),\n        [field]: true,\n      },\n    };\n\n    await saveTaskPlan(this.tasksJsonPath, this.plan);\n  }\n}\n","import { mkdir, readFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport { ZodError } from 'zod';\nimport { isoNow } from '../core/state-manager.js';\nimport type { DependencyGraph } from '../issues/graph.js';\nimport type { Issue } from '../issues/types.js';\nimport { executionPlanSchema } from '../storage/schemas.js';\nimport type { LastError, PullRequestRef } from '../types.js';\nimport { writeFileAtomic } from '../utils/fs.js';\nimport { priorityOf } from './order.js';\nimport type {\n  ExecutionPlan,\n  ExecutionPlanExcluded,\n  ExecutionPlanIssue,\n  QueueIssueStatus,\n  QueueStatus,\n} from './types.js';\n\n/**\n * Building, reading, writing and advancing the execution plan of a queue.\n *\n * The plan is the only state a multi-issue run adds to the storage tree, and it\n * is written **only** for a queue with more than one Issue — a single-issue run\n * leaves the layout exactly as it was.\n */\n\nexport interface BuildExecutionPlanInput {\n  /** Project id of the global storage tree. */\n  projectId: string;\n  /** Identifiers the user asked for, in order; the first one names the queue. */\n  requested: readonly string[];\n  graph: DependencyGraph;\n  /** Ids to run, already ordered by `computeExecutionOrder`. */\n  order: readonly string[];\n  noBranch?: boolean;\n  prReview?: boolean;\n  /** Injectable clock, so tests can assert `createdAt` vs `updatedAt`. */\n  now?: () => string;\n}\n\n/** Title/url/number of a node, falling back to what the id alone tells us. */\nfunction describeIssue(\n  issue: Issue | null,\n  id: string,\n): {\n  number: number | null;\n  title: string;\n  url: string | null;\n  source: string;\n} {\n  const parsed = Number.parseInt(id, 10);\n  return {\n    number: issue?.number ?? (Number.isNaN(parsed) ? null : parsed),\n    title: issue?.title ?? '',\n    url: issue?.remoteRef ?? null,\n    source: issue?.source ?? 'github',\n  };\n}\n\n/**\n * Turn a graph plus an order into the persisted plan.\n *\n * Every Issue of the graph that is *not* in the order becomes an `excluded`\n * entry: the consolidated Pull Request reports them as known pending work, so a\n * hierarchy the user chose to trim never disappears silently.\n */\nexport function buildExecutionPlan(input: BuildExecutionPlanInput): ExecutionPlan {\n  const now = input.now ?? isoNow;\n  const at = now();\n  const scheduled = new Set(input.order);\n  const requested = new Set(input.requested);\n\n  const issues: ExecutionPlanIssue[] = input.order.map((id, index) => {\n    const node = input.graph.nodes.get(id);\n    const relations = node?.relations;\n    const described = describeIssue(node?.issue ?? null, id);\n\n    return {\n      id,\n      number: described.number,\n      title: described.title,\n      url: described.url,\n      source: described.source,\n      position: index + 1,\n      status: 'pending',\n      origin: requested.has(id) ? 'requested' : 'discovered',\n      // Only the constraints that survive inside the queue: a blocker left out\n      // of it is reported in `excluded`, not enforced as a dependency.\n      dependsOn: (relations?.blockedBy ?? []).filter((blocker) => scheduled.has(blocker)),\n      parent: relations?.parent ?? null,\n      priority: priorityOf(node?.issue?.labels ?? []),\n      heuristic: (relations?.heuristic.length ?? 0) > 0,\n      failedPhase: null,\n      lastError: null,\n      attempts: 0,\n      blockedReason: null,\n      startedAt: null,\n      completedAt: null,\n    };\n  });\n\n  const excluded: ExecutionPlanExcluded[] = [];\n  for (const node of input.graph.nodes.values()) {\n    if (scheduled.has(node.id)) continue;\n    const described = describeIssue(node.issue, node.id);\n    excluded.push({\n      id: node.id,\n      number: described.number,\n      title: described.title,\n      url: described.url,\n      reason: 'Discovered in the hierarchy but not selected for this run',\n    });\n  }\n\n  return {\n    schemaVersion: 1,\n    id: input.requested[0] ?? (input.order[0] as string),\n    project: input.projectId,\n    requested: [...input.requested],\n    branchName: null,\n    noBranch: input.noBranch ?? false,\n    prReview: input.prReview ?? false,\n    status: 'pending',\n    createdAt: at,\n    updatedAt: at,\n    truncated: input.graph.truncated,\n    issues,\n    excluded,\n  };\n}\n\n/** Read a persisted plan. Throws with the offending fields on invalid content. */\nexport async function loadExecutionPlan(path: string): Promise<ExecutionPlan> {\n  const raw: unknown = JSON.parse(await readFile(path, 'utf-8'));\n\n  try {\n    return executionPlanSchema.parse(raw) as ExecutionPlan;\n  } catch (err) {\n    if (err instanceof ZodError) {\n      const issues = err.issues.map((i) => `  - ${i.path.join('.')}: ${i.message}`).join('\\n');\n      throw new Error(`Invalid execution-plan.json at ${path}:\\n${issues}`);\n    }\n    throw err;\n  }\n}\n\n/**\n * Persist a plan atomically, creating the queue directory on first write.\n *\n * `updatedAt` is stamped here so no call site can forget it — the file is the\n * only record of how far a queue got, and a stale timestamp on it is worse than\n * none.\n */\nexport async function saveExecutionPlan(\n  path: string,\n  plan: ExecutionPlan,\n  now: () => string = isoNow,\n): Promise<void> {\n  await mkdir(dirname(path), { recursive: true });\n  const stamped: ExecutionPlan = { ...plan, updatedAt: now() };\n  await writeFileAtomic(path, `${JSON.stringify(stamped, null, 2)}\\n`);\n}\n\n/**\n * The Issue the queue should work on next, or `null` when every one of them is\n * completed.\n *\n * The order of the lookups *is* the resume policy: an interrupted issue\n * (`in_progress`) and a failed one are retried before the queue moves on, and\n * each of them picks up from its own `tasks.json` (phase-level resume) rather\n * than from the start. A `completed` issue is never revisited — that is the\n * whole point of persisting the queue.\n */\nexport interface NextQueueIssueOptions {\n  /**\n   * Ids this invocation is done with, however they ended. A queue that skips a\n   * failing Issue and comes back to it needs a way to say \"not this one again\",\n   * or \"come back later\" becomes \"come back forever\".\n   */\n  exclude?: ReadonlySet<string>;\n}\n\n/**\n * Whether every dependency this Issue declares *inside the queue* is finished.\n *\n * The execution order already places dependencies first, so this only bites\n * once an entry stops being `completed` — skipped, blocked or failed. Handing\n * out an Issue whose blocker was skipped is how a queue produces work that\n * cannot compile.\n */\nfunction dependenciesSatisfied(plan: ExecutionPlan, entry: ExecutionPlanIssue): boolean {\n  return entry.dependsOn.every((id) => {\n    const dependency = plan.issues.find((candidate) => candidate.id === id);\n    return dependency === undefined || dependency.status === 'completed';\n  });\n}\n\n/**\n * The Issue to work on next.\n *\n * The order of the four lookups is the resumption policy:\n * an interrupted Issue first (it was mid-flight), then one that failed on a\n * previous invocation, then the untouched ones, and only at the end the ones\n * this queue deliberately set aside — which is what \"go on with the\n * independent work and come back to it\" means in one line.\n *\n * `blocked` is absent on purpose: it needs a human, and no ordering of the\n * queue changes that.\n */\nexport function nextQueueIssue(\n  plan: ExecutionPlan,\n  options: NextQueueIssueOptions = {},\n): ExecutionPlanIssue | null {\n  const exclude = options.exclude ?? new Set<string>();\n  const eligible = (status: QueueIssueStatus) => (entry: ExecutionPlanIssue) =>\n    entry.status === status && !exclude.has(entry.id) && dependenciesSatisfied(plan, entry);\n\n  return (\n    plan.issues.find(eligible('in_progress')) ??\n    plan.issues.find(eligible('failed')) ??\n    plan.issues.find(eligible('pending')) ??\n    plan.issues.find(eligible('skipped')) ??\n    null\n  );\n}\n\n/**\n * Status of the queue derived from its entries.\n *\n * `skipped` is *not* terminal — the queue means to come back to it — so a queue\n * holding one is still `in_progress`. `blocked` is: nothing the queue can do\n * moves it, so a queue that ends with one ends `failed`, which is what a person\n * needs to see.\n */\nexport function queueStatus(plan: ExecutionPlan): QueueStatus {\n  if (plan.issues.some((entry) => entry.status === 'failed' || entry.status === 'blocked')) {\n    return 'failed';\n  }\n  if (plan.issues.every((entry) => entry.status === 'completed')) return 'completed';\n  if (plan.issues.some((entry) => entry.status !== 'pending')) return 'in_progress';\n  return 'pending';\n}\n\n/** Whether every Issue of the queue has been resolved. */\nexport function isQueueComplete(plan: ExecutionPlan): boolean {\n  return plan.issues.every((entry) => entry.status === 'completed');\n}\n\n/** Apply `patch` to one entry and recompute the queue status. Pure. */\nfunction updateIssue(\n  plan: ExecutionPlan,\n  id: string,\n  patch: Partial<ExecutionPlanIssue>,\n): ExecutionPlan {\n  const issues = plan.issues.map((entry) => (entry.id === id ? { ...entry, ...patch } : entry));\n  const next: ExecutionPlan = { ...plan, issues };\n  return { ...next, status: queueStatus(next) };\n}\n\nexport function markQueueIssueInProgress(\n  plan: ExecutionPlan,\n  id: string,\n  now: () => string = isoNow,\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'in_progress',\n    // Preserved across a resume: the queue reports when the work on this Issue\n    // really began, not when it was last picked up.\n    startedAt: current?.startedAt ?? now(),\n    failedPhase: null,\n    lastError: null,\n  });\n}\n\nexport function markQueueIssueCompleted(\n  plan: ExecutionPlan,\n  id: string,\n  now: () => string = isoNow,\n): ExecutionPlan {\n  return updateIssue(plan, id, {\n    status: 'completed',\n    completedAt: now(),\n    failedPhase: null,\n    lastError: null,\n  });\n}\n\nexport function markQueueIssueFailed(\n  plan: ExecutionPlan,\n  id: string,\n  failure: { phase: string | null; error: LastError | null },\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'failed',\n    failedPhase: failure.phase,\n    lastError: failure.error,\n    attempts: (current?.attempts ?? 0) + 1,\n  });\n}\n\n/**\n * Set an Issue aside and come back to it later.\n *\n * The difference from `failed` is the whole point of `--on-issue-failure skip`:\n * a failure that stopped this attempt is not a verdict on the eleven other\n * Issues in the queue, and `skipped` is the status that says \"not now\" rather\n * than \"not at all\". `attempts` is incremented here because the counter is what\n * keeps \"come back later\" from becoming \"come back forever\".\n */\nexport function markQueueIssueSkipped(\n  plan: ExecutionPlan,\n  id: string,\n  failure: { phase: string | null; error: LastError | null },\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'skipped',\n    failedPhase: failure.phase,\n    lastError: failure.error,\n    attempts: (current?.attempts ?? 0) + 1,\n  });\n}\n\n/**\n * Stop working on an Issue until a person looks at it.\n *\n * `blocked` is never handed back out by `nextQueueIssue`: waiting cannot fix\n * a missing credential or a repository mid-rebase, and a queue that could\n * unblock itself would spin on the same cause forever.\n */\nexport function markQueueIssueBlocked(\n  plan: ExecutionPlan,\n  id: string,\n  reason: string,\n  failure: { phase: string | null; error: LastError | null },\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'blocked',\n    blockedReason: reason,\n    failedPhase: failure.phase,\n    lastError: failure.error,\n    attempts: (current?.attempts ?? 0) + 1,\n  });\n}\n\n/** Record the branch every Issue of the queue shares. */\nexport function setQueueBranch(plan: ExecutionPlan, branchName: string): ExecutionPlan {\n  return { ...plan, branchName };\n}\n\n/** Record the single Pull Request that consolidated the queue. */\nexport function setQueuePullRequest(\n  plan: ExecutionPlan,\n  pullRequest: PullRequestRef,\n): ExecutionPlan {\n  return { ...plan, pullRequest };\n}\n","import { emptyRelations, uniqueIds } from './relations.js';\nimport type { Issue, IssueRelations } from './types.js';\n\n/**\n * Dependency graph of a set of Issues, built by walking the relations every\n * provider exposes through `fetchRelations`.\n *\n * The traversal is deliberately *structural*: it follows hierarchy\n * (parent/children) and dependencies (blockedBy/blocking) and stops there. Plain\n * mentions are recorded on each node but never expanded — a body citing \"see\n * also #12\" would otherwise drag an unrelated Issue into an execution plan the\n * user is about to confirm.\n */\n\nexport interface DependencyGraphNode {\n  id: string;\n  relations: IssueRelations;\n  /** Distance from the closest root, in traversal hops. */\n  depth: number;\n  /** The Issue itself, when the caller supplied a way to read it. */\n  issue: Issue | null;\n  /** True when the node was requested by the user rather than discovered. */\n  root: boolean;\n}\n\nexport interface DependencyGraph {\n  /** Ids the traversal started from, in the order they were requested. */\n  roots: string[];\n  /** Every discovered node, keyed by id, in discovery order. */\n  nodes: Map<string, DependencyGraphNode>;\n  /**\n   * Dependency cycles found among the discovered nodes, each listed once,\n   * starting at its smallest member. Reported rather than thrown: discovery\n   * must still answer, and it is the ordering layer that refuses to run.\n   */\n  cycles: string[][];\n  /** True when a limit stopped the traversal before it was exhausted. */\n  truncated: boolean;\n  limits: { maxNodes: number; maxDepth: number };\n}\n\n/**\n * Conservative defaults: a real hierarchy is a handful of Issues, and each node\n * costs several API calls. A malformed (or simply huge) graph must not turn a\n * `run` into a rate-limit incident.\n */\nexport const DEFAULT_MAX_NODES = 25;\nexport const DEFAULT_MAX_DEPTH = 3;\n\nexport interface BuildDependencyGraphOptions {\n  maxNodes?: number;\n  maxDepth?: number;\n  /** Issues the caller already resolved, so the traversal does not re-read them. */\n  known?: Iterable<Issue>;\n  /** Reader for the Issues the traversal discovers. Optional. */\n  fetchIssue?: (id: string) => Promise<Issue | null>;\n  /** Warning sink for a source that failed. Silent by default. */\n  warn?: (message: string) => void;\n}\n\n/** Edge `from` → `to`, meaning \"`from` must be resolved before `to`\". */\nexport interface DependencyEdge {\n  from: string;\n  to: string;\n}\n\n/**\n * Ordering constraints of a graph: only hierarchy-free, explicit dependencies.\n *\n * `blockedBy`/`blocking` are the two spellings of the same fact, so both are\n * normalized into a single direction here. Parent/child is **not** a constraint\n * — it is a presentation and tie-breaking concern (see `computeExecutionOrder`),\n * because a parent is usually an umbrella that neither blocks nor is blocked by\n * its children.\n *\n * Edges pointing outside the graph are dropped: an Issue the traversal never\n * reached cannot be scheduled, so a constraint against it is unenforceable.\n */\nexport function dependencyEdges(graph: DependencyGraph): DependencyEdge[] {\n  const edges: DependencyEdge[] = [];\n  const seen = new Set<string>();\n\n  const add = (from: string, to: string): void => {\n    if (from === to || !graph.nodes.has(from) || !graph.nodes.has(to)) return;\n    const key = `${from}->${to}`;\n    if (seen.has(key)) return;\n    seen.add(key);\n    edges.push({ from, to });\n  };\n\n  for (const node of graph.nodes.values()) {\n    for (const blocker of node.relations.blockedBy) {\n      add(blocker, node.id);\n    }\n    for (const blocked of node.relations.blocking) {\n      add(node.id, blocked);\n    }\n  }\n\n  return edges;\n}\n\n/** Every cycle of the dependency edges, each reported once. */\nexport function findCycles(graph: DependencyGraph): string[][] {\n  const adjacency = new Map<string, string[]>();\n  for (const { from, to } of dependencyEdges(graph)) {\n    const list = adjacency.get(from);\n    if (list === undefined) {\n      adjacency.set(from, [to]);\n    } else {\n      list.push(to);\n    }\n  }\n\n  const cycles: string[][] = [];\n  const reported = new Set<string>();\n  const state = new Map<string, 'visiting' | 'done'>();\n  const stack: string[] = [];\n\n  const record = (cycle: string[]): void => {\n    // Rotate to the smallest member so the same cycle found from two entry\n    // points is reported once.\n    let pivot = 0;\n    for (let i = 1; i < cycle.length; i++) {\n      if (compareIds(cycle[i] as string, cycle[pivot] as string) < 0) pivot = i;\n    }\n    const normalized = [...cycle.slice(pivot), ...cycle.slice(0, pivot)];\n    const key = normalized.join('->');\n    if (reported.has(key)) return;\n    reported.add(key);\n    cycles.push(normalized);\n  };\n\n  const visit = (id: string): void => {\n    state.set(id, 'visiting');\n    stack.push(id);\n\n    for (const next of adjacency.get(id) ?? []) {\n      const status = state.get(next);\n      if (status === 'visiting') {\n        record(stack.slice(stack.indexOf(next)));\n        continue;\n      }\n      if (status === undefined) {\n        visit(next);\n      }\n    }\n\n    stack.pop();\n    state.set(id, 'done');\n  };\n\n  for (const id of graph.nodes.keys()) {\n    if (!state.has(id)) visit(id);\n  }\n\n  return cycles;\n}\n\n/** Numeric when both ids are numbers, lexicographic otherwise. */\nexport function compareIds(a: string, b: string): number {\n  const na = Number(a);\n  const nb = Number(b);\n  if (Number.isInteger(na) && Number.isInteger(nb)) {\n    return na - nb;\n  }\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\n/** Ids a node links to structurally, in traversal order. */\nfunction neighbours(relations: IssueRelations): string[] {\n  return uniqueIds(\n    [\n      ...(relations.parent === null ? [] : [relations.parent]),\n      ...relations.children,\n      ...relations.blockedBy,\n      ...relations.blocking,\n    ],\n    relations.id,\n  );\n}\n\n/**\n * Walk the relations of `roots` breadth-first and return the whole structure.\n *\n * Failures never abort the walk: a node whose relations cannot be read enters\n * the graph with empty relations (and a warning), exactly like an Issue that\n * genuinely relates to nothing. That keeps a partially unavailable API from\n * costing the user the Issues that *were* discovered.\n *\n * Breadth-first is what makes `depth` meaningful under a limit: when the walk is\n * truncated, what is missing is the far edge of the graph, not a random subset.\n */\nexport async function buildDependencyGraph(\n  roots: readonly string[],\n  fetchRelations: (id: string) => Promise<IssueRelations | null>,\n  options: BuildDependencyGraphOptions = {},\n): Promise<DependencyGraph> {\n  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;\n  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;\n  const warn = options.warn ?? ((): void => {});\n\n  const known = new Map<string, Issue>();\n  for (const issue of options.known ?? []) {\n    known.set(issue.id, issue);\n  }\n\n  const rootIds = uniqueIds(roots);\n  const nodes = new Map<string, DependencyGraphNode>();\n  const queued = new Set<string>(rootIds);\n  let truncated = false;\n\n  let frontier: { id: string; depth: number }[] = rootIds.map((id) => ({ id, depth: 0 }));\n\n  while (frontier.length > 0) {\n    const next: { id: string; depth: number }[] = [];\n\n    for (const { id, depth } of frontier) {\n      if (nodes.size >= maxNodes) {\n        truncated = true;\n        break;\n      }\n\n      let relations: IssueRelations | null = null;\n      try {\n        relations = await fetchRelations(id);\n      } catch (err) {\n        warn(\n          `Could not read the relations of issue '${id}': ${err instanceof Error ? err.message : String(err)}`,\n        );\n      }\n\n      let issue = known.get(id) ?? null;\n      if (issue === null && options.fetchIssue !== undefined) {\n        try {\n          issue = await options.fetchIssue(id);\n        } catch (err) {\n          warn(`Could not read issue '${id}': ${err instanceof Error ? err.message : String(err)}`);\n        }\n      }\n\n      const resolved = relations ?? emptyRelations(id);\n      nodes.set(id, { id, relations: resolved, depth, issue, root: rootIds.includes(id) });\n\n      if (depth >= maxDepth) {\n        // Only a node that actually has unexplored neighbours truncates the\n        // graph; a leaf at max depth explored everything there was.\n        if (neighbours(resolved).some((neighbour) => !queued.has(neighbour))) {\n          truncated = true;\n        }\n        continue;\n      }\n\n      for (const neighbour of neighbours(resolved)) {\n        if (queued.has(neighbour)) continue;\n        queued.add(neighbour);\n        next.push({ id: neighbour, depth: depth + 1 });\n      }\n    }\n\n    if (nodes.size >= maxNodes && next.length > 0) {\n      truncated = true;\n      break;\n    }\n    frontier = next;\n  }\n\n  const graph: DependencyGraph = {\n    roots: rootIds,\n    nodes,\n    cycles: [],\n    truncated,\n    limits: { maxNodes, maxDepth },\n  };\n\n  linkReferencedBy(graph);\n  graph.cycles = findCycles(graph);\n\n  return graph;\n}\n\n/**\n * Complete `referencedBy` with the inverse of `references` among the discovered\n * nodes.\n *\n * The origin only reports the citations it can see (GitHub's timeline covers\n * cross-references but not, for instance, a mention added by the textual\n * heuristic); inverting what the graph already holds costs no API call and\n * keeps the two directions consistent inside it.\n */\nfunction linkReferencedBy(graph: DependencyGraph): void {\n  for (const node of graph.nodes.values()) {\n    for (const cited of node.relations.references) {\n      const target = graph.nodes.get(cited);\n      if (target === undefined || target.id === node.id) continue;\n      target.relations.referencedBy = uniqueIds(\n        [...target.relations.referencedBy, node.id],\n        target.id,\n      );\n    }\n  }\n}\n","import { compareIds, type DependencyGraph, dependencyEdges, findCycles } from '../issues/graph.js';\nimport type { IssuePriority } from './types.js';\n\n/**\n * Turning a dependency graph into the order the queue runs in.\n *\n * The criteria are applied in the exact precedence the initiative specifies:\n *\n * 1. **dependencies and blocks** — hard constraints; an Issue never starts\n *    before something it depends on has finished. This is the topological part\n *    and the only one that can make the computation fail (a cycle);\n * 2. **hierarchy** — with two Issues both ready to run, the ancestor goes\n *    first, so an umbrella Issue frames the work of its sub-issues;\n * 3. **priority** — the GitHub labels `high`, `medium` and `low`;\n * 4. **logical order** — the identifier, numerically when it is a number.\n *\n * Everything below the first item is a *tie-break among Issues that are already\n * free to run*, never a constraint: a `high` Issue that depends on a `low` one\n * still runs second, which is the whole point of the feature.\n */\n\nconst PRIORITY_LABELS: Record<string, IssuePriority> = {\n  high: 'high',\n  medium: 'medium',\n  low: 'low',\n};\n\n/** Ranking of a priority; an Issue with no label sorts after every labelled one. */\nconst PRIORITY_RANK: Record<IssuePriority, number> = { high: 0, medium: 1, low: 2 };\nconst NO_PRIORITY_RANK = 3;\n\n/**\n * Priority carried by a label set, or `null` when there is none.\n *\n * Both the bare labels used by this repository (`high`) and the qualified\n * spellings other projects use (`priority: high`, `priority/high`, `P-high`)\n * are accepted; anything else is simply not a priority. The absence of a label\n * is never an error — most Issues have none.\n */\nexport function priorityOf(labels: readonly string[]): IssuePriority | null {\n  for (const label of labels) {\n    const normalized = label.trim().toLowerCase();\n    const direct = PRIORITY_LABELS[normalized];\n    if (direct !== undefined) return direct;\n\n    const qualified = /^(?:priority|prio|p)\\s*[:/-]\\s*(high|medium|low)$/.exec(normalized);\n    const matched = qualified?.[1];\n    if (matched !== undefined) return PRIORITY_LABELS[matched] as IssuePriority;\n  }\n  return null;\n}\n\nexport interface ExecutionOrderOptions {\n  /**\n   * Subset of the graph to schedule. Defaults to every node — the \"run the\n   * whole hierarchy\" answer; the \"only the ones I asked for\" answer passes the\n   * requested ids.\n   */\n  include?: readonly string[];\n}\n\nexport type ExecutionOrderResult =\n  | { ok: true; order: string[] }\n  | { ok: false; cycles: string[][] };\n\n/** Number of ancestors of `id` inside the selection: 0 for a top-level Issue. */\nfunction hierarchyDepth(\n  id: string,\n  parentOf: Map<string, string | null>,\n  selected: Set<string>,\n): number {\n  let depth = 0;\n  let current = parentOf.get(id) ?? null;\n  const seen = new Set<string>([id]);\n\n  while (current !== null && selected.has(current) && !seen.has(current)) {\n    depth++;\n    seen.add(current);\n    current = parentOf.get(current) ?? null;\n  }\n\n  return depth;\n}\n\n/**\n * Order the selected Issues of a graph.\n *\n * Kahn's algorithm with a deterministic tie-break, so the same graph always\n * produces the same order — a plan the user confirmed must not reshuffle itself\n * on the next run.\n *\n * A cycle is reported, never worked around: an arbitrary order would silently\n * implement an Issue before its dependency, which is exactly the failure this\n * whole feature exists to prevent. Constraints pointing outside the selection\n * are dropped — an Issue that is not going to run cannot block anything.\n */\nexport function computeExecutionOrder(\n  graph: DependencyGraph,\n  options: ExecutionOrderOptions = {},\n): ExecutionOrderResult {\n  const selected = new Set(\n    (options.include ?? [...graph.nodes.keys()]).filter((id) => graph.nodes.has(id)),\n  );\n\n  const parentOf = new Map<string, string | null>();\n  const priority = new Map<string, IssuePriority | null>();\n  for (const id of selected) {\n    const node = graph.nodes.get(id);\n    parentOf.set(id, node?.relations.parent ?? null);\n    priority.set(id, priorityOf(node?.issue?.labels ?? []));\n  }\n\n  const incoming = new Map<string, Set<string>>();\n  const outgoing = new Map<string, string[]>();\n  for (const id of selected) {\n    incoming.set(id, new Set());\n    outgoing.set(id, []);\n  }\n  for (const { from, to } of dependencyEdges(graph)) {\n    if (!selected.has(from) || !selected.has(to) || from === to) continue;\n    incoming.get(to)?.add(from);\n    outgoing.get(from)?.push(to);\n  }\n\n  const depth = new Map<string, number>();\n  for (const id of selected) {\n    depth.set(id, hierarchyDepth(id, parentOf, selected));\n  }\n\n  const rank = (id: string): number => {\n    const value = priority.get(id) ?? null;\n    return value === null ? NO_PRIORITY_RANK : PRIORITY_RANK[value];\n  };\n\n  const better = (a: string, b: string): number => {\n    const byHierarchy = (depth.get(a) ?? 0) - (depth.get(b) ?? 0);\n    if (byHierarchy !== 0) return byHierarchy;\n    const byPriority = rank(a) - rank(b);\n    if (byPriority !== 0) return byPriority;\n    return compareIds(a, b);\n  };\n\n  const ready = [...selected].filter((id) => (incoming.get(id)?.size ?? 0) === 0);\n  const order: string[] = [];\n\n  while (ready.length > 0) {\n    ready.sort(better);\n    const next = ready.shift() as string;\n    order.push(next);\n\n    for (const dependent of outgoing.get(next) ?? []) {\n      const pending = incoming.get(dependent);\n      if (pending === undefined) continue;\n      pending.delete(next);\n      if (pending.size === 0) {\n        ready.push(dependent);\n      }\n    }\n  }\n\n  if (order.length !== selected.size) {\n    // Prefer the cycles the graph already recorded; recompute only if the\n    // selection is what closed the loop.\n    const cycles = graph.cycles.length > 0 ? graph.cycles : findCycles(graph);\n    const relevant = cycles.filter((cycle) => cycle.every((id) => selected.has(id)));\n    return { ok: false, cycles: relevant.length > 0 ? relevant : cycles };\n  }\n\n  return { ok: true, order };\n}\n\n/** One-line description of the cycles, for an error message. */\nexport function describeCycles(cycles: readonly string[][]): string {\n  return cycles.map((cycle) => [...cycle, cycle[0]].map((id) => `#${id}`).join(' → ')).join('; ');\n}\n"],"mappings":"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","names":["mkdir","dirname","mkdir","dirname"]}

package/dist/{chunk-AAY6KM7N.js → chunk-73ATPIYX.js}

@@ -1,19 +1,36 @@
 #!/usr/bin/env node
 import {
+  emptyRelations,
+  mergeRelations,
+  parseTextualRelations,
+  uniqueIds
+} from "./chunk-KMMASOA6.js";
+import {
+  getActiveResilienceConfig,
+  loadIssuesConfig
+} from "./chunk-42PJFMAR.js";
+import {
+  ClassifiedError,
+  actionOf,
+  classify,
+  failureOf,
   getProjectRoot,
-  loadIssuesConfig,
+  requiresHumanAction,
   resolveIssuePaths,
+  resolvePolicy,
   resolveProjectPaths,
   run
-} from "./chunk-VQ5VN7DF.js";
+} from "./chunk-DIDUVL6O.js";
 import {
-  isoNow,
-  issueMetadataSchema,
   printError,
   printInfo,
-  printWarning,
+  printWarning
+} from "./chunk-BYZDPR7N.js";
+import {
+  isoNow,
+  issueMetadataSchema,
   writeFileAtomic
-} from "./chunk-HC2MT7BX.js";
+} from "./chunk-CD5ULRVC.js";
 
 // src/issues/registry.ts
 var providers = /* @__PURE__ */ new Map();
@@ -47,134 +64,32 @@ function hashIssueContent(title, body) {
   return `sha256:${digest}`;
 }
 
-// src/issues/relations.ts
-function emptyRelations(id) {
-  return {
-    id,
-    parent: null,
-    children: [],
-    blockedBy: [],
-    blocking: [],
-    references: [],
-    referencedBy: [],
-    heuristic: []
-  };
-}
-function uniqueIds(ids, self) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const raw of ids) {
-    const id = raw.trim();
-    if (id === "" || id === self || seen.has(id)) continue;
-    seen.add(id);
-    out.push(id);
-  }
-  return out;
-}
-function stripCode(body) {
-  return body.replace(/```[\s\S]*?```/g, " ").replace(/`[^`\n]*`/g, " ");
-}
-var BLOCKED_BY = /\b(?:depends[- ]on|depends upon|blocked[- ]by|requires|depende[ -]de|dependente[ -]de|bloquead[ao] por|requer)\b\s*:?\s*/gi;
-var BLOCKING = /\b(?:blocks|blocking|bloqueia|bloqueando)\b\s*:?\s*/gi;
-var TASK_ITEM = /^[ \t]*[-*]\s*\[[ xX]\]\s*(.*)$/gm;
-var ANY_ID = /(?:^|[^\w#])#(\d+)\b/g;
-function idsFrom(text) {
-  const ids = [];
-  const id = /#(\d+)/y;
-  let cursor = 0;
-  while (cursor < text.length) {
-    id.lastIndex = cursor;
-    const match = id.exec(text);
-    if (match === null) break;
-    ids.push(match[1]);
-    cursor = id.lastIndex;
-    const gloss = /^\s*\([^)]*\)/.exec(text.slice(cursor));
-    if (gloss !== null) {
-      cursor += gloss[0].length;
-    }
-    const separator = /^\s*(?:,|and\b|e\b|&)\s*/i.exec(text.slice(cursor));
-    if (separator === null) break;
-    cursor += separator[0].length;
-  }
-  return ids;
-}
-function collect(body, keyword) {
-  const ids = [];
-  keyword.lastIndex = 0;
-  let match = keyword.exec(body);
-  while (match !== null) {
-    ids.push(...idsFrom(body.slice(keyword.lastIndex)));
-    match = keyword.exec(body);
-  }
-  return ids;
-}
-function parseTextualRelations(body, self) {
-  const text = stripCode(body ?? "");
-  const blockedBy = collect(text, BLOCKED_BY);
-  const blocking = collect(text, BLOCKING);
-  const children = [];
-  TASK_ITEM.lastIndex = 0;
-  let item = TASK_ITEM.exec(text);
-  while (item !== null) {
-    const content = item[1] ?? "";
-    const first = /^\s*\[?#(\d+)\b/.exec(content);
-    if (first?.[1] !== void 0) {
-      children.push(first[1]);
-    }
-    item = TASK_ITEM.exec(text);
-  }
-  const classified = /* @__PURE__ */ new Set([...blockedBy, ...blocking, ...children]);
-  const references = [];
-  ANY_ID.lastIndex = 0;
-  let cited = ANY_ID.exec(text);
-  while (cited !== null) {
-    const id = cited[1];
-    if (!classified.has(id)) {
-      references.push(id);
-    }
-    ANY_ID.lastIndex = Math.max(ANY_ID.lastIndex - 1, cited.index + 1);
-    cited = ANY_ID.exec(text);
-  }
-  return {
-    children: uniqueIds(children, self),
-    blockedBy: uniqueIds(blockedBy, self),
-    blocking: uniqueIds(blocking, self),
-    references: uniqueIds(references, self)
-  };
-}
-function mergeRelations(structured, textual) {
-  const self = structured.id;
-  const children = uniqueIds([...structured.children, ...textual.children], self);
-  const blockedBy = uniqueIds([...structured.blockedBy, ...textual.blockedBy], self);
-  const blocking = uniqueIds([...structured.blocking, ...textual.blocking], self);
-  const references = uniqueIds([...structured.references, ...textual.references], self);
-  const fromApi = /* @__PURE__ */ new Set([
-    ...structured.children,
-    ...structured.blockedBy,
-    ...structured.blocking,
-    ...structured.parent === null ? [] : [structured.parent]
-  ]);
-  const heuristic = uniqueIds(
-    [...textual.children, ...textual.blockedBy, ...textual.blocking].filter(
-      (id) => !fromApi.has(id)
-    ),
-    self
-  );
-  return {
-    id: self,
-    parent: structured.parent,
-    children,
-    blockedBy,
-    blocking,
-    references,
-    referencedBy: uniqueIds(structured.referencedBy, self),
-    heuristic
-  };
-}
-
 // src/issues/providers/github.ts
 var VIEW_FIELDS = "number,title,body,labels,state,url,createdAt,updatedAt";
 var PROBE_TIMEOUT_MS = 1e4;
+function ghPolicy() {
+  return (failure) => resolvePolicy(failure.kind, getActiveResilienceConfig());
+}
+var PROBE_MAX_ATTEMPTS = 3;
+var PROBE_MAX_DELAY_MS = 5e3;
+function ghProbePolicy() {
+  const policyFor = ghPolicy();
+  return (failure) => {
+    const policy = policyFor(failure);
+    return {
+      ...policy,
+      maxAttempts: Math.min(policy.maxAttempts, PROBE_MAX_ATTEMPTS),
+      maxDelayMs: Math.min(policy.maxDelayMs, PROBE_MAX_DELAY_MS),
+      retryForever: false
+    };
+  };
+}
+function gh(args, options = {}) {
+  return run("gh", args, {
+    retry: ghPolicy(),
+    ...options.timeout === void 0 ? {} : { timeout: options.timeout }
+  });
+}
 var NOT_FOUND_PATTERN = /could not resolve to an issue|no issues? found|issue not found|could not find any issue/i;
 function normalizeState(state) {
   return String(state ?? "").toUpperCase() === "CLOSED" ? "closed" : "open";
@@ -212,7 +127,7 @@ function isRecord(value) {
 }
 async function ghApiJson(path) {
   try {
-    const result = await run("gh", ["api", path]);
+    const result = await gh(["api", path]);
     if (result.exitCode !== 0) return null;
     return JSON.parse(result.stdout);
   } catch {
@@ -246,27 +161,66 @@ function crossReferences(timeline, self) {
 function extractIssueNumber(output) {
   return output.match(/\/issues\/(\d+)/)?.[1] ?? null;
 }
+function ghError(message, result) {
+  const failure = result.failure;
+  if (failure === void 0) return new Error(message);
+  return new ClassifiedError(message, failure, ghAction(failure));
+}
+function ghAction(failure) {
+  if (!requiresHumanAction(failure.kind)) return void 0;
+  if (failure.kind === "authentication") {
+    return "Run `gh auth login` to authenticate the GitHub CLI";
+  }
+  return void 0;
+}
+function unavailable(result, action) {
+  const failure = result.failure;
+  const needsHuman = failure === void 0 || requiresHumanAction(failure.kind);
+  return {
+    available: false,
+    ...failure === void 0 ? {} : { failure },
+    ...needsHuman ? { action } : {}
+  };
+}
 var GitHubIssueProvider = class {
   name = "github";
   /** True when gh is installed and authenticated. Never throws. */
   async isAvailable() {
+    return (await this.checkAvailability()).available;
+  }
+  /**
+   * Whether gh is installed and authenticated, with the reason when it is not.
+   *
+   * Both probes retry on the capped probe budget, so a DNS blip during a long
+   * run no longer reports GitHub as unavailable and takes the whole run down
+   * with it — while an authentication failure is clamped to zero attempts by
+   * `resolvePolicy()` and comes back immediately, with the action to take.
+   */
+  async checkAvailability() {
     try {
-      const version = await run("gh", ["--version"], { timeout: PROBE_TIMEOUT_MS });
-      if (version.exitCode !== 0) return false;
-      const auth = await run("gh", ["auth", "status"], { timeout: PROBE_TIMEOUT_MS });
-      return auth.exitCode === 0;
+      const retry = ghProbePolicy();
+      const version = await run("gh", ["--version"], { retry, timeout: PROBE_TIMEOUT_MS });
+      if (version.exitCode !== 0) {
+        return unavailable(version, "Install the GitHub CLI: https://cli.github.com");
+      }
+      const auth = await run("gh", ["auth", "status"], { retry, timeout: PROBE_TIMEOUT_MS });
+      if (auth.exitCode !== 0) {
+        return unavailable(auth, "Run `gh auth login` to authenticate the GitHub CLI");
+      }
+      return { available: true };
     } catch {
-      return false;
+      return { available: false };
     }
   }
   async get(id) {
     const issueId = normalizeId(id);
-    const result = await run("gh", ["issue", "view", issueId, "--json", VIEW_FIELDS]);
+    const result = await gh(["issue", "view", issueId, "--json", VIEW_FIELDS]);
     if (result.exitCode !== 0) {
       const detail = (result.stderr || result.stdout).trim();
       if (NOT_FOUND_PATTERN.test(detail)) return null;
-      throw new Error(
-        `Failed to fetch GitHub issue #${issueId}: ${detail || "gh issue view failed"}`
+      throw ghError(
+        `Failed to fetch GitHub issue #${issueId}: ${detail || "gh issue view failed"}`,
+        result
       );
     }
     let payload;
@@ -287,10 +241,10 @@ var GitHubIssueProvider = class {
     if (draft.type !== void 0 && draft.type !== "") {
       args.push("--type", draft.type);
     }
-    const result = await run("gh", args);
+    const result = await gh(args);
     if (result.exitCode !== 0) {
       const detail = (result.stderr || result.stdout).trim();
-      throw new Error(`Failed to create GitHub issue: ${detail || "gh issue create failed"}`);
+      throw ghError(`Failed to create GitHub issue: ${detail || "gh issue create failed"}`, result);
     }
     const number = extractIssueNumber(result.stdout);
     if (!number) {
@@ -358,11 +312,12 @@ var GitHubIssueProvider = class {
   }
   async close(id) {
     const issueId = normalizeId(id);
-    const result = await run("gh", ["issue", "close", issueId]);
+    const result = await gh(["issue", "close", issueId]);
     if (result.exitCode !== 0) {
       const detail = (result.stderr || result.stdout).trim();
-      throw new Error(
-        `Failed to close GitHub issue #${issueId}: ${detail || "gh issue close failed"}`
+      throw ghError(
+        `Failed to close GitHub issue #${issueId}: ${detail || "gh issue close failed"}`,
+        result
       );
     }
   }
@@ -715,10 +670,20 @@ function ensureProvidersRegistered() {
 import { createInterface } from "readline";
 var IssueResolutionError = class extends Error {
   exitCode;
-  constructor(message, exitCode = 1) {
+  /**
+   * The verdict of the origin that failed, when one origin failed for a reason
+   * worth naming. It is what tells "this Issue does not exist" apart from
+   * "GitHub could not be reached", which are the same message today.
+   */
+  failure;
+  /** What a human has to do, for a failure that waiting cannot fix. */
+  action;
+  constructor(message, exitCode = 1, details = {}) {
     super(message);
     this.name = "IssueResolutionError";
     this.exitCode = exitCode;
+    this.failure = details.failure;
+    this.action = details.action;
   }
 };
 var MAX_PROMPT_ATTEMPTS = 3;
@@ -743,14 +708,23 @@ async function fetchCandidate(source, id, warn) {
   } catch (err) {
     return { source, issue: null, reason: errorMessage(err) };
   }
-  let available;
+  let availability;
   try {
-    available = await provider.isAvailable();
+    availability = await provider.checkAvailability?.() ?? {
+      available: await provider.isAvailable()
+    };
   } catch (err) {
     return { source, issue: null, reason: `provider unavailable (${errorMessage(err)})` };
   }
-  if (!available) {
-    return { source, issue: null, reason: "provider unavailable" };
+  if (!availability.available) {
+    const reason = availability.failure?.message ?? "provider unavailable";
+    return {
+      source,
+      issue: null,
+      reason,
+      ...availability.failure === void 0 ? {} : { failure: availability.failure },
+      ...availability.action === void 0 ? {} : { action: availability.action }
+    };
   }
   try {
     const issue = await provider.get(id);
@@ -758,7 +732,15 @@ async function fetchCandidate(source, id, warn) {
   } catch (err) {
     const reason = errorMessage(err);
     warn(`Could not read issue '${id}' from ${sourceLabel(source)}: ${reason}`);
-    return { source, issue: null, reason };
+    const failure = failureOf(err);
+    const action = actionOf(err);
+    return {
+      source,
+      issue: null,
+      reason,
+      ...failure === null ? {} : { failure },
+      ...action === null ? {} : { action }
+    };
   }
 }
 function shortHash(hash) {
@@ -875,6 +857,17 @@ async function resolveIssue(id, opts = {}) {
   if (found.length === 0) {
     const details = candidates.map((candidate) => `${sourceLabel(candidate.source)}: ${candidate.reason ?? "not found"}`).join("; ");
     const where = details.length > 0 ? ` (${details})` : "";
+    const blocking = candidates.find((candidate) => candidate.action !== void 0);
+    if (blocking !== void 0) {
+      throw new IssueResolutionError(
+        `Cannot read issue '${id}' from ${sourceLabel(blocking.source)}: ${blocking.reason}`,
+        1,
+        {
+          ...blocking.failure === void 0 ? {} : { failure: blocking.failure },
+          ...blocking.action === void 0 ? {} : { action: blocking.action }
+        }
+      );
+    }
     throw new IssueResolutionError(`Issue '${id}' not found in any registered origin${where}`);
   }
   const build = (candidate, divergent) => buildResolved(candidate.issue, candidate.source, local, github, divergent);
@@ -955,21 +948,34 @@ async function resolveCommandIssue(id, preResolved, options) {
   } catch (err) {
     if (err instanceof IssueResolutionError) {
       printError(err.message);
+      printAction(err.action);
       return { ok: false, code: err.exitCode };
     }
     const message = err instanceof Error ? err.message : String(err);
     printError(`Could not resolve issue '${id}': ${message}`);
+    printAction(actionOf(err) ?? requiredAction(message));
     return { ok: false, code: 1 };
   }
 }
+function requiredAction(message) {
+  const failure = classify({ source: "github", stderr: message });
+  if (!requiresHumanAction(failure.kind)) return null;
+  if (failure.kind === "authentication") {
+    return "Run `gh auth login` to authenticate the GitHub CLI";
+  }
+  return null;
+}
+function printAction(action) {
+  if (action !== null && action !== void 0 && action !== "") {
+    printWarning(`Action required: ${action}`);
+  }
+}
 
 export {
-  emptyRelations,
-  uniqueIds,
   getProvider,
   ensureProvidersRegistered,
   localIssueRef,
   issuePlaceholders,
   resolveCommandIssue
 };
-//# sourceMappingURL=chunk-AAY6KM7N.js.map
+//# sourceMappingURL=chunk-73ATPIYX.js.map