Lower precision in ET rendering: round sub-1000 values to nearest 10

Agent-Logs-Url: https://github.com/github/gh-aw/sessions/421a2320-dc20-44d9-b8a7-f45b05335d6c

Co-authored-by: pelikhan <4175913+pelikhan@users.noreply.github.com>

Author: Copilot

actions/setup/js/effective_tokens.cjs

@@ -186,15 +186,22 @@ function computeEffectiveTokens(model, inputTokens, outputTokens, cacheReadToken
 /**
  * Formats an ET number in a compact, human-readable form.
  *
+ * Effective tokens are estimates, so sub-1000 values are rounded to the nearest 10.
+ *
  * Ranges:
- *   < 1,000        → exact integer (e.g. "900")
+ *   < 10           → exact integer (e.g. "7")
+ *   10–999         → rounded to nearest 10 (e.g. "40", "120", "900")
  *   1,000–999,999  → Xk with one decimal when non-zero (e.g. "1.2K", "450K")
  *   >= 1,000,000   → Xm with one decimal when non-zero (e.g. "1.2M", "3M")
  *
  * @param {number} n - Non-negative ET value (should be rounded before passing)
  * @returns {string} Compact string representation
  */
 function formatET(n) {
+  // Round to nearest 10 for values in [10, 1000) — effective tokens are estimates
+  if (n >= 10 && n < 1000) {
+    n = Math.round(n / 10) * 10;
+  }
   if (n < 1000) return String(n);
   if (n < 1_000_000) return `${(n / 1000).toFixed(1).replace(/\.0$/, "")}K`;
   return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;

actions/setup/js/effective_tokens.test.cjs

@@ -302,11 +302,24 @@ describe("effective_tokens", () => {
   });
 
   describe("formatET", () => {
-    test("returns exact string for values under 1000", () => {
+    test("returns exact string for values under 10", () => {
       expect(formatET(0)).toBe("0");
       expect(formatET(1)).toBe("1");
+      expect(formatET(9)).toBe("9");
+    });
+
+    test("rounds values in [10, 1000) to nearest 10", () => {
+      expect(formatET(10)).toBe("10");
+      expect(formatET(14)).toBe("10");
+      expect(formatET(15)).toBe("20");
+      expect(formatET(42)).toBe("40");
+      expect(formatET(123)).toBe("120");
       expect(formatET(900)).toBe("900");
-      expect(formatET(999)).toBe("999");
+    });
+
+    test("rounds values near 1000 up to 1K", () => {
+      expect(formatET(995)).toBe("1K");
+      expect(formatET(999)).toBe("1K");
     });
 
     test("formats values in the thousands as K", () => {

pkg/cli/health_metrics.go

@@ -235,14 +235,23 @@ func GroupRunsByWorkflow(runs []WorkflowRun) map[string][]WorkflowRun {
 	return grouped
 }
 
-// formatTokens formats token count in a human-readable format
+// formatTokens formats token count in a human-readable format.
+// Values in [10, 1000) are rounded to the nearest 10 — token counts are estimates.
 func formatTokens(tokens int) string {
 	if tokens == 0 {
 		return "-"
 	}
-	if tokens < 1000 {
+	if tokens < 10 {
 		return strconv.Itoa(tokens)
 	}
+	if tokens < 1000 {
+		// Round to nearest 10 — token counts are estimates
+		rounded := (tokens + 5) / 10 * 10
+		if rounded >= 1000 {
+			return "1K"
+		}
+		return strconv.Itoa(rounded)
+	}
 	if tokens < 1000000 {
 		return fmt.Sprintf("%.1fK", float64(tokens)/1000)
 	}

pkg/cli/health_metrics_test.go

@@ -233,10 +233,30 @@ func TestFormatTokens(t *testing.T) {
 			expected: "-",
 		},
 		{
-			name:     "small tokens",
+			name:     "single digit kept exact",
+			tokens:   7,
+			expected: "7",
+		},
+		{
+			name:     "rounds to nearest 10",
+			tokens:   42,
+			expected: "40",
+		},
+		{
+			name:     "rounds up to nearest 10",
+			tokens:   45,
+			expected: "50",
+		},
+		{
+			name:     "multiple of 10 unchanged",
 			tokens:   500,
 			expected: "500",
 		},
+		{
+			name:     "rounds near 1000 to 1K",
+			tokens:   999,
+			expected: "1K",
+		},
 		{
 			name:     "thousands",
 			tokens:   5000,