pantheon-opencode 1.5.0-beta.2 → 1.5.0-beta.20

package/src/pantheon/dispatch-guard.ts

@@ -1,109 +0,0 @@
-/**
- * Dispatch Guard (Wave 4, PR #46) — auto-retry-on-empty for background
- * delegations. Classifies a dispatch result and redispatch once when it
- * came back empty.
- *
- * Failure signature classification:
- *   - 'content'     — text content present, nothing to do.
- *   - 'empty-mode1' — NO content AND NO tokens: the dispatch returned
- *                     nothing at all (no reply / early abort).
- *   - 'empty-mode2' — no text part but tokens present: reasoning happened
- *                     but the text part was lost — the themis Wave-2
- *                     failure signature that triggered this guard.
- *
- * Retry cap is HARD at 1 (never 2x). The guard is stateful per instance:
- * one retry budget total. It is a PURE library — it does NOT intercept
- * task() (opencode 1.18.x cannot intercept task completion via hooks, so
- * integration is manual-orchestration; see zeus.md "Empty-Result Retry").
- *
- * @module dispatch-guard
- */
-
-import { createPantheonLogger } from './logger.ts'
-
-// Silence-by-default TUI policy (pantheon-hooks L42-58): the default warn
-// fallback logs to .pantheon/logs/hooks.log; console echo is opt-in via
-// PANTHEON_HOOKS_LOG=1. `logger` injection stays for tests.
-const log = createPantheonLogger({ module: 'pantheon-dispatch-guard' })
-
-/** A dispatch result — the minimal shape needed to classify emptiness. */
-export interface DispatchResultLike {
-  /** Text content of the result (task_result / report markdown). */
-  content?: string | null
-  /** Input tokens (present when the model actually reasoned). */
-  tokensInput?: number
-  /** Output tokens (present when the model actually reasoned). */
-  tokensOutput?: number
-  /** R1: the failure that produced this result (classified by retry-policy). */
-  error?: unknown
-}
-
-/** Classification of a dispatch result. */
-export type DispatchClassification = 'content' | 'empty-mode1' | 'empty-mode2'
-
-export interface DispatchGuardOptions {
-  /** Enable auto-retry on empty results. Default: true. */
-  retryOnEmpty?: boolean
-  /** Injectable logger (defaults to the Pantheon file log, env-gated echo). */
-  logger?: { warn: (message: string) => void }
-}
-
-export interface DispatchGuard {
-  /** Classify a result: content, empty-mode1 (nothing), empty-mode2 (reasoning, no text). */
-  classifyResult(result: DispatchResultLike): DispatchClassification
-  /**
-   * Redispatch ONCE when the result is empty and retryOnEmpty is enabled.
-   * A retried result that is STILL empty is returned as-is — the cap of 1
-   * is never exceeded. Never throws.
-   */
-  maybeRetry(
-    result: DispatchResultLike,
-    redispatch: () => Promise<DispatchResultLike>,
-  ): Promise<{
-    classification: DispatchClassification
-    retried: boolean
-    result: DispatchResultLike
-  }>
-}
-
-/** 1-based retry budget — the hard cap. Never 2x. */
-const MAX_RETRIES = 1
-
-/** Whether a result carries any text content (whitespace-only counts as empty). */
-function hasContent(result: DispatchResultLike): boolean {
-  return typeof result.content === 'string' && result.content.trim() !== ''
-}
-
-/** Whether the result carries any token counts (i.e. the model actually ran). */
-function hasTokens(result: DispatchResultLike): boolean {
-  return (result.tokensInput ?? 0) > 0 || (result.tokensOutput ?? 0) > 0
-}
-
-export function createDispatchGuard(options?: DispatchGuardOptions): DispatchGuard {
-  const retryOnEmpty = options?.retryOnEmpty ?? true
-  const warn = options?.logger?.warn ?? ((message: string) => log.warn(message))
-  // Per-instance retry budget — the "cap 1" enforcement point.
-  let retriesUsed = 0
-
-  return {
-    classifyResult(result: DispatchResultLike): DispatchClassification {
-      if (hasContent(result)) return 'content'
-      return hasTokens(result) ? 'empty-mode2' : 'empty-mode1'
-    },
-
-    async maybeRetry(result, redispatch) {
-      const classification = this.classifyResult(result)
-      if (!retryOnEmpty || classification === 'content' || retriesUsed >= MAX_RETRIES) {
-        return { classification, retried: false, result }
-      }
-      retriesUsed += 1
-      warn(`dispatch returned ${classification}; retrying once (cap ${MAX_RETRIES})`)
-      const retriedResult = await redispatch()
-      return {
-        classification: this.classifyResult(retriedResult),
-        retried: true,
-        result: retriedResult,
-      }
-    },
-  }
-}

package/src/pantheon/permission-eval.ts

@@ -1,284 +0,0 @@
-/**
- * S1 — Deny-first permission evaluation + PreToolUse-style hooks.
- *
- * Deny rules checked BEFORE allow rules. User-level denies cannot be
- * overridden by project config. Hook exit-code semantics:
- *   exit 0 → allow, exit 2 → hard deny, missing/throw → fail-open.
- *
- * @module permission-eval
- */
-
-// ─── Types ─────────────────────────────────────────────────────────────
-
-/** Result of a permission evaluation. */
-export interface PermissionResult {
-  allowed: boolean
-  reason: 'allow' | 'deny' | 'hook_deny' | 'no_match'
-  message?: string
-}
-
-/** Hook script result (mirrors hook-runner.ts HookResult). */
-export interface HookResult {
-  code: number
-  stdout: string
-  stderr: string
-  /** When true, the hook script was not found — treat as fail-open. */
-  missing?: boolean
-}
-
-/**
- * PreToolUse hook function signature.
- * exit 0 → allow, exit 2 → hard deny, exit 1 → soft deny.
- * Throw = fail-open.
- */
-export type PreToolUseHook = (tool: string, args: unknown) => Promise<HookResult> | HookResult
-
-/** Permission configuration. */
-export interface PermissionConfig {
-  /** Deny rules — evaluated first. User-level denies override project allows. */
-  deny: readonly string[]
-  /** Allow rules — evaluated after deny. */
-  allow: readonly string[]
-  /** Optional hooks configuration. */
-  hooks?: {
-    /** PreToolUse hook function (in-process, not script path). */
-    preToolUse?: PreToolUseHook
-  }
-}
-
-// ─── Pattern matching ──────────────────────────────────────────────────
-
-/**
- * Parse a permission rule pattern into { tool, argPattern }.
- *
- * Supported formats:
- *   - "tool"             → tool="tool", argPattern="*"
- *   - "tool:*"           → tool="tool", argPattern="*"
- *   - "tool:subcommand"  → tool="tool", argPattern="subcommand"
- *   - "tool(pattern)"    → tool="tool", argPattern="pattern" (full match)
- *   - "*:*"              → tool="*", argPattern="*"
- *   - "git push:*"       → tool="git push", argPattern="*" (subcommand prefix)
- */
-function parsePattern(pattern: string): { tool: string; argPattern: string } {
-  // Handle "tool(pattern)" format — the content inside parens is the full
-  // arg pattern. Colons inside parens are literal, not separators.
-  const parenMatch = /^([^(]+)\(([^)]+)\)$/.exec(pattern)
-  if (parenMatch) {
-    const tool = parenMatch[1] ?? ''
-    const argPattern = parenMatch[2] ?? ''
-    return { tool, argPattern }
-  }
-
-  // Handle "tool:argPattern" or just "tool"
-  const colonIdx = pattern.indexOf(':')
-  if (colonIdx === -1) {
-    return { tool: pattern, argPattern: '*' }
-  }
-  const argPattern = pattern.slice(colonIdx + 1)
-  return {
-    tool: pattern.slice(0, colonIdx),
-    // Empty argPattern after colon = wildcard (e.g. "*:" matches any args)
-    argPattern: argPattern === '' ? '*' : argPattern,
-  }
-}
-
-/**
- * Convert a glob-like pattern to a regex. `*` matches any sequence.
- * Anchored to full match.
- */
-function globToRegex(pattern: string): RegExp {
-  const escaped = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*/g, '.*')
-    .replace(/\?/g, '.')
-  return new RegExp(`^${escaped}$`)
-}
-
-/** Extract a string representation from tool args for pattern matching. */
-function argsToString(args: unknown): string {
-  if (args === null || args === undefined) return ''
-  if (typeof args === 'string') return args
-  if (typeof args === 'object') {
-    const record = args as Record<string, unknown>
-    // Try common field names
-    for (const key of ['command', 'cmd', 'query', 'pattern', 'filePath', 'path', 'url']) {
-      if (typeof record[key] === 'string') return record[key]
-    }
-    return JSON.stringify(args)
-  }
-  return String(args)
-}
-
-/**
- * Build a combined string for matching: "toolName argString".
- * This allows patterns like "git push:*" to match tool="git" with args
- * containing "push".
- */
-function combinedString(tool: string, args: unknown): string {
-  const argsStr = argsToString(args)
-  return argsStr !== '' ? `${tool} ${argsStr}` : tool
-}
-
-/**
- * Check if a tool+args matches a permission rule pattern.
- * Returns true when the pattern matches.
- *
- * Matching strategy:
- *   1. Wildcard tool ("*") → match any tool with argPattern
- *   2. Direct tool match → check argPattern against args
- *   3. Combined match (for "git push:*" style patterns) → prefix match
- */
-function matchesRule(pattern: string, tool: string, args: unknown): boolean {
-  const { tool: patternTool, argPattern } = parsePattern(pattern)
-
-  // Wildcard tool: match any tool
-  if (patternTool === '*') {
-    if (argPattern === '*') return true
-    const argsStr = argsToString(args)
-    return globToRegex(argPattern).test(argsStr)
-  }
-
-  // Check direct tool match
-  if (globToRegex(patternTool).test(tool)) {
-    if (argPattern === '*') return true
-    const argsStr = argsToString(args)
-    return globToRegex(argPattern).test(argsStr)
-  }
-
-  // Combined match for patterns with spaces (e.g. "git push:*")
-  // The pattern tool includes a subcommand that appears in args.
-  // Use prefix matching: "git push" matches "git push origin main"
-  if (patternTool.includes(' ')) {
-    const combined = combinedString(tool, args)
-    // Prefix match: combined starts with pattern tool
-    if (combined.startsWith(patternTool)) {
-      return true
-    }
-  }
-
-  return false
-}
-
-// ─── Evaluation ────────────────────────────────────────────────────────
-
-/**
- * Evaluate a permission config against a tool+args invocation.
- *
- * Evaluation order:
- *   1. Check deny rules (user-level first, then project-level)
- *   2. If no deny matched, run the PreToolUse hook
- *   3. If hook exits 0 (or missing), check allow rules
- *   4. If no allow matched → deny (implicit deny)
- *
- * User-level denies override project-level allows: a deny in the user config
- * cannot be cancelled by an allow in the project config.
- */
-export function evaluatePermission(
-  config: PermissionConfig,
-  invocation: { tool: string; args?: unknown },
-): PermissionResult {
-  const { tool, args } = invocation
-
-  // ── Step 1: Deny-first check ────────────────────────────────────────
-  for (const pattern of config.deny) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: false, reason: 'deny', message: `denied by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 2: PreToolUse hook ─────────────────────────────────────────
-  if (config.hooks?.preToolUse !== undefined) {
-    try {
-      const hookResult = config.hooks.preToolUse(tool, args)
-      // Support both sync and async hooks
-      // For sync hooks (non-Promise), check immediately
-      if (!(hookResult instanceof Promise)) {
-        // missing flag: hook script not found → fail-open
-        if (hookResult.missing === true) {
-          // Fall through to config evaluation (fail-open)
-        } else if (hookResult.code === 2) {
-          return {
-            allowed: false,
-            reason: 'hook_deny',
-            message: `hook hard deny (exit 2): ${hookResult.stderr}`,
-          }
-        } else if (hookResult.code !== 0) {
-          return {
-            allowed: false,
-            reason: 'hook_deny',
-            message: `hook deny (exit ${hookResult.code}): ${hookResult.stderr}`,
-          }
-        }
-        // Hook exited 0 (or missing) → fall through to allow check
-      }
-      // For async hooks, we cannot await in a sync function.
-      // Use evaluatePermissionAsync for async hooks.
-    } catch {
-      // Hook throw → fail-open: fall through to config evaluation
-    }
-  }
-
-  // ── Step 3: Allow check ─────────────────────────────────────────────
-  for (const pattern of config.allow) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: true, reason: 'allow', message: `allowed by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 4: No match → implicit deny ────────────────────────────────
-  return { allowed: false, reason: 'no_match', message: 'no matching allow rule' }
-}
-
-/**
- * Async version of evaluatePermission that properly awaits hooks.
- * Use this when hooks may be async (e.g., shell scripts).
- */
-export async function evaluatePermissionAsync(
-  config: PermissionConfig,
-  invocation: { tool: string; args?: unknown },
-): Promise<PermissionResult> {
-  const { tool, args } = invocation
-
-  // ── Step 1: Deny-first check ────────────────────────────────────────
-  for (const pattern of config.deny) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: false, reason: 'deny', message: `denied by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 2: PreToolUse hook ─────────────────────────────────────────
-  if (config.hooks?.preToolUse !== undefined) {
-    try {
-      const hookResult = await config.hooks.preToolUse(tool, args)
-      // missing flag: hook script not found → fail-open
-      if (hookResult.missing === true) {
-        // Fall through to config evaluation (fail-open)
-      } else if (hookResult.code === 2) {
-        return {
-          allowed: false,
-          reason: 'hook_deny',
-          message: `hook hard deny (exit 2): ${hookResult.stderr}`,
-        }
-      } else if (hookResult.code !== 0) {
-        return {
-          allowed: false,
-          reason: 'hook_deny',
-          message: `hook deny (exit ${hookResult.code}): ${hookResult.stderr}`,
-        }
-      }
-      // Hook exited 0 (or missing) → fall through to allow check
-    } catch {
-      // Hook throw → fail-open: fall through to config evaluation
-    }
-  }
-
-  // ── Step 3: Allow check ─────────────────────────────────────────────
-  for (const pattern of config.allow) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: true, reason: 'allow', message: `allowed by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 4: No match → implicit deny ────────────────────────────────
-  return { allowed: false, reason: 'no_match', message: 'no matching allow rule' }
-}

package/src/pantheon/preemptive-compact.ts

@@ -1,76 +0,0 @@
-/**
- * Preemptive Compaction Check (release-134 Phase 5) — dormant, ready-to-wire.
- *
- * WHY: the SDK 1.18.x exposes NO runtime source of context-usage percentage,
- * so there is nothing to observe at runtime yet. This module is the pure
- * decision core that warns the model BEFORE the context fills up — ready to
- * be wired to a future usage source, but deliberately NOT wired today.
- *
- * HOW: `preemptiveCompactCheck` is a pure function: given the current usage
- * fraction and the last fraction at which a warning was emitted, it decides
- * whether to warn again (threshold + re-warn step) and returns the effective
- * `lastWarnedPct`. The `enqueue` callback is INJECTED by the caller — this
- * module stays standalone and does NOT import the shared chat-reminders
- * buffer.
- *
- * YAGNI: no background timers, no polling, no plugin wiring. When (if) the
- * SDK exposes a usage source, the caller wires it into this check.
- *
- * FAIL-OPEN: the whole check is wrapped — an enqueue failure returns the
- * previous state and never throws.
- *
- * @module preemptive-compact
- */
-
-// ─── Constants ─────────────────────────────────────────────────────────
-
-/** Warn when context usage reaches this fraction (78%). */
-export const PREEMPTIVE_COMPACTION_THRESHOLD = 0.78
-
-/** Re-warn only when usage rose at least this much since the last warning (5pp). */
-export const PREEMPTIVE_REWARN_STEP = 0.05
-
-// ─── Types ─────────────────────────────────────────────────────────────
-
-/** Dependencies threaded to preemptiveCompactCheck (wired from plugin.ts). */
-export interface PreemptiveCompactDeps {
-  /** The session whose context usage is being checked. */
-  sessionID: string
-  /** Current context usage as a fraction (0..1). */
-  usagePct: number
-  /** Last fraction at which a warning was emitted (undefined = never). */
-  lastWarnedPct: number | undefined
-  /** Injectable enqueue (testable). The module stays standalone. */
-  enqueue: (text: string) => void
-}
-
-// ─── Decision ──────────────────────────────────────────────────────────
-
-/**
- * Pure decision: should a warning be emitted at the given usage?
- * True when usage is at/above the threshold AND either no warning was
- * emitted yet or usage rose by at least the re-warn step since the last one.
- */
-export function shouldWarn(usagePct: number, lastWarnedPct: number | undefined): boolean {
-  if (usagePct < PREEMPTIVE_COMPACTION_THRESHOLD) return false
-  if (lastWarnedPct === undefined) return true
-  return usagePct >= lastWarnedPct + PREEMPTIVE_REWARN_STEP
-}
-
-/**
- * Preemptive compaction check: when a warning should fire, enqueue the
- * reminder and return the usage fraction as the new `lastWarnedPct`.
- * Otherwise (or on any failure) return the previous `lastWarnedPct`.
- * NEVER throws — the hook must never break the session.
- */
-export function preemptiveCompactCheck(deps: PreemptiveCompactDeps): number | undefined {
-  try {
-    if (!shouldWarn(deps.usagePct, deps.lastWarnedPct)) return deps.lastWarnedPct
-    deps.enqueue(
-      `context usage at ${Math.round(deps.usagePct * 100)}% — consider compacting before continuing`,
-    )
-    return deps.usagePct
-  } catch {
-    return deps.lastWarnedPct
-  }
-}

package/src/pantheon/retry-policy.ts

@@ -1,212 +0,0 @@
-/**
- * R1 — Per-error-type retry + provider cooldown (LiteLLM pattern).
- *
- * Pure library (no SDK, no I/O). When a delegation fails, the error is
- * classified (auth | rate_limit | timeout | other), the per-error-type
- * retry policy from routing.yml `retry_policy` is applied with exponential
- * backoff, and provider cooldown state (routing.yml `cooldown`) is tracked
- * in-memory: after `allowed_fails` consecutive failures a provider is
- * skipped for `cooldown_time_seconds`; a success resets the counter.
- *
- * YAGNI: no usage-based routing, no Redis — a simple in-memory cooldown
- * map plus config.
- *
- * @module retry-policy
- */
-
-// ─── Types ─────────────────────────────────────────────────────────────
-
-/** Error classes a delegation failure can be classified into. */
-export type ErrorType = 'auth' | 'rate_limit' | 'timeout' | 'other'
-
-/** Max retries per error class (routing.yml `retry_policy`). */
-export interface RetryPolicy {
-  auth: number
-  rate_limit: number
-  timeout: number
-  other: number
-}
-
-/** Provider cooldown config (routing.yml `cooldown`). */
-export interface CooldownConfig {
-  /** Consecutive failures before the provider is skipped. */
-  allowedFails: number
-  /** How long the provider stays skipped, in seconds. */
-  cooldownTimeSeconds: number
-}
-
-/** Defaults matching routing.yml `retry_policy`. */
-export const DEFAULT_RETRY_POLICY: RetryPolicy = {
-  auth: 0,
-  rate_limit: 3,
-  timeout: 2,
-  other: 1,
-}
-
-/** Defaults matching routing.yml `cooldown`. */
-export const DEFAULT_COOLDOWN: CooldownConfig = {
-  allowedFails: 3,
-  cooldownTimeSeconds: 60,
-}
-
-// ─── Error classification ──────────────────────────────────────────────
-
-const AUTH_RE = /(auth|unauthorized|401|403|api[ _-]?key|invalid credential|permission denied)/i
-const RATE_LIMIT_RE = /(rate[ _-]?limit|429|too many requests|quota|throttl)/i
-const TIMEOUT_RE = /(timeout|timed out|deadline|504|408|etimedout)/i
-
-/**
- * Classify a thrown error into one of the four retry-policy buckets.
- * Message-based matching (LiteLLM pattern); unknown errors → 'other'.
- */
-export function classifyError(err: unknown): ErrorType {
-  const message = err instanceof Error ? err.message : String(err ?? '')
-  if (AUTH_RE.test(message)) return 'auth'
-  if (RATE_LIMIT_RE.test(message)) return 'rate_limit'
-  if (TIMEOUT_RE.test(message)) return 'timeout'
-  return 'other'
-}
-
-// ─── Exponential backoff ───────────────────────────────────────────────
-
-/**
- * Exponential backoff delay for a retry attempt (0-based): base * 2^attempt,
- * capped at maxMs. attempt 0 → base, attempt 1 → 2x base, etc.
- */
-export function computeBackoffMs(attempt: number, baseMs = 1000, maxMs = 30_000): number {
-  const delay = baseMs * 2 ** attempt
-  return Math.min(delay, maxMs)
-}
-
-// ─── Provider cooldown tracker ─────────────────────────────────────────
-
-interface CooldownEntry {
-  fails: number
-  cooldownUntil: number
-}
-
-/**
- * In-memory provider cooldown state. After `allowedFails` consecutive
- * failures a provider is skipped until `cooldownUntil`; a success resets
- * the counter. The clock is injectable for tests.
- */
-export class ProviderCooldownTracker {
-  private readonly state = new Map<string, CooldownEntry>()
-  readonly config: CooldownConfig
-
-  constructor(config: CooldownConfig = DEFAULT_COOLDOWN) {
-    this.config = config
-  }
-
-  /** Record one failure for a provider; trips cooldown at allowedFails. */
-  recordFailure(provider: string): void {
-    const entry = this.state.get(provider) ?? { fails: 0, cooldownUntil: 0 }
-    entry.fails += 1
-    if (entry.fails >= this.config.allowedFails) {
-      entry.cooldownUntil = Date.now() + this.config.cooldownTimeSeconds * 1000
-    }
-    this.state.set(provider, entry)
-  }
-
-  /** Record a success — resets the failure counter (no spurious cooldown). */
-  recordSuccess(provider: string): void {
-    this.state.delete(provider)
-  }
-
-  /**
-   * Whether the provider is currently skipped. Expired cooldowns are
-   * cleared; entries that never tripped (cooldownUntil 0) are kept so the
-   * consecutive-failure counter survives the check.
-   */
-  isInCooldown(provider: string, now = Date.now()): boolean {
-    const entry = this.state.get(provider)
-    if (entry === undefined) return false
-    if (entry.cooldownUntil > now) return true
-    if (entry.cooldownUntil > 0) this.state.delete(provider)
-    return false
-  }
-
-  /** Remaining cooldown time in ms (0 when not in cooldown). */
-  remainingCooldownMs(provider: string, now = Date.now()): number {
-    const entry = this.state.get(provider)
-    if (entry === undefined) return 0
-    return Math.max(0, entry.cooldownUntil - now)
-  }
-
-  /** Current consecutive failure count for a provider. */
-  failCount(provider: string): number {
-    return this.state.get(provider)?.fails ?? 0
-  }
-}
-
-// ─── Retry policy engine ───────────────────────────────────────────────
-
-export type RetryDecisionReason = 'policy' | 'cooldown'
-
-export interface RetryDecision {
-  shouldRetry: boolean
-  /** Retries still available for this error class (0 when exhausted). */
-  retriesRemaining: number
-  /** Backoff delay to wait before the next attempt (ms). */
-  delayMs: number
-  /** Why the decision was made: policy budget or provider cooldown. */
-  reason: RetryDecisionReason
-}
-
-/**
- * Combines error classification, the per-error-type retry policy, and the
- * provider cooldown tracker into one decision point. Enforcement: when a
- * delegation fails, call `decide(provider, err, attemptsUsed)`; when the
- * result is content, call `recordSuccess`; when the budget is exhausted,
- * call `recordFailure` so the cooldown can trip.
- */
-export class RetryPolicyEngine {
-  private readonly cooldown: ProviderCooldownTracker
-  readonly policy: RetryPolicy
-  readonly backoffBaseMs: number
-
-  constructor(
-    policy: RetryPolicy = DEFAULT_RETRY_POLICY,
-    cooldown?: ProviderCooldownTracker,
-    backoffBaseMs = 1000,
-  ) {
-    this.policy = policy
-    this.backoffBaseMs = backoffBaseMs
-    this.cooldown = cooldown ?? new ProviderCooldownTracker()
-  }
-
-  /**
-   * Decide whether a failed dispatch should be retried.
-   *
-   * @param provider provider name (cooldown key, e.g. "opencode")
-   * @param err the failure (classified into auth/rate_limit/timeout/other)
-   * @param attemptsUsed retries already consumed for this dispatch
-   * @param now injectable clock (tests)
-   */
-  decide(provider: string, err: unknown, attemptsUsed: number, now = Date.now()): RetryDecision {
-    if (this.cooldown.isInCooldown(provider, now)) {
-      return { shouldRetry: false, retriesRemaining: 0, delayMs: 0, reason: 'cooldown' }
-    }
-    const type = classifyError(err)
-    const retriesRemaining = Math.max(0, this.policy[type] - attemptsUsed)
-    if (retriesRemaining <= 0) {
-      return { shouldRetry: false, retriesRemaining: 0, delayMs: 0, reason: 'policy' }
-    }
-    return {
-      shouldRetry: true,
-      retriesRemaining,
-      delayMs: computeBackoffMs(attemptsUsed, this.backoffBaseMs),
-      reason: 'policy',
-    }
-  }
-
-  /** Record a failure (feeds the cooldown tracker). */
-  recordFailure(provider: string, _err: unknown): void {
-    this.cooldown.recordFailure(provider)
-  }
-
-  /** Record a success (resets the provider's failure counter). */
-  recordSuccess(provider: string): void {
-    this.cooldown.recordSuccess(provider)
-  }
-}