augiefra/claude-mods
augiefra/claude-mods has 28 GitHub stars and 7 forks. GitHot measured 0 stars in 24 hours. Last checked 2026-11-16 19:10 UTC. Last push 2026-11-14.
Measured star growth
- in 24h
- 0
- in 7 days
- Collecting history
- in 15 days
- Collecting history
- in 1 month
- Collecting history
Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.
About
Claude Code mod: context in tokens, 5-hour and weekly limits vs. the clock, prompt cache countdown, session cost and running agents, in one band above the prompt.
Developer ToolsREADME.md
Originalclaude-mods
Claude Code mods by Eric Cologni.
token-weather-usage
Stop hitting your Claude limit by surprise. One band above the prompt shows how big your context is, your 5-hour and weekly limits against the clock (with a warning when the week's pace would run out before the reset), whether the prompt cache is still warm (and when a /model switch is about to rewrite it), what the session and the last prompt cost, which agents are running, and, when Claude asks for your go-ahead, one click to give it.

Five situations
All clear. Small context, both limits behind the clock, the cache warm for almost an hour.

Agents at work. Three subagents running (hover their pill for their tasks); the 5-hour limit runs a little ahead of time, so its gauge turns yellow.

Cache about to lapse. Seven minutes left: send the next message now, or the whole 604k context gets written again at full price.

Slow down. Context near full, the 5-hour limit far ahead of time, the cache expired: /compact before going on.

Weekly limit alone. On a plan without a 5-hour window, the band says what a day may use and where the week ends at its pace.

Switching models mid-thread
A prompt cache belongs to one model. Switch with /model in the middle of a long thread, and the next message reads nothing from the cache: it writes the whole context again, at the new model's price. On a 400k context that is several dollars for one message.
The cache pill says so as soon as you switch, before you send anything:

- Amber "model changed", with what the next message would write again and its cost at the new model's price.
- Hover for the way back: return to the model before while its cache is warm, and it serves again. Going on with the new model pays the rewrite once; the pill then counts down the new cache.
- The cheap moment to switch is a cut: a new thread, or right after
/compact, when the context is small.
What each pill says
| Pill | What it shows | Warns you when |
|---|---|---|
| Context | Tokens in the context, the last 5 prompts as bars | The weather turns from Clear to "Compact soon" |
| 5h / 7d | Share of each limit used, time left | Yellow when you run ahead of the clock, red when far ahead or past 90% |
| Day budget | On a plan with the weekly limit alone: what a day may use until the reset | Never: it just counts |
| Run-out | When this week's pace would hit the 7-day limit | Amber "⚠ out Sun night", red within a day |
| Cache | Minutes before the prompt cache lapses | Yellow under 10 min, red once expired, with what it will cost |
| Cost | What the session cost, and the last prompt | Never: it just counts |
| Agents | Subagents running and run so far | Never: it just counts |
| GO | The approvals Claude's last answer asks for, with an OK to give them all | Shows only when there are some |
In the app, hover any pill for its details.
Context
- A weather icon from Clear to "Compact soon", then the tokens in the context.
- One bar per prompt for the last 5, as tall as the tokens it added; the current one in color.
- The last prompt's change ("▲ +6.3k").
- Hover: the weather and the share of the window.
5h / 7d
- The share of your account's limits already used, then the time left.
- The hatched part is the gap with the time elapsed: grey after the bar while you have margin, in the bar's color when you use faster than time passes.

More detail
- Green while usage does not run ahead of time, yellow beyond, red when more than 15 points ahead or past 90%.
- The 5-hour reset time (machine's time zone) is in the pill's hover card in the app, left out in the terminal.
- A window that already reset is hidden until the next reading.
- The latest reading is shared across the sessions open on the machine.
Weekly limit alone
On a plan without a 5-hour window, the band uses the room for the week. The mod tells the plan by the limits the account reports: with a 5-hour limit the band stays as above.

- A day pill takes the 5-hour pill's place: what is left of the 7-day limit over the days left ("15% a day"). Hover: what is left, until when, and what today used so far ("Today so far: +6%").
- The 7d pill says where the week ends at its pace so far ("→ 64% Mon") in place of the time left, which moves to the hover card. From the week's second day; when the pace would run out before the reset, the run-out warning below shows instead.
- The 7d bar is twice as long in the app, in the room the 5-hour pill left.
- In the terminal both sit on the line:
15%/day │ 7d ━━──── 26% · 5d00h → 91% Wed.
Run-out warning
- Appears on the 7d pill when the week's pace would use up the limit before it resets: "⚠ out Sun night" in the terminal; in the app, a shorter "⚠ Sun pm" takes the place of the time left (the reset date stays in the hover card).
- Amber, red within a day.
- Hover: the exact time and the last day's pace, to tell whether you are speeding up or slowing down.
At this week's pace (+62% in 3d23h), the 7-day limit runs out Sun night around 00:42, before the reset on Mon 19/10.
Workdays only
If you leave Claude Code alone at the weekend, the full 7-day clock makes your weekdays look too fast. Turn on the Weekly pace on workdays option (/config): the mod then counts Monday to Friday only (your machine's time zone) for the 7d bar's pace, where the week ends, the run-out warning and the day budget. The weekend no longer counts as time you could have used, and a run-out falls on the next workdays. Off by default.
More detail
- The pace is the share used since the week started over the time elapsed: the same projection as Claude's usage page.
- Hours after midnight belong to the night before ("nuit de dim. à lun." in French).
- Shown from the week's second day and 15% used; hidden when the terminal line is too narrow for details.
Cache
- The time before the prompt cache lapses: behind a bolt in the app, the word "cache" in the terminal.
- Each message restarts the clock: 1 hour on a Claude subscription, 5 minutes on an API key.
- Under 10 minutes (yellow): what is at stake ("$2.32 at stake"), the whole context written again if it lapses.
- Expired (red): what the next message writes again and its cost ("741k to rewrite ≈ $5.93").
- Missed: a message had to write the cache again; shows the cause (model changed, lapsed, start changed) and the extra cost ("+$2.10").
- Model changed (amber): after
/model, a cache does not follow to another model. The pill says so before you send, with what the next message writes again at the new model's price ("412k to rewrite ≈ $6.59"). See Switching models mid-thread.

- The way out, from 100k tokens:
/compactup to 300k, a new thread beyond.
More detail
- When the last message read less than 90% of its prompt from the cache, that share comes first ("cache 64% · 52 min").
- Mods get the token counts but not the lifetime, so the mod follows Claude Code's rules and corrects itself from what the traffic shows.
- Why a new thread beyond 300k: the next message would rewrite the whole context at full price, which a new thread avoids and a compaction would only read again. The terminal keeps the advice on the line ("· /compact", "· new thread"); the app puts it in the hover card.
- Hover: the expiry time, the share of the last message read from the cache, what the context costs read from the cache against written again, and what the cache saved in this thread.
- Prices: Anthropic's list prices dated 2026-11-09 (input, cache read, cache writes at 1.25× input for 5 minutes or 2× for 1 hour). On a subscription they are API-price equivalents, hence the "≈". A model missing from the price table shows tokens only.
- A compaction updates the band at once: the context drops to its new size, and the cache reads "compacted" until the next message writes a new one (not counted as a miss).
Cost
- What the session cost, as
/costtotals it (cents dropped from $100; in the app, whole dollars on the pill and the cents in its hover card). - What the last prompt added, subagents included, in dollars and in points of the 5-hour limit ("+$1.07 · +2.5% 5h").
- The app keeps the total in the pill and the last prompt in its hover card; the terminal writes both on the line.
More detail
- The 5-hour limit is the account's: other sessions running at the same time count in it.
- On a subscription the dollars are the API-price equivalent, not a bill, hence the "≈".
Agents
- How many subagents the thread ran ("2 running · 7" while some run).
- Hover: the cost split between the main thread and each model's agents, the agents still running with their latest tool, the last batch, and what delegating saved ("Delegating: ≈ $8.40 saved compared with Opus 5.5").
More detail
- For each model's agents: their cost, effort levels and tokens. Running agents show the name of their latest tool, never its arguments. The last batch: how long it took, how much ran in parallel, its tool calls and cost.
- Each subagent request is counted as it comes back, at list prices (output at 5× input, 5-minute cache writes assumed, Haiku 5.5 by prompt size); the main thread's share is the session cost less its agents'.
- The terminal shows the count once the thread has run one.
- Background shell commands are not counted (Claude Code does not expose them to mods).
- A workflow's agents (the Workflow tool) are not shown: Claude Code does not list them, and telling them apart from its own internal agents would take a hook on agent spawns, which the plugin directory does not accept. Their cost still counts in each model's line.
- The mod reads all this from the agents' responses: it never hooks a tool call, so it can neither slow one down nor stand in its way.
GO pill
Approve what Claude asks for in one click. When Claude stops to ask for your go-ahead (commit, push, publish, send…) and writes each approval as a quoted phrase starting with GO, a green pill ends the band: a double check, how many, and OK. Hover it to read them; click OK and the mod sends them back as your own message, each one quoted, so the thread records exactly what you approved, and nothing more.

Make Claude write its approvals this way. Add a line like this to your CLAUDE.md (global or per project):
When a step needs my go-ahead (commit, push, publish, deploy, send), end your answer with the exact approval to give, quoted and starting with GO: “GO push v1.2 to origin main”. Never quote a GO you are not asking for.
- Recognized: “GO …”, "GO …", « GO … » and
`GO …`. Outside French quotes, GO must be in capitals, sogo testin code never counts. - Nothing is sent until you click OK. The pill goes away with your next message, and a subagent's answer never fills it.
- The message follows the mod's language: “You have my approval for all the GOs: …” in English, French or Russian.
- Off in the GO pill option (
/config). In the terminal it is a plain button,✓✓ 2 GO.
App and terminal
In the desktop app each block is a tinted pill with its icon. A pill never shrinks; when the window is too narrow, the pills wrap onto a second line. In the terminal the same blocks sit on one line, split by a thin rule:
☂ 634k ▃▄▂█▆ ▲ +6.3k │ 5h ━━━━╍─ 74% · 24 min │ 7d ━━━━── 65% · 2d20h │ cache 52 min │ ≈ $41.07 (+$0.58 · +1.5% 5h) │ 2 agents
When the line does not fit the terminal, the bars, details and cost drop out, leaving labels and percentages.
Language
Labels are in English, French or Russian. By default (auto) the mod follows LC_ALL, LC_MESSAGES or LANG and falls back to English. The desktop app often sets none of them: pick en, fr or ru in the plugin's Language option in /config.
Install
/plugin marketplace add augiefra/claude-mods
/plugin install token-weather-usage@augiefra-mods
/reload-plugins
Install from this repository: it always has the latest version. The Claude plugin directory no longer accepts plugins that include a mod, so the copy still listed there is an old version (3.10.7) that will not be updated.
If the line does not show up, restart Claude Code. A mod is code that runs inside Claude Code with the same access as Claude Code: read it before installing. This one is a single file, token-weather-usage.mjs.
Check
claude plugin validate ./plugins/token-weather-usage
claude plugin test ./plugins/token-weather-usage
Privacy
token-weather-usage collects, sends and retains no personal data. It only reads the usage figures Claude Code provides (context fill, 5-hour and 7-day limits, session cost, the session's model, each request's cache token counts), the list of the session's subagents and the names of the tools their responses ask for (never the arguments; shown in the agents card, kept in memory only and never stored), the text of Claude's final answer in the main thread, to find the quoted GO approvals (kept in memory only, until your next message), the locale variables above and the prompt-cache switches (DISABLE_PROMPT_CACHING, FORCE_PROMPT_CACHING_5M, CLAUDE_CODE_PROMPT_CACHE_TTL, ENABLE_PROMPT_CACHING_1H). It reads no file and hooks no tool call. It sends a message only when you click the GO pill's OK, and that message is only the approvals it showed you. It keeps in the plugin's local storage, on the machine, the latest limits reading, the 7-day share used every half hour over the last two days, and, per session, recent context readings, the last request's cache figures, what the cache saved in the session, the last prompt's cost and each subagent's model, effort, token counts and description (deleted after 8 idle days). No network requests.
What its hooks do. Every hook only reads and passes the event on unchanged (return next(e)): the mod never changes, delays or refuses anything; the one message it can send is the GO pill's, on your click. session.start and session.end start and stop its timers; turn.step reads each model response's token counts and the names of the tools it asks for; turn.complete reads the session's usage after each turn and the main thread's final answer for its GO approvals; session.measure reads new limits and cost readings; session.compact notes a compaction; ui.render draws the band above the prompt, with the GO pill at its end.
Credits
- The context weather, the tokens and the turns chart come from Anthropic's Token Weather example (claude-code-playground, Apache-2.0).
- The limit gauges are inspired by HolyGrail's usage-meter (HolyGrail/claude-mods). They were written for this mod after usage-meter (same idea: gauges with an elapsed-time marker, a reading shared across sessions), without copying its code.
- The cache block is inspired by Daniel San's prompt-cache-control (davila7/claude-code-templates, MIT). It was written for this mod after it (same idea: cache usage per request, an inferred lifetime, a countdown), without copying its code.
- The agents card's tool lines and last batch adapt code from Anji Xu's agentpane (xuanji86/claude-agentpane, MIT): its batch grouping, batch receipt and tool naming. Its license is reproduced in NOTICE.
License
Apache-2.0, see LICENSE and NOTICE.
By the same author
FacilAbo: 230+ calendars (public and school holidays, tax deadlines, sport) to subscribe to in one tap, on iPhone and Android. EuroVolt, your Linky electricity use in euros, is coming soon on iPhone.