← Back to Blog

claude --resume Used 7% of My 5-Hour Limit (Measured)

November 16, 2026 · 6 min read

Claude Code subscriptions have two limits: a 5-hour window and a weekly limit, both shown as a percentage used. Everyone says resuming a cold session is expensive. I wanted to know how expensive in the units that actually lock you out, so I resumed two idle sessions one at a time and logged both meters and the token counts of every request.

Result: each cold resume took 5–7% of my 5-hour limit and 1% of my weekly limit. Both sessions were Opus 5.5 with 170–210k tokens of context. In both, the first two requests after the resume each wrote the whole conversation to the cache, so the second write was about half of the cost.

Setup

Session A: 210k tokens, idle 2.5 days

Last request on November 13. I resumed it at 15:32 and sent one message. When it started a tool call I pressed Esc, and it replied once more.

RequestTimeWritten to cacheRead from cacheOutput5-hourWeekly
1. Reply to my message15:32:26209,269050812% → 16%42% → 43%
2. Reply after Esc15:35:02190,98924,8807017% → 21%43%

The meter moved 12% → 21%. Leaving out the measuring session, Session A's own requests account for about 7 points of the 5-hour limit, and the weekly limit moved 1 point.

Session B: 183k tokens, idle 12 days

Last request on November 4. My first message was stopped by L2Cache's cold-resume guard ("stopped this message so it doesn't reload 183k tokens"). No request was sent, so that cost nothing. I sent it again at 15:38:12. The model replied and kept working, so requests 2 and 3 came 10 and 16 seconds after the first.

RequestTimeWritten to cacheRead from cacheOutput5-hourWeekly
115:38:41143,58125,10328921% → 24%43% → 44%
215:38:51146,68824,88016124% → 27%44%
315:38:571,283171,56828427% → 28%44%
Next 8 requeststo 15:40:5913,187 total1,777,660 total3,56428% → 29%44%

The two cache writes took the 5-hour meter from 21% to 27%: about 5 points once the measuring session is left out. The weekly limit moved 1 point. The next eight requests, all reading the warm cache, cost about 2 points together.

The second write

In both sessions the second request read only about 25k tokens from cache, which is the system prompt and tool definitions, and wrote the conversation again. In Session B that happened 10 seconds after the first write, with no Esc involved. The transcript doesn't record why. From the third request on, reads covered the full context as normal.

What one point is worth

Anthropic doesn't publish how the plan meters weight tokens. If I weight them by Opus API price ratios (input 1×, 1-hour cache write 2×, cache read 0.1×, output 5×), every request in the run comes to about 1.92 million input-token equivalents, and the 5-hour meter moved 17 points:

SourceInput-token equivalentsShare of 5-hour points
Session A (2 requests)805,898~7
Session B (11 requests)830,917~7 (5 from the two writes)
Measuring session281,974~2.5
Total1,918,78917

Limits of this test

Measure your own

You need a statusline script that logs the meters, and the session transcript. Neither needs L2Cache.

1. Log the meters. Point statusLine in ~/.claude/settings.json at this script (needs jq):

#!/bin/bash
input=$(cat)
line=$(echo "$input" | jq -r '[.rate_limits.five_hour.used_percentage,
  .rate_limits.seven_day.used_percentage] | @tsv')
if [ "$line" != "$(cat ~/.claude/usage-last 2>/dev/null)" ]; then
  printf '%s\t%s\n' "$(date +%T)" "$line" >> ~/.claude/usage-log.tsv
  printf '%s' "$line" > ~/.claude/usage-last
fi
echo "5h ${line%%$'\t'*}%"

2. Read the transcript. Sessions live in ~/.claude/projects/<project>/<session-id>.jsonl. This prints each request after a UTC timestamp:

import json, sys
seen = set()
for line in open(sys.argv[1]):
    d = json.loads(line)
    m = d.get("message") or {}
    u = m.get("usage") if isinstance(m, dict) else None
    if not u or m.get("id") in seen or d.get("timestamp", "") < sys.argv[2]:
        continue
    seen.add(m["id"])
    print(d["timestamp"][11:19], "write", u.get("cache_creation_input_tokens"),
          "read", u.get("cache_read_input_tokens"), "out", u.get("output_tokens"))

Run it as python3 usage.py <session>.jsonl 2026-11-16T04:30. Then resume a session that has been idle longer than its cache lifetime, send a short message, and compare the two logs. Keep everything else idle while you do it.

How L2Cache helps

L2Cache reads your Claude Code session files and the same statusline data on your Mac, so it can step in at each point where this test spent the limit. Nothing is sent anywhere.

1. See which sessions are cold before you resume

The first step is knowing what a session will cost before you open it. Developer Home in L2Cache has a Pick up where you left off card for each recent session, showing its context size and cache state:

Next to it, the card compares the current session with a fresh start plus a handoff, so you can pick before spending anything. In the example below, 254k tokens against an estimated 52k starting context.

L2Cache pickup card in Developer Home: current session 254k tokens with 57 minutes of cache left, versus 52k starting context for a fresh session with a handoff
A pickup card for a 254k session with 57 minutes of cache left, next to what a fresh start with a handoff would cost.

2. Get warned at each step after that

Cold cache at 14:05 — this session's cache expired 3 h ago.
Your next message reloads 183k tokens (≈ 40× a warm turn).
Cheaper: type /clear — L2Cache starts a fresh session with this session's handoff.
Or just send your message to continue as is.

What I do now

See the cost before you resume

L2Cache shows each session's size, cache state and live plan limits, and stops a cold reload before it happens.

Download L2Cache for Mac