agent-dealer 1.2.4 → 1.2.6

package/bundle/server/dist/capacity/claude-local-cache.test.js

@@ -1,8 +1,10 @@
 // packages/server/src/capacity/claude-local-cache.test.ts
 //
 // NOT-268: Claude capacity local-first ladder — local cache 5H/1W plus a
-// one-hour paid fallback. No test here performs a live provider request:
-// every probe spawn goes through an injected fake runner.
+// free `/usage` refresh; NOT-281 retargeted the trigger to either window at
+// least 14 minutes old (per-window, inside the 15-minute display freshness).
+// No test here performs a live provider request: every probe spawn goes
+// through an injected fake runner.
 import { test, before, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import fs from "node:fs";
@@ -14,8 +16,8 @@ const { createAgent } = await import("../repository/agents.js");
 const { listCapacitySnapshots, clearAllCapacitySnapshots, } = await import("../repository/runtime-capacity.js");
 const { parseNdjson } = await import("../runners/stream-json.js");
 const { getRuntimeCapacitySnapshot } = await import("./service.js");
-const { recordClaudeCapacityFromEvents } = await import("./claude-events.js");
-const { CLAUDE_CACHE_FILE_ENV, CLAUDE_CAPACITY_REFRESH_ENV, buildClaudeProbeArgv, claudeCacheFilePath, extractClaudeCacheSubtree, ingestClaudeLocalCache, isClaudePaidFallbackEnabled, maybeProbeClaudeCapacity, newestValidClaudeObservationMs, parseClaudeCachedUtilization, probeDiagnosticLogPath, readClaudeLocalCache, refreshClaudeCapacityIfStale, resetClaudeCapacityRefreshState, runClaudeCapacityProbe, } = await import("./claude-local-cache.js");
+const { recordClaudeCapacityFromEvents, recordClaudeWindowReadings } = await import("./claude-events.js");
+const { CLAUDE_CACHE_FILE_ENV, CLAUDE_CAPACITY_REFRESH_ENV, CLAUDE_PROBE_STALE_AFTER_MS, buildClaudeProbeArgv, claudeCacheFilePath, extractClaudeCacheSubtree, ingestClaudeLocalCache, isClaudePaidFallbackEnabled, maybeProbeClaudeCapacity, newestValidClaudeObservationMs, newestValidClaudeObservationMsByRole, parseClaudeCachedUtilization, probeDiagnosticLogPath, readClaudeLocalCache, refreshClaudeCapacityIfStale, resetClaudeCapacityRefreshState, runClaudeCapacityProbe, } = await import("./claude-local-cache.js");
 const NOW_MS = Date.parse("2026-09-20T12:00:00.000Z");
 const FIVE_HOUR_RESET_SEC = Math.floor(NOW_MS / 1000) + 2 * 3600;
 const SEVEN_DAY_RESET_SEC = Math.floor(NOW_MS / 1000) + 3 * 24 * 3600;
@@ -42,17 +44,39 @@ function fullCacheFixture(fetchedAtMs) {
         },
     });
 }
-function probeStreamFixture(observedIso, costUsd = 0.0003) {
+// Mirrors a real `claude -p "/usage"` stream at 2.1.283: a local-command
+// result event carrying `usage_report.rate_limits.limits[]` (verified live
+// 2026-09-27 — see claude-local-cache.ts module header), followed by the
+// terminal `result` event. Real runs cost $0 (no model call); `costUsd`
+// defaults to 0 but stays overridable for the cost-plumbing assertions.
+function probeStreamFixture(observedIso, costUsd = 0) {
     return [
         JSON.stringify({
-            type: "rate_limit_event",
+            type: "assistant",
             timestamp: observedIso,
-            rate_limit_info: {
-                status: "allowed",
-                unifiedWindows: [
-                    { window: "five_hour", utilization: 0.2, resetsAt: FIVE_HOUR_RESET_SEC },
-                    { window: "seven_day", utilization: 0.4, resetsAt: SEVEN_DAY_RESET_SEC },
-                ],
+            local_command_run: { command: "usage", args: "" },
+            usage_report: {
+                session: { total_cost_usd: 0 },
+                rate_limits: {
+                    limits: [
+                        {
+                            kind: "session",
+                            group: "session",
+                            percent: 20,
+                            resets_at: new Date(FIVE_HOUR_RESET_SEC * 1000).toISOString(),
+                            severity: "normal",
+                            is_active: false,
+                        },
+                        {
+                            kind: "weekly_all",
+                            group: "weekly",
+                            percent: 40,
+                            resets_at: new Date(SEVEN_DAY_RESET_SEC * 1000).toISOString(),
+                            severity: "normal",
+                            is_active: true,
+                        },
+                    ],
+                },
             },
         }),
         JSON.stringify({
@@ -66,6 +90,42 @@ function probeStreamFixture(observedIso, costUsd = 0.0003) {
 const throwingRunner = () => {
     throw new Error("probe runner must not be called while disabled/fresh");
 };
+/**
+ * Seed the snapshot store with per-window ages (NOT-281): the shared cache
+ * fixture always stamps both windows together, so split-freshness cases
+ * need direct per-role rows. Resets stay in the future so rows count as
+ * valid observations at NOW_MS.
+ */
+function seedWindowAges(fiveHourAgeMs, weeklyAgeMs, nowMs = NOW_MS) {
+    const readings = [];
+    const role = (five, ageMs) => ({
+        windowKey: five ? "claude_unified_five_hour" : "claude_unified_seven_day",
+        providerBucket: five ? "five_hour" : "seven_day",
+        durationMinutes: five ? 300 : 10080,
+        providerLabel: five ? "five_hour" : "seven_day",
+        usedValue: five ? 0.17 : 0.42,
+        usedUnit: "fraction",
+        usedFraction: five ? 0.17 : 0.42,
+        resetAt: new Date((five ? FIVE_HOUR_RESET_SEC : SEVEN_DAY_RESET_SEC) * 1000).toISOString(),
+        observedAt: new Date(nowMs - ageMs).toISOString(),
+        source: "observed_event",
+        evidenceRef: "test:split-window-seed",
+        criticalRole: five ? "five_hour" : "weekly",
+    });
+    if (fiveHourAgeMs !== null)
+        readings.push(role(true, fiveHourAgeMs));
+    if (weeklyAgeMs !== null)
+        readings.push(role(false, weeklyAgeMs));
+    assert.equal(recordClaudeWindowReadings(readings, "claude_code", nowMs), readings.length);
+}
+function successRunner(atMs = NOW_MS) {
+    return async () => ({
+        stdout: probeStreamFixture(new Date(atMs).toISOString()),
+        exitCode: 0,
+        timedOut: false,
+        spawnError: null,
+    });
+}
 before(() => {
     migrate();
     createAgent({
@@ -263,7 +323,7 @@ test("a 2-hour-old cache ingests with its true age and reads expired, never live
         assert.equal(w.unavailableReason, "expired");
     }
 });
-test("paid fallback defaults on; explicit off and unrecognized values never spawn", async () => {
+test("refresh defaults on; explicit off and unrecognized values never spawn", async () => {
     for (const value of [undefined, "", "paid-after-1h"]) {
         if (value === undefined)
             delete process.env[CLAUDE_CAPACITY_REFRESH_ENV];
@@ -277,17 +337,33 @@ test("paid fallback defaults on; explicit off and unrecognized values never spaw
         const outcome = await maybeProbeClaudeCapacity(NOW_MS, { runner: throwingRunner });
         assert.deepEqual(outcome, { probed: false, reason: "disabled" });
     }
-    process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "paid-after-1h";
+    delete process.env[CLAUDE_CAPACITY_REFRESH_ENV];
     assert.equal(isClaudePaidFallbackEnabled(), true);
 });
-test("default-on fallback suppresses a fresh sample; stale data triggers exactly one", async () => {
-    delete process.env[CLAUDE_CAPACITY_REFRESH_ENV];
+test("extractClaudeUsageReportLimits reads the /usage local-command result", async () => {
+    const { extractClaudeUsageReportLimits } = await import("./claude-local-cache.js");
+    const observedIso = new Date(NOW_MS).toISOString();
+    const events = probeStreamFixture(observedIso).split("\n").map((l) => JSON.parse(l));
+    const readings = extractClaudeUsageReportLimits(events, NOW_MS);
+    assert.ok(readings);
+    assert.equal(readings.length, 2);
+    const fiveHour = readings.find((w) => w.criticalRole === "five_hour");
+    const weekly = readings.find((w) => w.criticalRole === "weekly");
+    assert.equal(fiveHour.usedPercent, 20);
+    assert.equal(weekly.usedPercent, 40);
+    assert.equal(fiveHour.observedAt, observedIso);
+    assert.equal(fiveHour.evidenceRef, "claude-probe:usage-command");
+    // No usage_report anywhere in the stream — nothing fabricated.
+    assert.equal(extractClaudeUsageReportLimits([{ type: "result" }], NOW_MS), null);
+});
+test("default-on refresh suppresses a fresh sample; stale data triggers exactly one", async () => {
+    assert.equal(CLAUDE_PROBE_STALE_AFTER_MS, 14 * 60_000);
     fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 10 * 60_000));
     assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
-    assert.ok((newestValidClaudeObservationMs(NOW_MS) ?? 0) > NOW_MS - 60 * 60_000);
+    assert.ok((newestValidClaudeObservationMs(NOW_MS) ?? 0) > NOW_MS - CLAUDE_PROBE_STALE_AFTER_MS);
     const fresh = await maybeProbeClaudeCapacity(NOW_MS, { runner: throwingRunner });
     assert.deepEqual(fresh, { probed: false, reason: "fresh" });
-    // All samples ≥60 minutes old: five concurrent readers share one probe.
+    // All samples past the 14-minute trigger: five concurrent readers share one probe.
     clearAllCapacitySnapshots();
     resetClaudeCapacityRefreshState();
     fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 61 * 60_000));
@@ -304,8 +380,122 @@ test("default-on fallback suppresses a fresh sample; stale data triggers exactly
     assert.equal(outcomes.filter((o) => o.reason === "shared").length, 4);
     assert.ok(outcomes.every((o) => o.probed && o.ok));
 });
-test("probe argv pins the fixed prompt, cheapest model, no tools/MCP, one turn, ≤$0.01", async () => {
-    process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "paid-after-1h";
+test("a stale twin triggers one refresh even when its sibling is newer", async () => {
+    // NOT-281: the old newest-of-pair gate let one fresh window suppress the
+    // refresh while its sibling went stale. Freshness is per window now.
+    seedWindowAges(5 * 60_000, 20 * 60_000);
+    const byRole = newestValidClaudeObservationMsByRole(NOW_MS);
+    assert.equal(byRole.five_hour, NOW_MS - 5 * 60_000);
+    assert.equal(byRole.weekly, NOW_MS - 20 * 60_000);
+    let calls = 0;
+    const runner = async () => {
+        calls++;
+        return {
+            stdout: probeStreamFixture(new Date(NOW_MS).toISOString()),
+            exitCode: 0,
+            timedOut: false,
+            spawnError: null,
+        };
+    };
+    const outcome = await maybeProbeClaudeCapacity(NOW_MS, { runner });
+    assert.equal(calls, 1);
+    assert.equal(outcome.probed, true);
+    assert.equal(outcome.reason, "completed");
+    assert.equal(outcome.ok, true);
+    // On success both windows are fresh again …
+    const after = newestValidClaudeObservationMsByRole(NOW_MS);
+    assert.equal(after.five_hour, NOW_MS);
+    assert.equal(after.weekly, NOW_MS);
+    // … and the next API/UI poll (a minute later, well inside the ordinary
+    // 15-minute stale boundary) reports known values with no new spawn.
+    const poll = await maybeProbeClaudeCapacity(NOW_MS + 60_000, { runner: throwingRunner });
+    assert.deepEqual(poll, { probed: false, reason: "fresh" });
+    const snap = getRuntimeCapacitySnapshot(NOW_MS + 60_000);
+    const claude = snap.runtimes.find((r) => r.runtime === "claude_code");
+    assert.equal(claude.windows.find((w) => w.displayLabel === "5H").remainingPercent, 80);
+    assert.equal(claude.windows.find((w) => w.displayLabel === "1W").remainingPercent, 60);
+});
+test("a missing window triggers a refresh even when the sibling is newer", async () => {
+    seedWindowAges(5 * 60_000, null);
+    assert.deepEqual(newestValidClaudeObservationMsByRole(NOW_MS), {
+        five_hour: NOW_MS - 5 * 60_000,
+        weekly: null,
+    });
+    let calls = 0;
+    const runner = async () => {
+        calls++;
+        return {
+            stdout: probeStreamFixture(new Date(NOW_MS).toISOString()),
+            exitCode: 0,
+            timedOut: false,
+            spawnError: null,
+        };
+    };
+    const outcome = await maybeProbeClaudeCapacity(NOW_MS, { runner });
+    assert.equal(calls, 1);
+    assert.equal(outcome.ok, true);
+    assert.deepEqual(newestValidClaudeObservationMsByRole(NOW_MS), {
+        five_hour: NOW_MS,
+        weekly: NOW_MS,
+    });
+});
+test("the freshness boundary is 14 minutes: just under stays quiet, exactly at triggers", async () => {
+    seedWindowAges(13 * 60_000, 13 * 60_000);
+    const fresh = await maybeProbeClaudeCapacity(NOW_MS, { runner: throwingRunner });
+    assert.deepEqual(fresh, { probed: false, reason: "fresh" });
+    clearAllCapacitySnapshots();
+    resetClaudeCapacityRefreshState();
+    seedWindowAges(14 * 60_000, 0);
+    const stale = await maybeProbeClaudeCapacity(NOW_MS, { runner: successRunner() });
+    assert.equal(stale.probed, true);
+    assert.equal(stale.reason, "completed");
+    assert.equal(stale.ok, true);
+});
+test("a healthy refresh buys 14 minutes: no second attempt inside the interval", async () => {
+    seedWindowAges(20 * 60_000, 20 * 60_000);
+    let calls = 0;
+    const runner = async () => {
+        calls++;
+        return {
+            stdout: probeStreamFixture(new Date(NOW_MS).toISOString()),
+            exitCode: 0,
+            timedOut: false,
+            spawnError: null,
+        };
+    };
+    const first = await maybeProbeClaudeCapacity(NOW_MS, { runner });
+    assert.equal(first.ok, true);
+    assert.equal(calls, 1);
+    // A 5-second-poll cadence sees fresh rows and spawns nothing.
+    const poll = await maybeProbeClaudeCapacity(NOW_MS + 5_000, { runner: throwingRunner });
+    assert.deepEqual(poll, { probed: false, reason: "fresh" });
+    // Even if the rows go missing mid-interval (e.g. a reset passes), the
+    // attempt cooldown stamped by the healthy run holds — at most one
+    // refresh per 14 minutes, never a retry per poll.
+    clearAllCapacitySnapshots();
+    const missing = await maybeProbeClaudeCapacity(NOW_MS + 5 * 60_000, { runner: throwingRunner });
+    assert.deepEqual(missing, { probed: false, reason: "backoff" });
+    assert.equal(calls, 1);
+    // Past the interval the gate opens again.
+    const later = await maybeProbeClaudeCapacity(NOW_MS + 15 * 60_000, { runner });
+    assert.equal(later.probed, true);
+    assert.equal(calls, 2);
+});
+test("disabled refresh never spawns and stale readings stay honestly N/A", async () => {
+    process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "off";
+    // 20 minutes old: past the 15-minute display freshness, inside expiry.
+    fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 20 * 60_000));
+    assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
+    const outcome = await maybeProbeClaudeCapacity(NOW_MS, { runner: throwingRunner });
+    assert.deepEqual(outcome, { probed: false, reason: "disabled" });
+    const snap = getRuntimeCapacitySnapshot(NOW_MS);
+    const claude = snap.runtimes.find((r) => r.runtime === "claude_code");
+    for (const w of claude.windows) {
+        assert.equal(w.remainingPercent, null);
+        assert.equal(w.unavailableReason, "stale");
+    }
+});
+test("probe argv pins the fixed /usage command plus structural model-turn safeguards", async () => {
     fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 61 * 60_000));
     assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
     let seenBin = "";
@@ -322,7 +512,7 @@ test("probe argv pins the fixed prompt, cheapest model, no tools/MCP, one turn,
     assert.equal(seenBin, "/fake/claude");
     assert.deepEqual(seenArgv, [
         "-p",
-        "Reply with exactly: ok",
+        "/usage",
         "--model",
         "haiku",
         "--max-turns",
@@ -337,13 +527,14 @@ test("probe argv pins the fixed prompt, cheapest model, no tools/MCP, one turn,
         "--max-budget-usd",
         "0.01",
     ]);
-    // Semantic pins behind the exact match: cheapest model, hard one-turn
-    // bound, tools fully off, MCP restricted to none passed, stream JSON,
-    // hard budget cap.
+    // Semantic pins behind the exact match: no MCP config passed, cheapest
+    // model + hard one-turn bound + no tools kept as structural safeguards
+    // (2026-09-27 review hardening) even though `/usage` never reaches the
+    // model on 2.1.283, plus the defensive budget cap.
+    assert.ok(!seenArgv.includes("--mcp-config"));
     assert.equal(seenArgv[seenArgv.indexOf("--model") + 1], "haiku");
     assert.equal(seenArgv[seenArgv.indexOf("--max-turns") + 1], "1");
     assert.equal(seenArgv[seenArgv.indexOf("--tools") + 1], "");
-    assert.ok(!seenArgv.includes("--mcp-config"));
     const budget = Number(seenArgv[seenArgv.indexOf("--max-budget-usd") + 1]);
     assert.ok(Number.isFinite(budget) && budget <= 0.01);
     assert.equal(seenArgv.filter((a) => a === "-p").length, 1);
@@ -357,7 +548,7 @@ test("probe success updates both 5H and 1W and records cost without prompt/outpu
     assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
     const marker = "probe-stream-marker-must-never-reach-log";
     const runner = async () => ({
-        stdout: `${probeStreamFixture(new Date(NOW_MS).toISOString(), 0.0007)}\n${JSON.stringify({ type: "assistant", text: marker })}`,
+        stdout: `${probeStreamFixture(new Date(NOW_MS).toISOString())}\n${JSON.stringify({ type: "assistant", text: marker })}`,
         exitCode: 0,
         timedOut: false,
         spawnError: null,
@@ -365,28 +556,134 @@ test("probe success updates both 5H and 1W and records cost without prompt/outpu
     const result = await runClaudeCapacityProbe(NOW_MS, { runner });
     assert.equal(result.ok, true);
     assert.equal(result.failureKind, null);
-    assert.equal(result.costUsd, 0.0007);
+    assert.equal(result.costUsd, 0);
     assert.deepEqual(result.windowsUpdated, ["claude_unified_five_hour", "claude_unified_seven_day"]);
     const rows = listCapacitySnapshots("claude_code");
     assert.equal(rows.find((r) => r.providerBucket === "five_hour").remainingPercent, 80);
     assert.equal(rows.find((r) => r.providerBucket === "seven_day").remainingPercent, 60);
     assert.equal(rows.find((r) => r.providerBucket === "five_hour").observedAt, new Date(NOW_MS).toISOString());
     const logText = fs.readFileSync(probeDiagnosticLogPath(), "utf8");
-    assert.ok(logText.includes('"costUsd":0.0007'));
+    assert.ok(logText.includes('"costUsd":0'));
     assert.ok(!logText.includes("Reply with exactly"));
     assert.ok(!logText.includes(marker));
 });
-test("probe success via the cache side effect when the stream carries no windows", async () => {
+test("probe rejects and ingests nothing when the result reports nonzero cost", async () => {
+    // Reviewer-requested hardening (PR #165): any charge means /usage did not
+    // resolve locally as expected — reject the whole run rather than trusting
+    // windows a real (unexpected) model turn happened to produce.
+    process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "paid-after-1h";
+    fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 61 * 60_000));
+    assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
+    const runner = async () => ({
+        stdout: probeStreamFixture(new Date(NOW_MS).toISOString(), 0.0007),
+        exitCode: 0,
+        timedOut: false,
+        spawnError: null,
+    });
+    const result = await runClaudeCapacityProbe(NOW_MS, { runner });
+    assert.equal(result.ok, false);
+    assert.equal(result.failureKind, "unexpected_cost");
+    assert.equal(result.costUsd, 0.0007);
+    assert.deepEqual(result.windowsUpdated, []);
+    // Last-good rows from before the rejected run are untouched.
+    const rows = listCapacitySnapshots("claude_code");
+    assert.equal(rows.find((r) => r.providerBucket === "five_hour").remainingPercent, 83);
+});
+test("probe rejects and ingests nothing when cost cannot be verified as zero", async () => {
+    // Reviewer-requested hardening, round 2 (PR #165): a stream with the
+    // local-command marker and well-formed windows, but a `result` event that
+    // omits `total_cost_usd` (costUsd === null), must fail closed exactly like
+    // a confirmed positive charge — null is not evidence of zero cost.
+    process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "paid-after-1h";
+    fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 61 * 60_000));
+    assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
+    const runner = async () => ({
+        stdout: [
+            JSON.stringify({
+                type: "assistant",
+                timestamp: new Date(NOW_MS).toISOString(),
+                local_command_run: { command: "usage", args: "" },
+                usage_report: {
+                    rate_limits: {
+                        limits: [
+                            { kind: "session", percent: 20, resets_at: new Date(FIVE_HOUR_RESET_SEC * 1000).toISOString() },
+                            { kind: "weekly_all", percent: 40, resets_at: new Date(SEVEN_DAY_RESET_SEC * 1000).toISOString() },
+                        ],
+                    },
+                },
+            }),
+            // No `result` event at all — total_cost_usd is unknowable.
+        ].join("\n"),
+        exitCode: 0,
+        timedOut: false,
+        spawnError: null,
+    });
+    const result = await runClaudeCapacityProbe(NOW_MS, { runner });
+    assert.equal(result.ok, false);
+    assert.equal(result.failureKind, "unexpected_cost");
+    assert.equal(result.costUsd, null);
+    assert.deepEqual(result.windowsUpdated, []);
+    const rows = listCapacitySnapshots("claude_code");
+    assert.equal(rows.find((r) => r.providerBucket === "five_hour").remainingPercent, 83);
+});
+test("probe rejects and ingests nothing when the local-command marker is absent", async () => {
+    // Reviewer-requested hardening (PR #165): a stream that never shows
+    // `/usage` resolving locally must not be trusted, even if it happens to
+    // carry a well-formed usage_report (e.g. a different CLI build echoing it
+    // from a real turn) or a fresh cache-file side effect.
+    process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "paid-after-1h";
+    fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 61 * 60_000));
+    assert.equal(ingestClaudeLocalCache(NOW_MS), 2);
+    const runner = async () => {
+        fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS + 5_000));
+        return {
+            stdout: [
+                JSON.stringify({
+                    type: "assistant",
+                    timestamp: new Date(NOW_MS).toISOString(),
+                    usage_report: {
+                        rate_limits: { limits: [{ kind: "session", percent: 20, resets_at: null }] },
+                    },
+                }),
+                JSON.stringify({ type: "result", is_error: false, total_cost_usd: 0 }),
+            ].join("\n"),
+            exitCode: 0,
+            timedOut: false,
+            spawnError: null,
+        };
+    };
+    const result = await runClaudeCapacityProbe(NOW_MS, { runner });
+    assert.equal(result.ok, false);
+    assert.equal(result.failureKind, "not_local_command");
+    assert.deepEqual(result.windowsUpdated, []);
+    const rows = listCapacitySnapshots("claude_code");
+    assert.equal(rows.find((r) => r.providerBucket === "five_hour").remainingPercent, 83);
+});
+test("probe success via the cache side effect when usage_report carries no windows", async () => {
     process.env[CLAUDE_CAPACITY_REFRESH_ENV] = "paid-after-1h";
     fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS - 61 * 60_000));
-    // The stream is empty but the probe run itself refreshes Claude's own
-    // cache file — the re-read must count as success.
+    // The local-command marker is present (so the run is trusted) and cost is
+    // $0, but usage_report carries no usable limits[] — the cache re-read
+    // (the probe run itself refreshes Claude's own cache file) still counts
+    // as corroborating success.
     const runner = async () => {
         // A real probe refreshes Claude's own cache file while it runs, so the
         // new `fetchedAtMs` is later than the pre-spawn `NOW_MS` stamp — the
         // post-spawn re-read must accept it, not reject it as future.
         fs.writeFileSync(cacheFile, fullCacheFixture(NOW_MS + 5_000));
-        return { stdout: "", exitCode: 0, timedOut: false, spawnError: null };
+        return {
+            stdout: [
+                JSON.stringify({
+                    type: "assistant",
+                    timestamp: new Date(NOW_MS).toISOString(),
+                    local_command_run: { command: "usage", args: "" },
+                }),
+                JSON.stringify({ type: "result", is_error: false, total_cost_usd: 0 }),
+            ].join("\n"),
+            exitCode: 0,
+            timedOut: false,
+            spawnError: null,
+        };
     };
     const result = await runClaudeCapacityProbe(NOW_MS, { runner });
     assert.equal(result.ok, true);
@@ -408,7 +705,9 @@ test("probe failure preserves last-good rows and enters bounded backoff", async
     const first = await maybeProbeClaudeCapacity(NOW_MS, { runner: failing });
     assert.equal(first.probed, true);
     assert.equal(first.ok, false);
-    assert.equal(first.failureKind, "nonzero_exit");
+    // Unparsable stdout ("not-json") means no local-command marker is found —
+    // that check runs before the nonzero-exit fallback.
+    assert.equal(first.failureKind, "not_local_command");
     // Last-good rows are untouched by the failed probe (0.17 used → 83 left).
     const rows = listCapacitySnapshots("claude_code");
     assert.equal(rows.find((r) => r.providerBucket === "five_hour").remainingPercent, 83);
@@ -416,10 +715,10 @@ test("probe failure preserves last-good rows and enters bounded backoff", async
     const second = await maybeProbeClaudeCapacity(NOW_MS + 60_000, { runner: failing });
     assert.deepEqual(second, { probed: false, reason: "backoff" });
     assert.equal(calls, 1);
-    // Exponential backoff: one failure doubles the 60-minute cooldown.
-    const during = await maybeProbeClaudeCapacity(NOW_MS + 61 * 60_000, { runner: failing });
+    // Exponential backoff: one failure doubles the 14-minute cooldown (28m).
+    const during = await maybeProbeClaudeCapacity(NOW_MS + 15 * 60_000, { runner: failing });
     assert.deepEqual(during, { probed: false, reason: "backoff" });
-    const after = await maybeProbeClaudeCapacity(NOW_MS + 121 * 60_000, { runner: failing });
+    const after = await maybeProbeClaudeCapacity(NOW_MS + 29 * 60_000, { runner: failing });
     assert.equal(after.probed, true);
     assert.equal(calls, 2);
 });