🐢 and 🐇 in My Claude Code Status Line: Now Watching Fable

A developer extended their Claude Code status line to track per-model weekly quota buckets after discovering that the tool's built-in 7-day indicator only reflects the all-models limit, allowing Fable usage to hit 100% while the display showed 47%. The updated setup uses two scripts — statusline.sh and a new usage-fetch.sh — that poll Anthropic's undocumented OAuth usage endpoint every five minutes and cache per-model percentages for display, after the developer incurred roughly $200 in extra usage charges.

My Claude Code status line races a tortoise against a hare to show whether I'm burning quota faster than a steady pace. Last time https://dev.to/suruseas/and-in-my-claude-code-status-line-now-watching-the-week-1m1e I switched the main bar to the 7-day window. I'd kept Fable away from long-running agents — it goes through tokens fast. Then Fable 5.1 landed. The announcement https://www.anthropic.com/claude-fable-and-mythos-5-1 said it's "more comfortable with long, unattended work than Fable 5," and estimated it would cost about 25% less than Fable 5 for typical workloads — up to about 45% less for highly agentic work. I wanted to see how it would hold up, so I left agents running on it. The status line said the week was fine, and I found out afterwards that I'd gone through Fable's own weekly limit and into extra usage — about $200 of it. I hadn't known that Fable's weekly limit could also be extended with extra usage. The status line wasn't wrong. It was watching the wrong bucket. Besides the all-models 7-day window, there are per-model weekly limits. /usage shows them, but the status line payload doesn't carry them: rate limits.seven day is the all-models bucket, even while you're on Fable. So 7d:47% can look perfectly relaxed while Fable is at 100%. Now the line looks like this: Opus 5 ·········🐇🐢········· 7d all :47%@9/16 | ·🐇·🐢······ 5h:15%@14:50 | Fable 7d:87% ⚠️ 7d all — renamed from 7d , so it's obvious it's not model-specific. Fable 7d:87% ⚠️ — the per-model weekly bucket. Which per-model buckets get shown: Fable 7d:… . ⚠️ on a per-model segment uses the same tortoise rule as the bars: usage percentage elapsed fraction of the window. Unlike the bars, it's suppressed below 25%, so a fresh window doesn't flag on the first few messages. 📦 The full code is in this gist https://gist.github.com/suruseas/49ba6edfb2b8daf94cde32fd2a6b59c0 — both scripts, the settings snippet, and a README. The sections below walk through it. The per-model numbers come from https://api.anthropic.com/api/oauth/usage — the endpoint /usage reads — authenticated with the Claude Code OAuth token. It's undocumented, so use this at your own risk. More on that at the end. This version is two scripts instead of one. Both live in ~/.claude/ : ~/.claude/ ├── settings.json statusLine points at statusline.sh only ├── statusline.sh updated — draws the line, starts usage-fetch.sh ├── usage-fetch.sh new — calls the usage endpoint, writes the cache └── usage-cache.json written by usage-fetch.sh, read by statusline.sh settings.json only knows about statusline.sh . You never run usage-fetch.sh yourself — statusline.sh starts it in the background at most once every 5 minutes, and reads whatever it last cached: on every render : Claude Code → statusline.sh → reads usage-cache.json → prints the line every 5 minutes : statusline.sh → starts usage-fetch.sh in the background in background : usage-fetch.sh → calls the usage endpoint → writes usage-cache.json The relevant part of the response: { "limits": { "kind": "weekly scoped", "scope": { "model": { "display name": "Fable" } }, "percent": 0.87, "resets at": "2026-09-16T09:00:00.126747+00:00" } } The script keeps only the per-model weekly buckets and caches them: {"fetched at":1789266899,"buckets": {"name":"Fable","pct":87,"resets at":1789549199} } bash /bin/bash Fetch per-model weekly quota buckets and cache them for statusline.sh. set -u CACHE=~/.claude/usage-cache.json LOCK=~/.claude/.usage-fetch.lock ATTEMPT=~/.claude/.usage-fetch-attempt Single flight. A lock older than 2min is stale killed mid-fetch . if -d "$LOCK" ; then -n "$ find "$LOCK" -maxdepth 0 -mmin +2 2 /dev/null " && rmdir "$LOCK" 2 /dev/null fi mkdir "$LOCK" 2 /dev/null || exit 0 trap 'rmdir "$LOCK" 2 /dev/null' EXIT Record the attempt first, so a failing fetch backs off like a successful one instead of re-firing on every render. date +%s "$ATTEMPT" OAuth token: keychain on macOS, credentials file elsewhere. Never written out. TOKEN=$ security find-generic-password -s "Claude Code-credentials" -w 2 /dev/null \ | jq -r '.claudeAiOauth.accessToken // .accessToken // .access token // empty' 2 /dev/null -n "${TOKEN:-}" || TOKEN=$ jq -r '.claudeAiOauth.accessToken // .accessToken // .access token // empty' \ ~/.claude/.credentials.json 2 /dev/null -n "${TOKEN:-}" || exit 0 RESP=$ curl -sS --max-time 8 https://api.anthropic.com/api/oauth/usage \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -H "anthropic-beta: oauth-2025-04-20" 2 /dev/null unset TOKEN -n "$RESP" || exit 0 Keep only the weekly per-model windows. percent comes back as a 0-1 fraction, but tolerate a real percentage in case that ever changes. OUT=$ printf '%s' "$RESP" | jq -c --argjson now "$ date +%s " ' resets at arrives as "2026-09-16T09:00:00.126747+00:00" - fractional seconds and an offset, neither of which jq fromdate accepts. def iso2epoch: if type = "string" then null else capture "^ ?<b \\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2} \\.\\d+ ? ?<tz Z| +- \\d{2}:\\d{2} ?$" as $c | if $c == null then null else $c.b + "Z" | fromdateiso8601 as $t | $c.tz // "Z" as $tz | if $tz == "Z" then $t else $tz 1:3 | tonumber 3600 + $tz 4:6 | tonumber 60 as $off | if $tz 0:1 == "+" then $t - $off else $t + $off end end end end; {fetched at: $now, buckets: .limits // | select .kind == "weekly scoped" and .scope.model.display name | type == "string" | {name: .scope.model.display name, pct: if .percent // 0 <= 1 then .percent // 0 100 else .percent end , resets at: .resets at | iso2epoch } } | select .buckets | length 0 ' 2 /dev/null -n "$OUT" || exit 0 umask 077 printf '%s\n' "$OUT" "$CACHE".tmp && mv -f "$CACHE".tmp "$CACHE" A few details: ~/.claude/.credentials.json on other platforms , passed to curl , and unset. Only percentages and reset times are written to disk, with umask 077 . mkdir as a lock. resets at needs a hand-rolled parser. fromdateiso8601 rejects both the fractional seconds and the +00:00 offset. tmp + mv statusline.sh never reads a half-written file. Everything up to the 5h bar is the same as the previous post. New is the block at the end and the 7d all label: bash /bin/bash input=$ cat MODEL=$ echo "$input" | jq -r '.model.display name' FIVE H PCT=$ echo "$input" | jq -r ' .rate limits.five hour.used percentage // 0 ' SEVEN D PCT=$ echo "$input" | jq -r ' .rate limits.seven day.used percentage // 0 ' FIVE H RESETS=$ echo "$input" | jq -r '.rate limits.five hour.resets at // empty' SEVEN D RESETS=$ echo "$input" | jq -r '.rate limits.seven day.resets at // empty' NOW=$ date +%s TZ=Asia/Tokyo change to your local timezone W7=20; W5=10 bar widths: 7d full, 5h half make bar { local actual=$1 ideal=$2 width=$3 bar="" i for i in $ seq 0 $ width - 1 ; do if "$i" -eq "$ideal" && "$i" -eq "$actual" ; then bar="${bar}🐢🐇" elif "$i" -eq "$ideal" ; then bar="${bar}🐢" elif "$i" -eq "$actual" ; then bar="${bar}🐇" else bar="${bar}·" fi done "$actual" -ge "$width" && bar="${bar}🐇" echo "$bar" } 7-day window main bar, width=20 if -n "$SEVEN D RESETS" ; then REMAINING 7D=$ SEVEN D RESETS - NOW RESET 7D MD=$ date -r "$SEVEN D RESETS" "+%m/%d" | awk -F/ '{printf "%d/%d", $1, $2}' RESET 7D TAG="@${RESET 7D MD}" if "$REMAINING 7D" -gt 0 && "$REMAINING 7D" -lt 604800 ; then IDEAL 7D=$ 604800 - REMAINING 7D W7 / 604800 else IDEAL 7D=0 fi else IDEAL 7D=0; RESET 7D TAG="@?" fi ACTUAL 7D=$ awk "BEGIN {print int $SEVEN D PCT $W7 / 100 }" BAR 7D=$ make bar "$ACTUAL 7D" "$IDEAL 7D" "$W7" "$ACTUAL 7D" -gt "$IDEAL 7D" && WARN 7D=" ⚠️" || WARN 7D="" SEVEN D DISP=$ printf "%.0f" "$SEVEN D PCT" 5-hour window half bar, width=10 if -n "$FIVE H RESETS" ; then REMAINING 5H=$ FIVE H RESETS - NOW RESET 5H JST=$ date -r "$FIVE H RESETS" "+%H:%M" RESET 5H TAG="@${RESET 5H JST}" if "$REMAINING 5H" -gt 0 && "$REMAINING 5H" -lt 18000 ; then IDEAL 5H=$ 18000 - REMAINING 5H W5 / 18000 else IDEAL 5H=0 fi else IDEAL 5H=0; RESET 5H TAG="@?" fi ACTUAL 5H=$ awk "BEGIN {print int $FIVE H PCT $W5 / 100 }" BAR 5H=$ make bar "$ACTUAL 5H" "$IDEAL 5H" "$W5" "$ACTUAL 5H" -gt "$IDEAL 5H" && WARN 5H=" ⚠️" || WARN 5H="" FIVE H DISP=$ printf "%.0f" "$FIVE H PCT" Per-model weekly windows. Not in the payload - seven day is the all-models bucket even while on Fable - so a detached helper caches them from the same endpoint /usage reads. Rendering never waits on it and stays silent on failure. USAGE CACHE=~/.claude/usage-cache.json USAGE ATTEMPT=~/.claude/.usage-fetch-attempt LAST ATTEMPT=$ cat "$USAGE ATTEMPT" 2 /dev/null || echo 0 if $ NOW - LAST ATTEMPT -ge 300 ; then nohup ~/.claude/usage-fetch.sh /dev/null 2 &1 & 2 /dev/null fi Current model's own weekly bucket, plus any other bucket already past pace. SCOPED=$ jq -r --arg model "$MODEL" --argjson now "$NOW" ' def pace $b : if $b.resets at // 0 $now and $b.resets at - $now < 604800 then 604800 - $b.resets at - $now 100 / 604800 else 100 end; def seg $b : " | \ $b.name 7d:\ $b.pct | round %" + if $b.pct pace $b and $b.pct = 25 then " \u26a0\ufe0f" else "" end ; .buckets // as $bs | $model | ascii downcase as $m | $bs | map select .name as $n | $m | startswith $n | ascii downcase | first as $mine | if $mine then seg $mine else "" end + $bs | map select .name = $mine.name // "" and .pct pace . and .pct = 25 | map seg . | join "" ' "$USAGE CACHE" 2 /dev/null || SCOPED="" echo " ${MODEL} ${BAR 7D} 7d all :${SEVEN D DISP}%${WARN 7D}${RESET 7D TAG} | ${BAR 5H} 5h:${FIVE H DISP}%${WARN 5H}${RESET 5H TAG}${SCOPED}" Notes on the new block: nohup … & in a subshell Fable 5.1 , the bucket is named Fable ; startswith on lowercased names connects them. pace is the tortoise in percent SCOPED is empty and the line looks exactly like the previous version. The scripts are written for macOS: the token is read from the keychain with security , and statusline.sh uses BSD date -r <epoch on Linux, use date -d @<epoch . They also need jq and curl . Put both scripts in ~/.claude/ and make them executable: chmod +x ~/.claude/statusline.sh ~/.claude/usage-fetch.sh In settings.json , the status line still points only at statusline.sh . Add refreshInterval why is explained below : { "statusLine": { "type": "command", "command": "~/.claude/statusline.sh", "refreshInterval": 60 } } This is not a documented API. It's what Claude Code itself calls, it can change without notice, and it isn't clear whether calling it from your own script is an intended use. The script fails silently, so if the endpoint changes or stops answering, the rest of the status line keeps working. Claude Code doesn't run the status line command on a timer. It runs it on events: at session start, whenever a new assistant message arrives, after /compact , when the permission mode changes, and a few others docs https://code.claude.com/docs/en/statusline . Updates are debounced at 300ms, and if a new update comes in while the script is still running, the running one is cancelled. While an agent is working, that means a render for every message — far too often for an HTTP request. That's why the fetch is a separate script behind the 5-minute check, launched detached so it isn't killed when the next render cancels statusline.sh . A new value shows up on the render after the fetch finishes. Without refreshInterval , there's one request to the usage endpoint roughly every 5 minutes while agents are producing messages, and none when no messages are arriving. The attempt timestamp and the lock are files under ~/.claude/ , so the 5-minute gap is shared across all your Claude Code sessions, not per session. The catch is the idle case. When the main session is idle — say, waiting on background subagents — the event triggers go quiet, and the Fable number stops updating while the subagents keep burning it. That's why the setup adds refreshInterval : it re-runs the command every N seconds on top of the events, so with 60 the line re-renders every minute. The trade-off is that the request now also happens while you're idle — still at most once every 5 minutes, as long as a Claude Code session is open.