Kiasi releases

Kiasi 0.9.0

2026-10-17T08:58:47Z

The dashboard's days bought back no longer overcount, the benchmark compares every cut with what Claude Code alone sends, and the README's before-and-after line says where the smaller context comes from. Details in the 0.9.0 changelog.

Highlights

An honest bought-back figure. A cut's avoided re-reads now stop at the session's next compaction, because after a compaction the cut output would not have been re-sent anyway. The days bought back, the Your month card, the weekly digest, the session receipt and the postmortem all used the old count. On one month of heavy use the figure drops from 9.3 days to 1.1.
A benchmark against Claude Code alone. Every scenario is measured against what Claude Code alone sends under its documented output limits, not against the raw output. Kiasi sends more on three of the nine scenarios, and the tables say so. A benchmark page at /benchmark/ renders the same data.
Before and after, attributed. The README gives the measured 232k → 108k tokens per step (2.1× less) instead of an unreproducible 201k → 31k (6.5×). It says that almost all of the drop comes from the 200k compaction window on a 1M-context model, and that Kiasi's own cuts keep out about 5%. docs/launch.md now leads with the measurement and the free setting.
A new website. The landing page is one scroll story with the Kiasi mark as the hero. It also has a releases page with an Atom feed, and a results section where users post their month cards through an issue form.

Bug fixes

Dashboard: days bought back and every figure built on them credited a cut on every later step of the session, past compactions. They now stop at the next compaction.
Out-of-context tools: two run, distill or fetch saves in the same second no longer overwrite each other. Saved file names end in six random hex characters, and cleanup still recognises the old names.

Upgrade notes

Update with /plugin marketplace update kiasi then /plugin update kiasi, or git pull in a local checkout, then restart Claude Code.
Expect the days bought back, the Your month card and the session receipts to drop at the next report build. That is the fix, not a regression. The context-per-request factor is measured before and after install and does not change.
No re-run of /kiasi:limits setup is needed; the status line is unchanged.

Known issues

Counting stops at every compaction, including a prune that kept the cut output, so the bought-back figure leans low.
Before and after is measured on your machine against the days before you installed. It is not a paired A/B on the same tasks, and nothing yet shows whether Claude finishes the same work with the smaller context.

Full changelog

Kiasi 0.8.0

2026-10-09T09:02:07Z

Install is now one command after the plugin, the Overview says what the re-reads Kiasi avoided are worth in dollars, and the README leads with the weekly limit and a comparison. Details in the 0.8.0 changelog.

Highlights

One-step install. /kiasi:limits setup now writes the two settings Kiasi needs, CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000 and CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1, into the env block of ~/.claude/settings.json along with the status line. Your other env keys stay, and the command says which settings it added. The session-start reminder for a missing setting names the command instead of a JSON snippet.
Worth in dollars. The Overview's Bought back line adds what the avoided re-reads would have cost at public API rates, priced at the cache-read rate of the models you used in the window, weighted by their reads. The tooltip shows the rate. On an API key it is money; on a flat plan it is what the limit would have spent.
A README that starts with the problem. The pain in bytes, Quick start first, four things it cuts, three benchmark rows, a comparison with RTK, Context Mode and the compaction window alone, and the rules with the turn-budget trade-off stated. Settings and development notes moved to docs/.
Launch copy. docs/launch.md has the Show HN post, the reply for weekly-limit threads and the awesome-list PR text, for anyone who wants to tell others.

Bug fixes

None in this release.

Upgrade notes

Update with /plugin marketplace update kiasi then /plugin update kiasi, or git pull in a local checkout, then restart Claude Code.
Run /kiasi:limits setup once after updating. It now writes the two env settings, so you can delete them from your own settings if you prefer the command to own them; it leaves them alone if they are already set.
The dollar line appears on the Overview at the next report build after restart. It is left out when no model in the window has a known price.

Known issues

The dollar figure is an estimate of what tokens that were never sent would have cost, at today's public rates; it is not read from a bill.
The comparison table describes RTK and Context Mode from their READMEs at the time of writing; open an issue if either has changed.

Full changelog

Kiasi 0.7.0

2026-10-09T06:38:38Z

The Overview now tells you what to cut next and whether your last cut worked, and a new /kiasi:floor skill finds what to trim from the startup floor. Details in the 0.7.0 changelog.

Highlights

One week on one axis. The Overview leads with the runway in a sentence, then the weekly limit as a cumulative burn line and the context sent per day on the same Monday-to-Sunday axis, so used, pace, run-out and the days that caused it line up. The forecast continues dashed to the run-out or the reset.
What to cut next, with trend. A tinted bar of what the context is made of, then three rows. Each row shows the change against the seven days before, names the biggest single piece behind it (the largest piece of your floor, the one file whose read cost most, the hook that attaches most) and opens its panel.
Startup floor and system reminders panels. The floor per project with its pieces and a per-day line that shows a settings change as a step. The reminders split by the hook or notice that attached them, with how often each fired.
**/kiasi:floor.** Audits the last 30 days for skills, MCP servers, agents and hooks that sessions were offered but never used, prints what each costs, and writes a fix script for you to read and run. scripts/once.py makes a prompt hook attach its text once per session instead of on every prompt.
Session receipt, weekly digest and month card. A desktop notification at session end with what the session sent and what it would have sent without Kiasi; a weekly digest at startup; and "Share your month" on the Overview as text or an SVG image.

Bug fixes

Overview chart: the now label no longer straddles the band's floor, the runs-out label no longer runs into the reset label, and the ledger rows stay on one line.
Panels: closing the Startup floor or System reminders panel clears it from the address, so a refresh no longer reopens it.
Rules: the breakdown column wrapped again after a shared class name leaked the Overview ledger's grid onto it.
Timestamps: event-log stamps (local time) and transcript stamps (UTC) are read through one parser, so a cut is no longer shifted against its session's steps by the local offset.

Upgrade notes

Update with /plugin marketplace update then /plugin update kiasi, or git pull in a local checkout. No settings change is needed.
The trend on each "What to cut next" row appears once the share history is a week old; before that the rows show no change figure.
The per-day floor line and the share history live in floor-history.json and share-history.json next to the other Kiasi data.
Run /kiasi:floor to get the audit and its fix script. The script backs every file up and only moves things the audit saw unused; read it before running it.

Known issues

The floor audit counts a skill or server as used only when a transcript in the window shows it; a tool you use rarely can be listed as unused. The fix script only moves such things to project scope, it deletes nothing.
Image files read with the Read tool count as file reads in the attribution.

Full changelog

Kiasi 0.6.0

2026-10-07T09:27:32Z

Rule outcomes on the dashboard, a holdout experiment, and a ready subagent brief when kiasi says delegate. Full list in the changelog.

Highlights

Every rule gets an outcome. The Rules tab shows how often each rule fired, how often Claude followed it, and the measured effect: re-read paid against the estimate for delegated turns, steps after a turn warning, the restored session's first context after a handoff notice, and whether a compact nudge or task-switch notice was acted on within three prompts. Each figure carries a note on how it was judged.
Holdout experiment. Set holdout in .kiasi.json or CLAUDE_PLUGIN_OPTION_HOLDOUT to reread_check, turn_budget, context_notices, output_cap or sandbox. Sessions whose id hashes odd run with that rule off, and an Experiment section on the Rules tab compares the two halves on context, re-read and steps per prompt once each side has ten sessions.
Delegating is one call. When the re-read check says delegate, kiasi writes the task file and hands Claude a ready brief with the path, goal, working directory, step budget and report format. The turn-budget pause and the "hand to a subagent" choice carry the same brief.

Upgrade notes

No settings change is needed. The holdout is off until you set it.
Outcome lines appear as data accumulates. On a fresh install the re-read and handoff outcomes stay empty until a delegate-mode check or a task-file restore happens.

Known issues

The handoff outcome is judged by a task-file restore in the same project within 60 minutes. A handoff to a different machine or a restore after a longer break counts as ignored.
The compact nudge and task-switch outcomes are open-ended when fewer than three prompts follow the notice.

Kiasi 0.5.0

2026-10-07T09:02:31Z

Highlights

One task file per task. The pause, the compaction note, the stop note and the new /kiasi:handoff skill all write it under .kiasi/checkpoints/, and the next session restores it. /clear no longer loses the task.
Context notices. At 150k tokens Kiasi says "run /kiasi:handoff, then /clear" and names the floor the session would restart from. On return after the cache has gone cold with a large context, it says the next prompt rewrites all of it. A task-switch notice fires once when a prompt after a break shares few words with the task file's goal.
Smaller floor. The SessionStart block is 7 lines instead of about 40; /kiasi:rules loads the full rules on demand. The compaction pruner keeps the last three exchanges verbatim and reduces older ones to prompt, outcome and archive pointer.
Context meter in the status line. ctx 118k (floor 46k) · turn 12/60 1.4M · cache warm 52m · idle 3m, amber at 150k and red at 200k.
Dashboard. Median and p90 context beside the mean, a "past 200k" flag with the auto-compact window recommendation, a per-project floor audit, a per-day context chart, cache-gap and model-switch rewrites, and an effort comparison that controls for difficulty and recommends a lower effort only when output per step, extra tokens and steps per prompt all clear named thresholds.
Synthetic transcript entries are classified and the replay cause is confirmed from every transcript on this machine: 99.8% are history replayed on resume, with zero usage.

Bug fixes

The turn-budget warning, pause and resume name the task file instead of Claude's own checklist, and writing it is allowed at the pause.
The shared temp checklist folder is per user and private. Cleanup removes stale pause records after 14 days. A failed run no longer counts as saved tokens.
Session state and report writes retry briefly on Windows when a file is held open. Sandbox outputs from a session with no id are cleaned up.
A file a subagent read, or a Kiasi search returned, counts as read back. Resumed sessions are marked "earlier part not shown".
Compaction no longer leaves a long result uncut because its last line starts with [kiasi ; every saved-file pointer in a dropped part is kept, up to five. Searching for a bare -- works.
Report tests use local days and pass in four time zones at both midnights.

Upgrade notes

The status line script changed (context meter). It is a copy under the data folder, so run /kiasi:limits setup again after updating to get the meter.
Two Claude Code settings are worth setting: CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000 and, on an API key, CLAUDE_CODE_PROMPT_CACHE_TTL=1h. The README's Settings section explains both.
The stored daily history is recounted once on the first dashboard build after updating.

Known issues

The pruner's 200k-character reduction gate was measured at one in twenty compactions below it and kept; it will be re-measured after a month of data.
The effort recommendation is based on one week of prompts; a second week may change it.
Windows has still not been run on a real machine.

Kiasi 0.4.2

2026-10-07T05:31:57Z

Bug-fix release. Closes the four known issues listed on 0.4.1. Full list in CHANGELOG.md.

Highlights

A paused turn is never ended by one response. Parallel refused calls count as one refusal in every mode, matched by the response they belong to, so the three-refusal backstop only trips on three separate responses.
Subagent reports survive compaction in every shape. A hand-back that arrives as an agent message or inside a system notice is kept whole or archived, like a task notification.
Problems are visible. The Rules tab shows a Problems block when a pause could not be saved, a lock timed out or a .kiasi.json value was ignored.

Bug fixes

Refusals at a pause count once per response, by the response id from the transcript or by a 3-second window when there is none. Before the first tool batch of a session, three parallel refused calls used to end the turn.
The backstop no longer depends on a tool batch arriving, so a response whose every call is refused is counted too.
Agent-message hand-backs and task notifications wrapped in a system notice are detected and kept or archived. With no archive available, the head is kept and a final line says how many characters of the report were trimmed, instead of a silent cut to 200 characters.
Error events are grouped by kind with a plain explanation, count, last seen and last message, in a block that is hidden when there are none.
The status line locks its limits files, so two sessions no longer log the same reading twice.

Upgrade notes

**Run /kiasi:limits setup again** if you use the status line. The script is a copy under the data folder and this release changed it.
Behaviour change: in batched mode the third refused response ends the turn when its calls are refused, before the batch arrives. It used to wait for the batch.
Update with /plugin marketplace update kiasi or claude plugin update kiasi@kiasi, then restart Claude Code.

Known issues

The Problems block was tested on the report side only, not rendered in a browser before release.
Windows support as a whole is still untested on a real Windows machine.

Full changelog

Kiasi 0.4.1

2026-10-07T05:24:31Z

Bug-fix release. Three audit rounds swept the plugin for the bug classes fixed in 0.4.0 and reviewed the fixes. Full list in CHANGELOG.md.

Highlights

A paused turn keeps its work. The checklist written at the warning is the one a stop, a subagent brief or a later "continue" points at, and Claude can now read and edit it at the pause instead of being refused.
Pauses are per session. Two sessions in one project no longer overwrite each other's pause record, a pause resumes once, and cleanup leaves alone any state a live pause still protects.
Subagent reports survive compaction. A hand-back report is kept whole or archived with a pointer, never cut to a 200-character stub.
Dashboard days are local days. Every figure now uses your local calendar day, with a one-time recount of stored history.

Bug fixes

Three parallel refused calls in one response count as one refused response, not three.
A pause that cannot be written to disk logs an error and still trips, instead of silently never pausing.
Subagent turn entries from older prompts are dropped from session state instead of growing forever.
The checklist fallback folder moved out of ~/.claude, which Claude Code refuses to write.
Session state, daily history, savings and sync status are written to a temp file and renamed, with a lock around the history merge. A rebuild overlapping a Sync click no longer resets history to one day.
A bad value in a project .kiasi.json falls back for that key only, instead of silently turning every hook off.
The pruner recognises every Kiasi digest marker, so an output the caps already cut is not cut again and its saved-file pointer survives.
Nested tool inputs are shrunk too, and compaction archives are named per agent, so they no longer overwrite each other within a second.
Quoted search phrases match as phrases, and words starting with - work.
A failing command in the run tool is flagged as an error. The quiet-flag rewrite leaves quoted text alone.
A session resumed today no longer brings its old steps and bill into today's totals.
Delegation is credited only when a subagent actually started; a retried skip and a read-back cap save nothing.
Figures with too little data show a dash instead of "0 k" or "−100%".
The build survives a transcript deleted mid-read or a bad line, and marks stale or stuck rebuilds as such.

Upgrade notes

**Run /kiasi:limits setup again** if you use the status line. The script is a copy under the data folder and this release changed it.
The history recount runs once on the first dashboard build. A stored day whose transcripts are already gone loses its row; on a 28-day test history that was one day with 2 steps.
Update with /plugin marketplace update kiasi or claude plugin update kiasi@kiasi, then restart Claude Code.

Known issues

Before the first tool batch of a session is seen, three parallel refused calls still end a paused turn.
Hand-back reports delivered as an agent-message block, rather than a task notification, are still cut at compaction.
Error events (pause record, lock timeout, bad setting) are logged but not yet shown on the dashboard.
No Windows file lock for the status line's limits files.

Full changelog

Kiasi 0.4.0

2026-10-07T04:34:38Z

Install or update: /plugin marketplace update kiasi, or claude plugin update kiasi@kiasi, then restart Claude Code.

Changes

The dashboard counts what the rules did over whole days. Rule events were counted over the last 168 hours while the token bill was counted by calendar day, so the first day of a period showed its bill but none, or only part, of what the rules did that day.
The same question is put at the warning, before the pause: Claude follows the warning and so seldom reaches the pause, and used to choose between ending the turn and a subagent itself. Continue there renews the budget; stop or a subagent pauses the turn at that point, so replying continue later resumes it.
At a pause Claude now asks how to go on, where it used to only end the turn: continue here with a fresh budget, hand the rest to a subagent, or stop. The checklist is written first, and Kiasi reads the answer. Continue renews the budget in place; the other two leave the turn paused, so replying continue later still resumes it. The question is asked in the terminal, the VS Code extension and the desktop app; a headless run and a subagent are paused as before. pause_question (auto, always or off; also in .kiasi.json) sets it.
A desktop notification when Kiasi pauses a turn, and when it ends one after refused calls, in the VS Code extension and the desktop app. Their chat shows the pause as one grey line, which is easy to miss in a background window. It uses notify-send on Linux, osascript on macOS and a PowerShell toast on Windows; the terminal keeps its own notification and bell. The new pause_notification setting (auto, always, off) says where it shows.
The turn budget counts steps, not tool calls. The tool calls Claude makes in one response are one step: the next request re-reads the context once for all of them. Each call used to count on its own and add the whole context to the re-read total, so a turn that worked in parallel reached its budget early. Kiasi counts at Claude Code's PostToolBatch hook, which runs once per response. Until the first one arrives in a session the calls count one by one, and that batch gives the extra counts back. A batch of calls that were all refused at the pause is not a step. Subagent budgets count the same way. The notices, the session rules and the subagent briefs say "steps" and say that parallel calls count once.
Dashboard: a delegation saving is credited only when an Agent call followed the instruction before the next prompt. It was credited whenever the instruction was shown, whether or not Claude delegated. An instruction that was not followed is listed with the checks shown, as "delegate, no Agent call".
Dashboard: "Avoidable misses" no longer counts a cache that expired while the session was idle; those misses are shown beside it. The extra cost still covers them, since they were paid for.
Dashboard: the "each step costs N× less than before" headline waits for 300 steps both before and after the install, and until then says how many there are. It used to show a factor after a few dozen steps.
When the dashboard's sync reaches its timeout, the report scripts it started are stopped with it. Only the sync itself was stopped, so a hung report script kept running.
When Claude keeps calling tools after a pause and Kiasi ends the turn, the developer is told so in a system message: "Kiasi ended this turn: Claude kept calling tools after the pause", with both ways to resume. VS Code does not show a hook's stop reason, so the turn ended there after three refused calls with no explanation.
On Windows, a dashboard that an older version left running is replaced at the next session start. It had been started with no console, so it kept opening an empty window at every 30-minute rebuild until it was stopped by hand. Like the rest of the Windows support, this is untested on a real Windows machine.
tests/e2e_parallel_compact.py resumes the session once more after the compaction and checks the batch again.
Turn checklists are written to .kiasi/checkpoints/ in the project, a folder that git ignores. Claude Code refuses Claude's writes anywhere under ~/.claude as edits to a sensitive file, so a checklist in Kiasi's data folder was never saved in headless runs, and sessions that accept edits got a permission prompt at the pause. A session without a writable project folder still uses the data folder. Search and the state restored after compaction look in both. The daily cleanup moves idle project checklists to trash like the ones in the data folder, finding their folders through the turn events, which now name the checklist path; a restore puts them back in their project, and the storage tab counts them.
A pause in a turn resumed with "continue" keeps the task and edited files of the pause it resumed, so resuming it again without a checklist still has them. A new task prompt drops them.
The turn budget has a mode, turn_budget_mode: pause (the default) pauses the turn as before, warn only warns, before and at the budget, and refuses nothing, and off only counts calls. Subagent budgets, the session rules, subagent briefs and the status line follow it. The token budget is a setting too (turn_token_budget, 8M by default), and .kiasi.json can also set turn_warn_tokens. The session rules now state the configured budgets instead of the defaults.
Replying "continue" after a pause resumes it. Kiasi adds the saved checklist (up to 2,000 characters) to that prompt, asks Claude to check git status first and to keep each item open until it is verified, and shows "Kiasi: resuming from <path>". After /clear, or in a new session of the same project, the session start says that work is waiting, and the first "continue" there resumes it the same way. Any other first prompt is only told where the checklist is. If Claude never wrote the checklist, the resume starts from the paused turn's task and the files it edited. The pause notice now says to reply "continue" after /clear as well.
The turn budget warning now comes 10 calls before the pause (at 50 of 60) or at 80% of the token limit, instead of at 30 calls or half the tokens, so a turn keeps its working room. It says about how many calls are left, counting the tokens a wide context re-reads, and asks Claude to finish the item in progress and keep the checklist current. A subagent is warned 10 calls before its own limit (30 of 40). turn_warn_steps in .kiasi.json still sets the warning outright.
When a paused turn ends and Claude's last message does not name the checklist, the Stop hook asks Claude once to close with the pause line. Hook messages may not show in the desktop app or VS Code, but Claude's reply does. The reminder is hook context, not a Stop block, so it never shows as an error, and it is skipped when the refused calls have already ended the turn.
A turn that reaches its budget is paused instead of blocked. The developer gets a notice with the cause, where the remaining work is saved and both ways to resume (reply "continue", or /clear and resume from the checklist), plus a desktop notification and a bell; the warning at 30 calls is shown to the developer too. Every call except Write and Agent is refused before it runs, and the third refused call ends the turn with the same notice. A paused subagent has its calls refused as well, but never ends the developer's turn. Before, the stop was a PostToolUse block: the call had already run, nothing was stopped, and the terminal showed a hook error, so the chat looked dead.
A subagent is held to its own budget of 40 tool calls, the figure its brief already gave it: it is warned at 20 and stopped at 40. Nothing enforced that figure, and since subagents got their own count they ran to the main turn's 60. At the stop it is told to write its checklist and reply to its caller, since a subagent cannot start another subagent. The new subagent_call_budget option sets the figure; turn_call_budget no longer changes it. The dashboard leaves subagent warnings and stops out of the turn-budget figures, and the budget report counts them on their own lines.
A session's hooks no longer overwrite each other's turn counts. Each hook loads the session's state, changes it and saves it, and parallel tool calls and subagents run their hooks at the same time, so one save could drop the calls another hook had just counted, and the turn budget fired late or not at all. A hook now holds the session's lock file, sessions/<session id>.lock, while it runs, on Windows too. It waits at most 3 seconds for the lock, then goes ahead without it, so a hook never hangs a tool call. Cleanup removes the lock file with the rest of the session's state.
On Windows, the dashboard counts saved outputs, pastes and checklists that were read back. It looked for outputs/, pastes/ and checkpoints/ with a forward slash, which a Windows path never contains, so Recall showed none read back and marked every row "could be tighter", and Storage counted every saved file as unread.
The before-and-after table shows "–" for re-read tokens per day until a full day has passed since the install. It showed 0 and −100% on the first day after it.
A subagent's tool calls count toward its own turn budget, not the turn that started it. Claude Code sends a subagent's calls with the main session's transcript path, so they were added to the parent turn's call count and measured at the parent's context size: parallel subagents used up the parent's budget, and once a turn was stopped the general-purpose subagent its stop message hands the checklist to was told the budget was exhausted within its first five calls. Turns are now keyed by agent_id, a subagent's re-read size comes from its own transcript, and a new prompt starts every count afresh.
On Windows, the dashboard no longer opens an empty terminal window every 30 minutes. The server was started with no console at all (DETACHED_PROCESS), so each 30-minute rebuild, which starts python sync.py, made Windows give it a new visible console window, titled with the Python path and empty because the output goes to the log. Detached processes now get a hidden console that everything they start inherits. A dashboard that is already running keeps opening windows until it is stopped once.
The sandbox tools no longer fail at their longest timeout. Claude Code's process.run takes at most 600000 ms, and run, distill and fetch asked for their timeout plus 10 seconds of headroom, so timeout_s: 600 asked for 610000 ms: the hook threw and the call failed with "no tool.call hook answered this call". The longest timeout is now 590 seconds, derived from the host limit (PROCESS_RUN_MAX_TIMEOUT_MS), and the tool schemas advertise it.
Compaction shortens a text that only mentions its marker. A text was left whole whenever it contained [kiasi pruned anywhere, so a large tool result showing Kiasi's own source, its tests or a transcript was never shortened at any compaction. Only a text whose last line is a marker, which is how an earlier compaction leaves it, is now kept as it is.
A second compaction keeps the sizes the first one wrote. The pruner replaces the content of older Write, Edit and NotebookEdit calls with its size, such as [9000 chars], and the next compaction measured that marker as if it were the content, so [9000 chars] became [12 chars]. A value that is already a size marker is now kept as it is.
Every turn checklist goes to a new file. Claude Code refuses to overwrite a file outside the working directory without a read record, and a hook compaction clears those records and restores none. After a compaction, a stop or reminder that named the turn's existing checklist got "File has not been read yet", and the stop rules out the Read that would get past it. checkpoint_path now names the next free <session>-<turn>-<n>.md once the turn's file exists, and cleanup matches the numbered names.
Compaction keeps every result of parallel tool calls. Claude Code writes a parallel batch as one assistant entry per call, sharing one message id, and the pruner rebuilt each entry as its own message with a fresh id, so the batch loaded as separate messages and every call but the last came back as [Tool result missing due to internal error]; on the maintainer's machine that hit 46 of 61 compactions in 7 days and lost 488 results, mostly web searches, Bash and fetches. hooks/prune.js now rebuilds each batch as one message ahead of all its results, also when a result was written between two of its calls, and the recent messages it keeps unchanged never start inside a batch. New tests in hooks/compact.test.ts cover the layouts Claude Code writes, and tests/e2e_parallel_compact.py replays the case against a real session (about eight Haiku calls).
Landing page: a new Fig. 04 "the everyday" section between the rules and the dashboard, with a status line mock (ctx, turn, 5h, wk with reset time and pace, kiasi −kept) and a legend, then six cards for the status line, run, distill, fetch and search, the login-time dashboard autostart and cleanup; later figures renumbered. Section headings now put the figure label across both columns and top-align the lede with the heading. The limit cap line at the end of the simulator rails is gone.
Windows support (untested on a real Windows machine): every hook command runs through scripts/run.sh, which picks py -3, python or python3, so the hard-coded python3 is gone from hooks.json, the skills and the status line command (which now records the interpreter that ran setup); the function hooks try python3, python and py -3 in turn; cleanup takes its lock with msvcrt where fcntl is missing and bails out from a timer thread where SIGALRM is missing; the dashboard and cleanup detach with DETACHED_PROCESS on Windows instead of start_new_session, which Windows ignored, so they no longer die with the session that started them.
/kiasi:dashboard autostart on|off|status: the dashboard can run from login with no Claude Code session at all. on writes a small launcher to ~/.claude/kiasi and registers it with the system's login starter: a systemd user service on Linux (XDG autostart where there is no user systemd), a LaunchAgent on macOS, a script in the Startup folder on Windows. The launcher reads plugin-root and data-dir from ~/.claude/kiasi, both recorded at every session start, so it survives plugin updates. The session-start hook keeps starting the dashboard when nothing answers, so a session alone is still enough.
Landing page: everything below the hero re-imagined as six figures: an interactive week-on-your-plan simulator (light/typical/heavy, two rails racing to the limit), one tool output collapsing live from 38k to 2.1k chars, a rules marquee with six hook cards, a tilting dashboard screenshot, a three-step install beside a terminal that types itself with a copy button, a trust row and a closing command box. No external requests. The install terminal has a Terminal tab and a VS Code tab: the VS Code extension has no /plugin command, so that tab carries the extension's vscode://anthropic.claude-code/install-plugin link as a button, the /plugins dialog path, and a copy-link button. README quick start gains the same link and the claude plugin shell commands.
README rewritten to match the landing page: small logo, one number-led paragraph, key features, quick start, how it works, dashboard, privacy, settings, requirements. Landing page cost section gained presets, a per-step strip for each scenario, animated counts and a savings badge; the install section is a timeline that lights up on scroll with timed steps, an animated copy tick and a what-happens-next row.
Landing page (docs/index.html) rebuilt around one story: hero with an animated session demo, a re-read cost calculator, six leaks and rules, dashboard proof, three-step install, privacy, and a collapsed reference. Same palette, no external requests. Dashboard screenshot refreshed.
Per-day history: budget.py merges every build into history.json in the data dir, so days outlive the report window and Claude Code's transcript retention; the Overview before-and-after block reads it and no longer disappears a week after install. Report window BUDGET_DAYS raised from 7 to 30 days and used by the dashboard's rebuild too.
Restructured the plugin layout, no behaviour change: scripts/kiasi.py is now a thin hook dispatcher over the scripts/core/ package (constants, events, transcript, caps, prompt, turn, reads, session, launch); the report builders moved to scripts/reports/ (budget.py, lens.py, sync.py); limits.py is statusline_install.py and usage_limits.py is limits_data.py; the slash commands became skills under skills/ (still /kiasi:dashboard, /kiasi:sync, /kiasi:limits); the five redirect stubs in dashboard/ are gone; SHIPPING.md moved to docs/dev-notes.md; tests/test_kiasi.py is split into one test file per module with a shared tests/helpers.py; scripts/README.md describes the scripts.
Dashboard starts itself: the SessionStart hook probes 127.0.0.1:8787 (and the port recorded in the data directory's dashboard.json) and, when no Kiasi dashboard answers, starts dashboard.py detached in its own session, so it outlives the Claude Code process and keeps the 30-minute rebuild running. Before this, nothing in the plugin started the server: /kiasi:dashboard ran it as a background shell that died with the session, so on any machine without a hand-made systemd unit the pages went dark after the session ended and the auto-rebuild never fired. /kiasi:dashboard now runs dashboard.py --ensure (same probe, returns at once with the URL). KIASI_DASHBOARD=off disables the autostart. The server also rebuilds the reports on start when they are missing or older than 30 minutes, records pid and port in dashboard.json, logs only failed requests to dashboard.log (truncated past 200 KB), and sends a Server: kiasi-dashboard header the probe recognises. The dashboard status line now says "last rebuild failed" with the error from sync.json instead of silently showing an old build time, and two stale error texts in sync.js that still named sync.php are gone.
Sandbox routing: while the sandbox tools are registered (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1), a PreToolUse hook on Bash and WebFetch refuses a raw call once and names the sandbox call to make instead — mcp__kiasi__run for a command whose output would only be scanned (tests, builds, installs, lint, curl, git log, docker logs, long tails; a command that already limits its output with | head, -5, --oneline or a redirect stays raw), mcp__kiasi__fetch for a page. The identical call repeated goes through, like the big-file Read nudge. Events routed and route_retry show in the dashboard under a new Sandbox routing rule, so compliance is visible. Context-mode reports this blocking step as the difference between prompting alone (~60% compliance) and routing (~98%); four days of this install's logs showed the sandbox tools used zero times with prompting alone.
New sandbox tool mcp__kiasi__fetch: downloads a URL, strips HTML to text, saves the whole page under outputs/ (searchable, cleaned up like other saved outputs) and returns only the first 3,000 chars plus the lines matching the find words, with line numbers. Its saving is logged as a cap like the other sandbox tools.
Dashboard empty states: a tab with nothing to show no longer renders its headings over blank charts. Before the first report exists each tab explains what it will show and offers a "Build the report" button that runs the sync; a report with no session in range says so and offers "Rebuild now"; the plan-limits strip stays visible on the Budget tab. Copy lives in EMPTY_STATES in lens-constants.js, the renderer in lens-common.js. The per-section "No … in range yet" lines share one wording.
The Overview tab is rebuilt around what was measured, in three sections. "What you paid": four figures, each with a line per day (re-read tokens paid, re-read per prompt, first-request context, cache hit rate), and the bill per day. "Before and after Kiasi": a bar per day over the whole history with the switch-on day marked, and the comparison table; the "N× less" headline is gone, because the two periods are different work and nothing was held constant. "What Kiasi did": counts from the log. The avoided estimate is no longer on the Overview. It multiplies every cut by all later steps of its session, as if no compaction came in between, and added up to several times the measured bill; the per-day chart no longer stacks it on the bill, and the rules show how often they fired and the tokens they cut. The rows on context and steps over the warning size say they are main-session figures. The report's since block gains series, one point per history day, and steps_per_day. The detail of Cache and Recall moved to the Rules tab, and the mean steps after a pause is on the Turn budget rule too. Amber no longer marks a figure that got worse; that is red. The Rules tab lists each rule as one row: fired, tokens cut, a line of its fires per day with the count under each day, and the breakdown; the per-rule daily graphs moved there from the Overview. The steps chart there names the band its note and legend count (60+), where the note said 50+. The Overview now uses one colour per measure in both themes: re-read tokens blue, tokens per prompt violet, first-request context teal, cache hit rate orange, steps per day pink; the days before Kiasi stay grey, and green, red and amber keep their meaning of better, worse and warning. The Rules tab draws steps per prompt as paired bars, each band's share of the prompts next to its share of the re-read tokens on one scale, with the cost of one prompt of that length. Fixed: the reports counted the messages a pruned compaction writes back into the transcript as new steps and prompts, which inflated steps, prompts and the 60+ band and lowered the mean context per step; those zero-usage entries are no longer steps, a prompt is counted once per prompt id, and prompts out of time order no longer give a negative step count. The stored daily history is recounted once after the upgrade, from the transcripts that still exist; a day whose transcripts are gone keeps its stored row. The summary of a built-in compaction is no longer a prompt, and a tool output replayed by a pruned compaction is listed once among the big outputs.