chore(OUT-3544): trim withRetry classifier JSDoc to essentials

The JSDoc on `isRetryableError` had grown to 37 lines — a bullet list of
error shapes the code itself documents, plus a verbose retry-nesting
paragraph. Keep only the load-bearing pieces: the idempotent gate
contract and the nesting hazard one-liner. Tighten the `RetryOptions`
field JSDoc and the inline strict-mode comment the same way.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: SandipBajracharya

src/app/api/core/utils/withRetry.ts

@@ -30,54 +30,25 @@ const RETRYABLE_ERROR_NAMES: ReadonlySet<string> = new Set([
 
 export type RetryOptions = {
   /**
-   * Set to false for non-idempotent writes whose upstream lacks a request-key
-   * dedupe primitive (QBO create/update/void/delete endpoints). In that mode
-   * the classifier retries ONLY on 429 (explicit server-side reject without
-   * commit) and explicit `RetryableError.retry === true`. Everything else —
-   * 5xx, network errors, AbortSignal timeouts — is treated as permanent,
-   * because each of those can occur after the server has already committed
-   * and a replay would duplicate the write. Defaults to true (read-path /
-   * safe-to-replay behavior).
+   * False for non-idempotent writes (QBO create/update/void/delete) whose
+   * upstream has no request-key dedupe. In strict mode the classifier
+   * retries only on 429 and explicit `RetryableError.retry === true`;
+   * 5xx, network errors, and AbortSignal timeouts all bubble. Defaults
+   * to true (safe-to-replay reads).
    */
   idempotent?: boolean
 }
 
 /**
- * Centralized classifier for whether an error should trigger a retry.
- * Exported so it can be unit-tested independent of pRetry's timer plumbing.
+ * Classifies whether an error should trigger a retry. 429 and explicit
+ * `RetryableError.retry === true` retry in both modes. Strict mode
+ * (`options.idempotent === false`) short-circuits past 429: 5xx, network
+ * codes, AbortSignal timeouts, and undici fetch-failed envelopes are all
+ * treated as possibly-after-commit and never replayed.
  *
- * Retry-set composition is gated by `options.idempotent` (default true):
- *   - `RetryableError` is honored in both modes (explicit caller signal).
- *   - `ALWAYS_RETRY_STATUSES` (429) fires in both modes.
- *   - In strict mode (`idempotent: false`) everything past the 429 check
- *     short-circuits to non-retryable: 5xx, network codes, AbortSignal
- *     timeouts, and undici fetch-failed envelopes are all treated as
- *     possibly-after-commit and never replayed.
- *
- * The error shapes inspected here come from different layers; a single
- * unified type doesn't exist, which is why the input is `unknown` and
- * each field is checked defensively:
- *
- *   - `RetryableError` (ours, src/utils/error.ts) — explicit retry flag.
- *   - `HttpFetchError` (ours) and Copilot SDK's `StatusableError` —
- *     `status: number` set after a non-2xx response was received.
- *   - undici (Node fetch) network failures — thrown as
- *     `TypeError: fetch failed` with the underlying error on `.cause`
- *     (e.g. `{ code: 'ECONNRESET' }`). No HTTP response was ever built,
- *     so there is no status to inspect.
- *   - `AbortSignal.timeout()` rejects with a `DOMException` whose
- *     `name` is `'TimeoutError'` (retryable). `AbortController.abort()`
- *     produces `'AbortError'` and is NOT retried (deliberate cancellation).
- *   - Top-level `error.code` is checked defensively for legacy Node
- *     error paths; in current Node fetch the code lives under `.cause`.
- *
- * Retry-nesting hazard: do not call a `withRetry`-wrapped function from
- * inside another `withRetry`-wrapped function. With the broadened retry
- * set, worst-case wait is `outer × inner × per_call_timeout`, which can
- * blow past the 300s webhook execution budget. Inside `IntuitAPI._*`
- * methods that are themselves wrapped at the public level (see exports
- * at the bottom of `src/utils/intuitAPI.ts`), call the unwrapped `_*`
- * counterparts directly (e.g. `this._customQuery`, not `this.customQuery`).
+ * Retry-nesting hazard: don't call a wrapped function from inside another.
+ * Inside `IntuitAPI._*` methods call the unwrapped `_*` counterparts
+ * (e.g. `this._customQuery`, not `this.customQuery`).
  */
 export const isRetryableError = (
   error: unknown,
@@ -100,8 +71,7 @@ export const isRetryableError = (
   if (typeof err.status === 'number' && ALWAYS_RETRY_STATUSES.has(err.status))
     return true
 
-  // Non-idempotent mode: nothing past this point is safe — 5xx, network blips,
-  // and timeouts can all occur after the upstream has committed.
+  // Strict mode: nothing past this point is post-commit-safe.
   if (!idempotent) return false
 
   if (