refactor: extract startSpinner helper, use running total for progress, report NaN counts

- Extract startSpinner() from duplicated spinner code in poll() and
  withProgress() — eliminates ~30 lines of duplication
- Set stopped = true unconditionally in poll() finally block, not just in
  non-JSON mode
- Replace fetchedCounts array + reduce with running total + delta tracking
  in multi-target progress (onPage reports cumulative, not increments)
- Use '?'.padStart(COL_COUNT) for NaN placeholder instead of hardcoded spaces,
  and report to Sentry as a warning for unexpected non-numeric input

Author: BYK

src/commands/issue/list.ts

@@ -600,7 +600,11 @@ async function handleResolvedTargets(
   const results = await withProgress(
     { stderr, message: "Fetching issues..." },
     (setMessage) => {
-      const fetchedCounts = new Array<number>(targets.length).fill(0);
+      // Track per-target previous counts to compute deltas — onPage reports the
+      // running total for each target, not increments, so we need the previous
+      // value to derive how many new items arrived per callback.
+      let totalFetched = 0;
+      const prevFetched = new Array<number>(targets.length).fill(0);
       const totalLimit = flags.limit * targets.length;
       return Promise.all(
         targets.map((t, i) =>
@@ -610,8 +614,8 @@ async function handleResolvedTargets(
             sort: flags.sort,
             statsPeriod: flags.period,
             onPage: (fetched) => {
-              fetchedCounts[i] = fetched;
-              const totalFetched = fetchedCounts.reduce((a, b) => a + b, 0);
+              totalFetched += fetched - (prevFetched[i] ?? 0);
+              prevFetched[i] = fetched;
               setMessage(`Fetching issues... ${totalFetched}/${totalLimit}`);
             },
           })

src/lib/formatters/human.ts

@@ -5,6 +5,8 @@
  * Follows gh cli patterns for alignment and presentation.
  */
 
+// biome-ignore lint/performance/noNamespaceImport: Sentry SDK recommends namespace import
+import * as Sentry from "@sentry/bun";
 import prettyMs from "pretty-ms";
 import type {
   Breadcrumb,
@@ -333,7 +335,11 @@ function abbreviateCount(raw: string): string {
   if (Number.isNaN(n)) {
     // Non-numeric input: use a placeholder rather than passing through an
     // arbitrarily wide string that would break column alignment
-    return "    ?";
+    Sentry.captureMessage(
+      `Unexpected non-numeric issue count: ${raw}`,
+      "warning"
+    );
+    return "?".padStart(COL_COUNT);
   }
   if (n < 10_000) {
     return raw.padStart(COL_COUNT);

src/lib/polling.ts

@@ -83,31 +83,17 @@ export async function poll<T>(options: PollOptions<T>): Promise<T> {
   } = options;
 
   const startTime = Date.now();
-  let tick = 0;
-  let currentMessage = initialMessage;
-
-  // Animation timer runs independently of polling for smooth spinner
-  let stopped = false;
-  if (!json) {
-    const scheduleFrame = () => {
-      if (stopped) {
-        return;
-      }
-      const display = truncateProgressMessage(currentMessage);
-      stderr.write(`\r\x1b[K${formatProgressLine(display, tick)}`);
-      tick += 1;
-      setTimeout(scheduleFrame, ANIMATION_INTERVAL_MS).unref();
-    };
-    scheduleFrame();
-  }
+  const spinner = json ? null : startSpinner(stderr, initialMessage);
 
   try {
     while (Date.now() - startTime < timeoutMs) {
       const state = await fetchState();
 
       if (state) {
-        // Update message for animation loop to display
-        currentMessage = getProgressMessage(state);
+        // Always call getProgressMessage (callers may rely on the callback
+        // being invoked), but only forward the result to the spinner.
+        const msg = getProgressMessage(state);
+        spinner?.setMessage(msg);
 
         if (shouldStop(state)) {
           return state;
@@ -119,14 +105,48 @@ export async function poll<T>(options: PollOptions<T>): Promise<T> {
 
     throw new Error(timeoutMessage);
   } finally {
-    // Clean up animation timer
+    spinner?.stop();
     if (!json) {
-      stopped = true;
       stderr.write("\n");
     }
   }
 }
 
+/**
+ * Start an animated spinner that writes progress to stderr.
+ *
+ * Returns a controller with `setMessage` to update the displayed text
+ * and `stop` to halt the animation.
+ */
+function startSpinner(
+  stderr: Writer,
+  initialMessage: string
+): { setMessage: (msg: string) => void; stop: () => void } {
+  let currentMessage = initialMessage;
+  let tick = 0;
+  let stopped = false;
+
+  const scheduleFrame = () => {
+    if (stopped) {
+      return;
+    }
+    const display = truncateProgressMessage(currentMessage);
+    stderr.write(`\r\x1b[K${formatProgressLine(display, tick)}`);
+    tick += 1;
+    setTimeout(scheduleFrame, ANIMATION_INTERVAL_MS).unref();
+  };
+  scheduleFrame();
+
+  return {
+    setMessage: (msg: string) => {
+      currentMessage = msg;
+    },
+    stop: () => {
+      stopped = true;
+    },
+  };
+}
+
 /**
  * Options for {@link withProgress}.
  */
@@ -169,28 +189,12 @@ export async function withProgress<T>(
   options: WithProgressOptions,
   fn: (setMessage: (msg: string) => void) => Promise<T>
 ): Promise<T> {
-  const { stderr } = options;
-  let currentMessage = options.message;
-  let tick = 0;
-  let stopped = false;
-
-  const scheduleFrame = () => {
-    if (stopped) {
-      return;
-    }
-    const display = truncateProgressMessage(currentMessage);
-    stderr.write(`\r\x1b[K${formatProgressLine(display, tick)}`);
-    tick += 1;
-    setTimeout(scheduleFrame, ANIMATION_INTERVAL_MS).unref();
-  };
-  scheduleFrame();
+  const spinner = startSpinner(options.stderr, options.message);
 
   try {
-    return await fn((msg) => {
-      currentMessage = msg;
-    });
+    return await fn(spinner.setMessage);
   } finally {
-    stopped = true;
-    stderr.write("\r\x1b[K");
+    spinner.stop();
+    options.stderr.write("\r\x1b[K");
   }
 }