reread-guard
Stops Claude re-reading a file it already read in this conversation, with Read or a plain cat, sed -n, head, tail or Get-Content, when the file has not changed…
newguardstatus
Stops Claude re-reading a file it already read in this conversation, with Read or a plain cat, sed -n, head, tail or Get-Content, when the file has not changed…
Make the $20 Claude Pro plan last longer in Claude Code.
Twenty-two small mods that show you exactly where your usage goes and cut the waste. One mod makes a model call: prompt-polish, once each time you press Improve, and never on its own. The others make none. None adds anything to the system prompt (read-cap adds one tool, which Claude Code lists by name only until Claude first uses it; write-guard adds one line to a tool result at most once per conversation; compact-keeper adds a note of at most 4,000 characters after a compaction): every figure on screen is one Claude Code already reports, or a time the mod measured.
| Mod | What it does | Where |
|---|---|---|
| tool-diet | Loads tools you have not used lately on demand instead of with every request | Everywhere |
| skill-diet | Lists skills you have not used lately in this project by name only, without their descriptions | Everywhere |
| agent-diet | Runs Explore subagents on Haiku instead of your main model | Everywhere |
| context-xray | /xray opens the exact breakdown of what fills your context window | Everywhere |
| pro-hud | Live meters above the prompt for your 5-hour session, your week and the context window, plus a per-turn receipt of tokens in, cached and out | Claude desktop app |
| output-diet | Trims long shell output, search results and subagent reports before Claude reads them, keeping the head, the tail and the error lines; the untrimmed text is saved to a file Claude can open without a permission prompt | Everywhere |
| reread-guard | Skips Claude re-reading a file it already read when the file has not changed, with Read or a plain cat, sed -n, head, tail or Get-Content; a deliberate retry still goes through | Everywhere |
| write-guard | Steers Claude to Edit instead of rewriting an existing file in full with Write; a deliberate rewrite still goes through | Everywhere |
| loop-guard | Holds back a shell command that already failed twice in a row, so Claude changes approach | Everywhere |
| cmd-diet | Adds quiet flags to noisy shell commands before they run, so Claude reads short output from the start; errors, failures and warnings stay in full | Everywhere |
| gh-account | Runs each git push, pull, fetch, clone and gh command as the logged-in GitHub account that can see the repository, without switching the active account | Everywhere |
| cache-clock | Counts down until the prompt cache expires; once it has, shows exactly how many tokens your next message will re-send uncached | Everywhere |
| read-cap | Stops Claude reading a file over 1,000 lines whole (with Read, cat or Get-Content) and gives it an outline tool, so it reads only the lines it needs; a retry still reads the whole file | Everywhere |
| session-receipt | /receipt opens a pane with the exact tokens every turn of the session spent, and the costliest turns | Everywhere |
| peek | Typing status while background tasks run opens a pane with each one's exact elapsed time and last output lines, instead of sending the prompt to Claude | Everywhere |
| budget-guard | Holds a prompt back once your 5-hour or weekly usage reaches your limit (90% by default); sending it again goes through | Everywhere |
| turn-budget | When one turn uses more than +5 session points, writes a handoff and continues in a fresh session by itself; /handoff any time | Everywhere |
| compact-keeper | After a compaction, adds a note of exact facts from before it: your latest prompt in full, the todo list, the last failed command, files edited | Everywhere |
| collision-guard | Asks before Claude edits a file another chat on this machine changed in the last 30 minutes | Everywhere |
| answer-pane | Explain, plan and ELI5 pages drawn natively in a side pane; plans have decision buttons and Respond fills the prompt box | Desktop app (no diagrams in the terminal) |
| prompt-polish | An Improve button beside Send (above the prompt in the terminal) rewrites your draft with Opus at low effort and puts it back in the box; Undo restores it. One model call per press | Everywhere |
| kit-updates | Tells you when an installed mod from this kit has a newer version or a new mod joins the kit; /kit-update installs updates and new mods | Everywhere |
In Claude Code:
/plugin marketplace add VedantAndhale/claude-pro-kit
/plugin install tool-diet@claude-pro-kit
/plugin install skill-diet@claude-pro-kit
/plugin install agent-diet@claude-pro-kit
/plugin install context-xray@claude-pro-kit
/plugin install pro-hud@claude-pro-kit
/plugin install output-diet@claude-pro-kit
/plugin install reread-guard@claude-pro-kit
/plugin install write-guard@claude-pro-kit
/plugin install loop-guard@claude-pro-kit
/plugin install cmd-diet@claude-pro-kit
/plugin install gh-account@claude-pro-kit
/plugin install cache-clock@claude-pro-kit
/plugin install read-cap@claude-pro-kit
/plugin install session-receipt@claude-pro-kit
/plugin install peek@claude-pro-kit
/plugin install budget-guard@claude-pro-kit
/plugin install turn-budget@claude-pro-kit
/plugin install compact-keeper@claude-pro-kit
/plugin install collision-guard@claude-pro-kit
/plugin install answer-pane@claude-pro-kit
/plugin install prompt-polish@claude-pro-kit
/plugin install kit-updates@claude-pro-kitUpdates are off by default for marketplaces you add yourself. With kit-updates installed you are told when a fix ships and /kit-update installs it, from the desktop app or the terminal. Without it, turn on auto-update once: in a terminal, run claude, then /plugin → Marketplaces → claude-pro-kit → Enable auto-update; the desktop app has no toggle for it.
Install any one on its own; they do not depend on each other. Mods are not sandboxed, so read the code before installing: each mod is a single file under plugins/<name>/hooks/.
Every tool listed in front sends its whole description and schema with every request. A deferred tool is listed by name only, and Claude loads it through ToolSearch when it needs it; Claude Code already does this for most MCP tools. tool-diet does it for the rest of the tools you are not using: anything outside the core set (Bash, PowerShell, Read, Edit, Write, Glob, Grep, Agent, Skill, ToolSearch, TodoWrite, AskUserQuestion) that you have not used in your last five sessions.
Measured with one prompt, "Reply with just OK.", in a fresh session, as the API reported each request:
| Prompt tokens per request | |
|---|---|
| Without tool-diet | 43,859 |
| With tool-diet | 27,905 |
| Change | −15,954 (−36%) |
On that setup, the largest tool moved was Artifact, whose description alone is 19,870 characters. What moves depends on your tools and your habits; /xray shows yours.
/tool-diet lists what is on demand this session, grouped by where each tool comes from; /tool-diet keep <tool> always loads one, unkeep undoes it, and /tool-diet off|on switches it. Answers are toasts, so they add nothing to the conversation. The status line keeps the count: 38 tools on demand.
Every request carries the skill listing: each installed skill's name and its whole description. With a few plugins installed that is dozens of skills, most of which a given project never uses (video skills in a backend repo, document skills in a game). skill-diet keeps the skills you used lately in this project listed in full and lists the rest on one line by name only. The Skill tool still loads any of them, and typing /name still works.
Measured with one prompt, "Reply with just OK.", in a fresh session with 45 skills installed and the other mods on, as the API reported the request:
| Prompt tokens per request | |
|---|---|
| Without skill-diet | 27,423 |
| With skill-diet | 19,197 |
| Change | −8,226 (−30%) |
In the same setup, asked to fill in a PDF form, Claude found anthropic-skills:pdf from its name alone and loaded it with the Skill tool. What moves depends on your skills; /xray shows yours.
/name or called by Claude through the Skill tool./skill-diet shows what is listed by name only this session and how many characters left the listing; /skill-diet keep <skill> always lists one in full, unkeep undoes it, and /skill-diet off|on switches it. Answers are toasts, so they add nothing to the conversation. The status line keeps the count, in the form <n> skills by name only, <n> characters off./xray shows the skills line before and after, in tokens.A subagent runs on your main model unless its definition or Claude's Agent call names another. Explore only searches and reads, yet in the author's own 85 subagent transcripts, every one of the 2,043 Explore requests ran on Opus or Sonnet, reading 147,298,992 input tokens. agent-diet starts the agent types you list (Explore by default) on Haiku.
/agent-diet shows the setting and how many subagents it moved this session; /agent-diet model haiku|sonnet|opus picks the model, /agent-diet add|remove <agent type> changes the list, and /agent-diet off|on switches it. Answers are toasts, so they add nothing to the conversation. The status line keeps the count, in the form 2 subagents on haiku.Measured with claude -p --model sonnet --output-format json on a task that sends one Explore subagent to find a file, three runs each in alternating order. Every run found the file. Figures are the cost and tokens Claude Code reported per model:
| Run | Without: cost | Without: Sonnet tokens in | With: cost | With: Sonnet tokens in | With: Haiku tokens in |
|---|---|---|---|---|---|
| 1 | $0.05692 | 68,395 | $0.03724 | 40,213 | 27,848 |
| 2 | $0.05577 | 68,111 | $0.03764 | 39,593 | 27,872 |
| 3 | $0.05441 | 68,123 | $0.03736 | 40,184 | 42,770 |
| Average | $0.05570 | $0.03741 |
/xray opens a pane with the exact breakdown /context computes: what is sent with every request (system prompt, tools, MCP tools, memory files, skills, messages), what is loaded on demand, which MCP tools load every time, and each memory file's size. It measures when the pane opens and when you press Refresh (or r), never in the background, because the exact count sends one token-count request per tool and memory file.
Opens by itself when the context crosses 60% and again at 80%, with a toast pointing at /compact and /handoff. /xray auto off keeps it to /xray only.
The recording at the top of this page is the band. In text:
Session ━━━━━━━━━━━━━━────── 69% resets in 32m
Week ━━━━━━━━━━━━━━━───── 74% resets in 4d 17h
Context ━━━━━━━━──────────── 44% 436,034 tokens
This turn 1m 35s · 1 tool · 0 files edited · 436,034 in · 431,260 cached · 580 outOn a wide window the three meters sit side by side on one row; on a narrow one each figure on the turn line wraps whole rather than being cut off.
/compact when it climbs.· session 20%, and finished tool calls draw as one line: status dot, tool, target, time./hud shows what is on; /hud all on|off, or /hud band|spinner|cards on|off. The answer is a toast, so toggling adds nothing to the conversation. It draws in the desktop app only and leaves the terminal as it is. Rows other mods put above the prompt still draw beneath the band.
Weekly toasts at 50%, 75% and 90% of the week, once each, because the weekly limit drains quietly across many sessions.
When a Bash or PowerShell result runs past 120 lines or 8,000 characters, Claude reads:
[output-diet: 82/500 lines shown; all 500 in ~/.claude/projects/<project>/<session>/tool-results/output-diet-<call>.txt]
<first 30 lines>
… [lines 31–450 omitted; error/warning lines from them:]
250│ ERROR: build failed in src/app.ts
300│ Warning: deprecated API
…
<last 50 lines>3 trimmed · 41,200 chars saved.tool-results folder, beside the transcript, where Claude Code keeps the outputs it saves itself, so Claude can open it without a permission prompt. When that folder cannot be found, it goes under ~/.claude/output-diet/ (or CLAUDE_CONFIG_DIR).Grep result past the same limits keeps its first 100 lines, with a note to narrow the search: [output-diet: first 100/252 lines shown; narrow the search, or read all in …]. In the author's 1,048 past Grep results, 26 went past the limits, and keeping the first 100 lines would have cut 104,052 characters. Glob is left alone: none of 128 went past.When Claude asks to Read the same range of the same file again in the same conversation, and the file's size and modification time have not changed, the read is skipped and Claude is told to use the copy it has. Any edit, a different range, or a subagent (which has its own context) reads freely. Claude Code can clear old tool results from context, so retrying the identical read straight after a skip always goes through. The record resets on /compact and /clear.
What Claude is told in place of the repeat read, kept to one line because the model reads it:
api.ts unchanged since you read it; use that copy. If it's gone from context, retry the same Read.Shell reads too. Claude often reads a file with the shell instead of Read: in the author's transcripts, 318 sed -n runs went past the guard. A shell command that only prints one file is now treated the same way: cat FILE, sed -n 'A,Bp' FILE, head -n N / tail -n N, and in PowerShell Get-Content, gc, cat or type (with -TotalCount, -Head, -First, -Tail, -Last or -Raw). The same range of the same unchanged file is skipped once, and retrying the same command goes through. A whole cat after a whole Read that showed every line counts as a repeat. A pipe, a chain, a variable, a glob or any other flag runs untouched. A shell read never counts as a Read, since Edit needs a real one first.
The status line counts them: 2 re-reads skipped.
Write sends the whole file as Claude's output, the most expensive kind of token; Edit sends only the lines that change. Claude sometimes rewrites a file it has already read in full to change a few lines. In the author's own 272 session transcripts, 141 writes rewrote a file Claude had already read or written (999,273 characters), and 112 of them followed an earlier rewrite in the same session. Of the 512,847 characters in the rewrites whose previous version was in the transcript, 171,325 had changed.
A hook runs after Claude has written the content, so write-guard cannot save the rewrite it sees; it stops the ones after it:
You rewrote all of api.ts. For changes to an existing file use Edit: it sends only the changed lines.api.ts exists; change it with Edit, not a full Write. If a full rewrite is intended, retry the same Write. Retrying the same Write goes through./clear starts over.1 full rewrite held back.Each retry of a failing command re-sends the whole conversation, and the same command usually fails the same way. In the author's 272 session transcripts, 10 commands failed 3 or more times, 38 runs between them.
Once the exact same Bash or PowerShell command has failed twice in a row, the next try is held back once, and Claude is told:
This exact command failed 2 times in a row. Change the approach instead of rerunning it. If a rerun is intended, retry the same command./clear starts over.1 failing retry held back.output-diet trims long output after a command has run; cmd-diet keeps the noise from being printed at all. Before a Bash or PowerShell command runs, a known noisy command gets its own quiet flags, which drop progress lines and keep errors, test failures and warnings:
| Command | Runs as | Output, measured |
|---|---|---|
git status | git status --short --branch | 415 to 58 characters |
pytest | pytest -q | 1,063 to 495 characters, failure details unchanged |
cargo build / test / check / clippy / run | cargo build -q | 197 to 0 characters on success, warnings unchanged |
npm install / ci | npm install --no-audit --no-fund | 62 to 18 characters |
curl (Bash only) | curl -sS | 1,049 to 577 characters, the progress meter removed |
mvn | mvn -B -ntp | not measured: drops download progress |
wget (Bash only) | wget -nv | not measured: one line per file |
docker pull | docker pull -q | not measured: drops layer progress |
In a live headless run (git status && python -m pytest on 41 test files, one failing), the request cost 41,535 tokens without cmd-diet and 40,571 with it, by the API's usage, and both runs named the failing test and its reason correctly. The shorter output stays in context, so every later request in the session sends less too.
&&, || or ; chain is handled on its own. A step that pipes, redirects or substitutes (| grep, > file, $(...)) is left alone, since something else reads its output; 2>&1 is fine.git status --porcelain, pytest -v, curl -fsSL, npm install --silent) is left alone, and a flag already present is not added twice.3 commands quieted.With two GitHub accounts logged in to gh, a push to a repository the other account owns fails, and Claude spends turns on gh auth status and gh auth switch. Before a Bash or PowerShell command runs, gh-account matches each git push, pull, fetch, clone, ls-remote and gh step to the repository's owner, and the owner to a logged-in account. When that account is not gh's active one, that step alone runs with its token:
GH_TOKEN="$(gh auth token --user ACCOUNT)" git pushThe token itself never appears in the command or its output, and the active account is not switched. For git it also asks gh for the credential.
-R owner/repo, a gh api repos/<owner>/... path, or the folder's remotes. With no remote named, every remote must point at the same owner.gh auth status, and organizations from gh api user/orgs. What it learns is kept across sessions.gh auth and other gh commands that reach no repository, a command that already sets GH_TOKEN, a token from the environment, git over ssh, hosts other than github.com, and subshells or substitutions./gh-account shows which account each owner uses, and /gh-account forget clears it. Answers are toasts. The status line counts them: 2 commands sent as <account>.Claude's prompt cache keeps your conversation for a fixed time after each request. Reply within it and the context is read from cache; reply after it and the whole context is sent again at full price. That message pays the cache-write price (1.25 times the input price for a 5-minute cache, 2 times for a 1-hour one) on every token instead of the cache-read price (0.1 times): 12.5 to 20 times more for the same context, and nothing on screen says so.
cache-clock puts the countdown in the status line, restarted by every response from the main conversation:
cache warm · 3m left
cache cold · next message re-sends 61,204 tokensWhen the cache runs out, a toast says so once (after the lifetime is known, see below). The token figure is the previous response
hooks/register.ts 254 lines1import type { Register } from 'claude-code'
2
3// A Read is skipped when the same loop already read the same range of the same
4// file and the file's size and modification time have not moved since. The
5// engine can clear old tool results from context, so a second attempt at the
6// exact same Read right after a skip always goes through.
7//
8// A shell command that only prints one file (`cat`, `sed -n 'A,Bp'`, `head`,
9// `tail`, `Get-Content`) is treated the same way. Anything else, a pipe, a
10// chain, a variable or a flag not listed here, runs untouched.
11
12const MAX_TRACKED = 500
13
14// What a Read with no range shows of a file: past this it cuts lines.
15const READ_LINES = 2000
16const READ_LINE_CHARS = 2000
17
18// Reads Claude Code turns into something other than text lines.
19const NOT_TEXT = /\.(png|jpe?g|gif|webp|bmp|ico|pdf|ipynb)$/i
20
21type Seen = { size: number; mtimeMs: number }
22
23const baseName = (path: string) => path.split(/[\\/]/).pop() ?? path
24
25// Characters a word may hold outside quotes; anything else (a pipe, redirect,
26// chain, variable, glob, escape, `~`) could make the shell do more than read.
27const BASH_PLAIN = /[\p{L}\p{N}_.\-/:+,@%=]/u
28const PWSH_PLAIN = /[\p{L}\p{N}_.\-/:\\]/u
29
30// Splits a command into words with their quotes removed; undefined when any
31// part is not plain.
32export function words(command: string, shell: string): string[] | undefined {
33 const out: string[] = []
34 const text = command.trim()
35 let cur: string | undefined
36 let quote: string | undefined
37 for (let i = 0; i < text.length; i++) {
38 const c = text[i]
39 if (quote !== undefined) {
40 // PowerShell also closes a string on a typographic quote.
41 if (shell !== 'Bash' && /[‘-„]/.test(c)) return undefined
42 if (c === quote) {
43 // PowerShell spells a quote inside quotes by doubling it.
44 if (shell !== 'Bash' && text[i + 1] === quote) return undefined
45 quote = undefined
46 } else if (quote === '"' && /[$`]/.test(c)) return undefined
47 else if (quote === '"' && shell === 'Bash' && /[\\!]/.test(c)) return undefined
48 else cur += c
49 continue
50 }
51 if (c === "'" || c === '"') {
52 quote = c
53 cur ??= ''
54 continue
55 }
56 if (c === ' ' || c === '\t') {
57 if (cur !== undefined) out.push(cur)
58 cur = undefined
59 continue
60 }
61 if (!(shell === 'Bash' ? BASH_PLAIN : PWSH_PLAIN).test(c)) return undefined
62 cur = (cur ?? '') + c
63 }
64 if (quote !== undefined) return undefined
65 if (cur !== undefined) out.push(cur)
66 return out
67}
68
69const count = (word: string | undefined) => (word !== undefined && /^[1-9]\d*$/.test(word) ? Number(word) : undefined)
70
71// `-n N`, `-nN` or `-N`, the only flags head and tail take here.
72const lineFlag = (flags: string[], isTail: boolean) => {
73 const word =
74 flags.length === 2 && flags[0] === '-n' ? flags[1]
75 : flags.length === 1 && /^-n./.test(flags[0]) ? flags[0].slice(2)
76 : flags.length === 1 && /^-\d/.test(flags[0]) ? flags[0].slice(1)
77 : undefined
78 if (isTail && word?.startsWith('+') === true) {
79 const from = count(word.slice(1))
80 return from === undefined ? undefined : `${from}-end`
81 }
82 const n = count(word)
83 return n === undefined ? undefined : isTail ? `last ${n}` : `1-${n}`
84}
85
86// One plain read of one file: its path as typed and the lines it prints, ''
87// for the whole file. Undefined for any command it does not fully understand.
88export function shellRead(command: string, shell: string): { path: string; range: string } | undefined {
89 const all = words(command, shell)
90 if (all === undefined || all.length < 2) return undefined
91 const [name, ...args] = all
92
93 if (shell === 'Bash') {
94 const path = args[args.length - 1]
95 const flags = args.slice(0, -1)
96 if (path.startsWith('-')) return undefined
97 if (name === 'cat' && flags.length === 0) return { path, range: '' }
98 if (name === 'sed' && flags.length === 2 && flags[0] === '-n') {
99 const hit = flags[1].match(/^(\d+)(?:,(\d+))?p$/)
100 const from = count(hit?.[1])
101 const to = hit?.[2] === undefined ? from : count(hit[2])
102 return from === undefined || to === undefined || to < from ? undefined : { path, range: `${from}-${to}` }
103 }
104 if (name === 'head' || name === 'tail') {
105 const range = lineFlag(flags, name === 'tail')
106 return range === undefined ? undefined : { path, range }
107 }
108 return undefined
109 }
110
111 if (!['get-content', 'gc', 'cat', 'type'].includes(name.toLowerCase())) return undefined
112 let path: string | undefined
113 let range = ''
114 for (let i = 0; i < args.length; i++) {
115 const arg = args[i].toLowerCase()
116 if (arg === '-raw') continue
117 if (arg === '-path' || arg === '-literalpath') {
118 if (path !== undefined || args[i + 1] === undefined) return undefined
119 path = args[++i]
120 continue
121 }
122 if (/^-(totalcount|head|first|tail|last)$/.test(arg)) {
123 const n = count(args[++i])
124 if (range !== '' || n === undefined) return undefined
125 range = /^-(tail|last)$/.test(arg) ? `last ${n}` : `1-${n}`
126 continue
127 }
128 if (arg.startsWith('-') || path !== undefined) return undefined
129 path = args[i]
130 }
131 return path === undefined || path.startsWith('-') ? undefined : { path, range }
132}
133
134// The path a shell resolves, given its working directory; undefined when it
135// cannot be placed with certainty (Git Bash's own `/tmp`, `\x`, `D:x`).
136export function absolute(path: string, cwd: string): string | undefined {
137 const isWindows = /^[A-Za-z]:[\\/]/.test(cwd)
138 // Git Bash spells D:\x as /d/x.
139 const drive = isWindows ? path.match(/^\/([A-Za-z])(\/.*)?$/) : null
140 if (drive !== null) return `${drive[1]}:${drive[2] ?? '/'}`
141 if (/^[A-Za-z]:[\\/]/.test(path)) return isWindows ? path : undefined
142 if (path.startsWith('/')) return isWindows ? undefined : path
143 if (path.startsWith('\\') || /^[A-Za-z]:/.test(path)) return undefined
144 return `${cwd.replace(/[\\/]+$/, '')}/${path}`
145}
146
147export const register: Register = on => {
148 const seen = new Map<string, Seen>()
149 const skippedOnce = new Set<string>()
150 let skips = 0
151
152 const loopOf = (agentId: string | undefined) => agentId ?? 'main'
153
154 const forget = (loop?: string) => {
155 for (const key of [...seen.keys()]) {
156 if (loop === undefined || key.startsWith(`${loop}|`)) seen.delete(key)
157 }
158 for (const key of [...skippedOnce]) {
159 if (loop === undefined || key.startsWith(`${loop}|`)) skippedOnce.delete(key)
160 }
161 }
162
163 const isUnchanged = (before: Seen | undefined, stat: Seen) =>
164 before !== undefined && before.size === stat.size && before.mtimeMs === stat.mtimeMs
165
166 // Claimed before the read runs, so an identical read sent in the same
167 // batch is skipped too; given back if this one fails.
168 const claim = (key: string, stat: Seen) => {
169 skippedOnce.delete(key)
170 seen.set(key, { size: stat.size, mtimeMs: stat.mtimeMs })
171 if (seen.size > MAX_TRACKED) seen.delete(seen.keys().next().value as string)
172 }
173
174 on('tool.call', { tool: 'Read' }, async ($, e, next) => {
175 const stat = await $.fs.stat(e.file_path, { resolve: true }).catch(() => undefined)
176 if (!stat || stat.kind !== 'file') return next(e)
177
178 const where = (stat.realPath ?? e.file_path).toLowerCase()
179 const key = [loopOf(e.agentId), where, e.offset ?? '', e.limit ?? '', e.pages ?? ''].join('|')
180
181 if (isUnchanged(seen.get(key), stat) && !skippedOnce.has(key)) {
182 skippedOnce.add(key)
183 skips += 1
184 $.ui.status(`${skips} re-${skips === 1 ? 'read' : 'reads'} skipped`)
185 return {
186 // Short on purpose: the model reads it.
187 deny: `${baseName(e.file_path)} unchanged since you read it; use that copy. If it's gone from context, retry the same Read.`,
188 }
189 }
190
191 claim(key, stat)
192 const ran = await next(e)
193 if (ran.deny !== undefined || ran.isError === true) seen.delete(key)
194
195 return ran
196 })
197
198 // A shell read is only recorded under its own key, never as a Read: the
199 // Edit tool needs a real Read of the file first.
200 on('tool.call', async ($, e, next) => {
201 if ((e.tool !== 'Bash' && e.tool !== 'PowerShell') || typeof e.command !== 'string') return next(e)
202 const read = shellRead(e.command, e.tool)
203 if (read === undefined) return next(e)
204 const cwd = await $.session.cwd().catch(() => undefined)
205 const path = cwd === undefined ? undefined : absolute(read.path, cwd)
206 if (path === undefined) return next(e)
207 const stat = await $.fs.stat(path, { resolve: true }).catch(() => undefined)
208 if (!stat || stat.kind !== 'file' || stat.realPath === undefined) return next(e)
209
210 const where = stat.realPath.toLowerCase()
211 const loop = loopOf(e.agentId)
212 const key = [loop, where, 'shell', read.range].join('|')
213
214 // A whole Read before a whole `cat` counts when that Read showed every line.
215 const sawAll = async () => {
216 if (read.range !== '' || NOT_TEXT.test(where) || !isUnchanged(seen.get([loop, where, '', '', ''].join('|')), stat)) return false
217 const text = await $.fs.read(stat.realPath as string).catch(() => undefined)
218 if (typeof text !== 'string') return false
219 const lines = text.split('\n')
220 return lines.length - (text.endsWith('\n') ? 1 : 0) <= READ_LINES && lines.every(line => line.length <= READ_LINE_CHARS)
221 }
222
223 if (!skippedOnce.has(key) && (isUnchanged(seen.get(key), stat) || (await sawAll()))) {
224 skippedOnce.add(key)
225 skips += 1
226 $.ui.status(`${skips} re-${skips === 1 ? 'read' : 'reads'} skipped`)
227 return {
228 deny: `${baseName(path)} unchanged since you read it; use that copy. If it's gone from context, retry the same command.`,
229 }
230 }
231
232 claim(key, stat)
233 const ran = await next(e)
234 if (ran.deny !== undefined || ran.isError === true) seen.delete(key)
235
236 return ran
237 })
238
239 // A compaction replaces what that loop had read with a summary.
240 on('session.compact', async ($, e, next) => {
241 const done = await next(e)
242 if (e.trigger !== 'precompute' && done.skip === undefined) forget(loopOf(e.agentId))
243
244 return done
245 })
246
247 // /clear starts a fresh conversation.
248 on('session.end', async ($, e, next) => {
249 forget()
250
251 return next(e)
252 })
253}
254