Trims the skill listing to what the project kind needs (off by default); /context-diet shows what was dropped and the tokens saved

English | 日本語
Personal Claude Code mods (function-hook plugins), published as one marketplace.
| Mod | What it does |
|---|---|
agent-pane | Live pane of the session's subagents: running ones with elapsed time, finished ones with result and duration |
done-gate | Flags unverified edits, stops repeated failing commands, and blocks git --no-verify |
sandbox-lens | Tallies sandbox denials seen in Bash output and reports them with /sandbox-report |
skill-hint | Suggests up to three matching skills above the prompt from what was typed; never invokes them. |
todo-agent | Collects #TODO(agent) follow-ups from Claude's replies into a per-project list with a /todos pane. |
context-meter | Band above the prompt with a Gruvbox sparkline of context use per turn, plus tokens and cost |
tool-row | Redraws finished tool-call rows in the terminal as one compact line with a Nerd Font icon, Gruvbox colors and a short stat |
image-preview | Thumbnails of the images a session writes, reads or generates: under the tool's row in the terminal, and in an /images pane |
self-audit | After each turn, a cached fork of the conversation audits Claude's own reply against the CLAUDE.md reporting rules and flags violations above the prompt |
context-diet | Trims the skill listing to what the project kind needs (off by default); /context-diet shows what was dropped and the tokens saved |
browser-cam | Live pane of the browser Claude drives: the latest screenshot from Claude in Chrome, the page URL and the recent actions |
prompt-coach | Holds back a typed prompt that looks ambiguous (no done-condition, unclear target) and offers guesses at what it meant, sending it as is, or adding one; on by default |
loopback | Feeds what self-audit, done-gate and sandbox-lens found back to Claude beside the next prompt, instead of only showing it to the person, skipping rules hit-rate found mostly wrong; off by default |
zukan | Error book: catches the errors Bash commands hit across sessions and repos, records what got past each one, and when one comes back tells Claude and the person how it was fixed last time |
pr-lamp | The current branch's pull request as a lamp: checks, review, unresolved threads and what is left before a merge, in the status line and a /pr pane; red checks and new review comments go to Claude beside the next prompt |
fog-map | Exploration map: the repository as a tree under fog, cleared where Claude read and marked where it edited, made a file or hit an error, with the importers an edit may have broken unseen; /map |
assertion-guard | Catches edits that weaken tests to pass: assertions removed, expectations loosened or rewritten, tests skipped, errors swallowed; asks Claude for the reason beside the edit |
negative-space | When an edit adds authorization, validation or error handling, lists the refusal and boundary-value tests no test touched this session covers; /negative-space |
mutation-tap | /mutate runs a mutation test limited to the lines changed since HEAD and lists the mutants the tests did not catch |
perf-delta | /perf compares a benchmark before and after (a saved baseline, or a git ref in a temporary worktree): median time, peak memory, spread, and whether the change beats the noise |
handoff-capsule | Before a compaction and at session end, keeps the goal, decisions, open items, commands to reproduce and files touched; the next session picks which parts to bring back |
port-lantern | The dev servers the session started: URL, port, whether each still listens, and their latest log lines, in the status line and /ports |
artifact-shelf | A shelf of what sessions made (CSV, PDF, HTML, video, patches…), tied to the call and request that made each; /shelf searches by kind, word and time |
focus-hud | One status line: goal, target, what is running and for how long, and what the session waits on; /focus |
side-effect-ledger | A ledger of what a git diff never shows (push, publish, deploy, PRs, API writes, messages) with outcome, how to undo, and whether the undo was checked; /ledger |
trust-label | Labels external text (web, issues, logs, browser pages, services) with its source beside the result and flags candidate injected instructions; a heuristic, never a safety verdict; /trust |
visual-diff | Compares browser screenshots of the same URL and size before and after an edit: side by side, a map of changed cells, regions, and the edits in between; /vdiff |
journey-trace | Records Claude's browser actions and the expected states as a replayable recipe; /journey md for a bug report, /journey e2e for a Playwright draft |
hit-rate | Gives each finding of done-gate, assertion-guard, self-audit and zukan a later verdict from what the session did next, keeps each rule's precision across sessions, and names the rules loopback stops feeding; /hit-rate; off by default |
token-lens | Checks an element's actual colours, spacing and type against the project's design tokens and lists off-token values with the nearest token; /token-lens <selector> |
At the prompt of a terminal session:
/plugin install <mod> --marketplace simota/claude-mods
From a shell:
claude plugin install <mod> --marketplace simota/claude-mods
This repository is private: installing needs read access on GitHub and a git credential for github.com on the machine (an SSH key, or gh auth login then gh auth setup-git).
Options are set with /plugin configure <mod>@simota-mods in a session, or from a shell:
echo '{"enabled":"true"}' | claude plugin configure <mod>@simota-mods --values-stdin
A change made with /plugin configure reloads the mod; one made from a shell applies after a restart. Bands above the prompt stack: each mod draws its row above what the others draw.
/agent-pane opens the pane: running subagents first with elapsed time, then finished ones with ✓/✗ and duration; a background run that was stopped shows ■ 停止. A background run that left the roster without a result shows ? 結果不明; a teammate or remote launch shows ↗ 起動済み(追跡外).agents: N running while any run.Works on its own, no command:
ls build, npm ci are not checks), and only when its exit status is the command's: the check is last, or only && follows it (npm test | tail does not count).--no-verify (or a prefix of it from --no-ver), and git commit -n / -nm, is denied, also inside subshells, $(…), backticks, bash -c "…", eval and wrappers such as sudo/timeout. The value of an option (-m "…"), a comment or a heredoc never triggers it. So is a git command that moves its hooks for the run (-c core.hooksPath=…, --config-env core.hooksPath=…) or carries a hook manager's off switch in its environment (HUSKY=0, LEFTHOOK=0, pre-commit's SKIP=…), or moves the hooks through config in its environment (GIT_CONFIG_KEY_n=core.hooksPath, GIT_CONFIG_PARAMETERS). ANSI-C quoting ($'--no-\x76erify'), env -S "…", bash -c -- '…' and a shell reading its script from stdin (bash <<< '…', a heredoc, echo '…' | sh) are read through. It is a best-effort guard: git aliases (git ci -n), a hook path written into config beforehand and an environment exported by an earlier command are not detected./sandbox-report lists the sandbox denials seen in Bash output, for this session and all time: denied hosts and paths, counts, last seen, an example command, and which setting would allow each./sandbox-report reset clears the record.127.0.0.1:3000), since an entry without a port opens every port.<sandbox_violations> block, and Operation not permitted lines a program printed about itself, are read. For a command that succeeded or was interrupted, the block is taken from where the engine puts it, apart from the command's own output, so one inside a shown file or page is ignored even when it ends the output. A failed command keeps only its error text: the block that ends it (before an agent-proxy note) is read, and there a block the command printed itself cannot be told from the harness's. Credentials in the example command (tokens, passwords, Authorization/Cookie and other credential headers such as X-API-Key, URL userinfo, keys in env assignments including run-together names such as PGPASSWORD, known key shapes) are masked. Each section shows the top 10; when the record is full (200), the least recently seen entry gives way.After a prompt is sent, up to three skills matching it show above the prompt (💡 skill候補: /coding-debug …), only ones that exist in the session. Nothing is invoked; 閉じる or the next prompt (a slash command included) clears it. A prompt that already names a skill (/name anywhere, or a hyphenated skill name such as coding-debug) gets no hint; built-in commands such as /clear and path segments such as src/review/ do not count as naming one. Plugin skills (plugin:name) are suggested by their full name.
#TODO(agent): <action> (after an optional quote or list bullet) in Claude's main-loop replies are collected per project (repo root or cwd). A mention inside a sentence, a table or inline code is not a TODO; subagent replies are ignored./todos opens the pane of this project's open items, each with a 完了 button./todos all lists every project's open items as text, marked as stored data.TODO(agent): N while the project has open items.A band with a sparkline of context use per turn and ctx 63% ▲4 · 126k · turn in 120k / out 8k · $1.23: the context size of the last request, then the whole turn's input/output (shown when the turn reported usage). The percentage turns yellow from 50% and red from 80%.
| Option | Default | |
|---|---|---|
band | true | Draw the band (samples are recorded either way) |
Finished tool calls are drawn as one compact line with a Nerd Font icon: Edit/Write path +A −D, Read with line count, Bash (red on error), Agent, web and MCP calls. The result block under a compacted row is hidden, so a call is one line; an errored result stays. A row another mod decorated (an image-preview thumbnail) is left as it is, result included. Runs Claude Code folds into one count line (Read 3 files, ran 2 shell commands) stay folded. Terminal only.
| Option | Default | |
|---|---|---|
compact | true | Off leaves every row and result as Claude Code draws them |
/images opens a pane, newest first; h/l step through them.sips after the tool result has gone back, so tool calls never wait on it. Converted files live in a private cache ($TMPDIR or ~/.cache), newest 50 kept. A killed session's folder is removed by a later session's start once a day untouched; a running session touches its own every hour (again after a plugin reload), so it is kept while idle, though not across a day the machine sleeps./tmp/a b/x.jpg) joins at most 8 preceding pieces and 4096 characters; the first 64 paths named are read, and of those the first 4 that exist are shown.| Option | Default | |
|---|---|---|
inline | true | Thumbnail under the tool row |
maxRows | 12 | Rows a thumbnail may take, 1 to 60 |
After each reply of at least minChars characters, one tool-less fork of the conversation (served mostly from the prompt cache), given the reply itself as quoted data, checks it against the CLAUDE.md rules: claims done without evidence, first line not the result, unverified assertions, bypassed checks, scope inflation. Only violations of the five rules whose quote is found in the reply are kept (a made-up quote or rule is dropped); the quote is compared past markdown marks, bullets, curly quotes, case, spacing and a closing full stop, and one shortened with … is found piece by piece. Violations show in red above the prompt; 詳細 or /self-audit opens the pane with quotes and the fork's token use. Results belong to the latest reply only: when it was not audited, the pane says why.
| Option | Default | |
|---|---|---|
enabled | true | |
minChars | 200 | Shorter replies are not audited |
Cost: one extra request per turn on the session's model, plus the reply text (up to 12,000 characters) as uncached input; a cold cache (after 5 minutes idle or a model switch) resends the whole conversation.
Off by default. When on, the skill listing is trimmed to what the project kind needs (Swift, Android, Rust, web, Python, Go, detected from the repo root and one level below). Coding, quality, planning and research skills are always kept; red-team, dynamic-*, persona and operation skills are dropped; image, design, ux-scan and brand-scan are dropped for Rust, Python and Go. Only the main loop's listing is reported. A dropped skill named in a prompt is still described for that prompt.
/context-diet shows the project kind, what was kept and dropped in the latest listing, and the tokens saved (estimate). A listing it cannot read reliably goes out unchanged./context-diet on|off|reset overrides the option for this session. Switching rebuilds the listing, so the prompt cache misses once.| Option | Default | |
|---|---|---|
enabled | false | |
keep | Comma list of names or prefix* never dropped; wins over drop | |
drop | Comma list of names or prefix* always dropped |
type ‹7文字›), since the field may be a password; a URL's secrets (token parameters, userinfo, key-shaped parts) are masked./cam toggles the pane; in a fullscreen terminal it opens by itself once per session, on the first browser call. Screenshots are decoded only while the pane is open, and written to a private per-session folder that is removed at session end. A killed session's folder is removed by a later session's start once a day untouched; a running session touches its own every hour (again after a plugin reload), so it is kept while idle, though not across a day the machine sleeps.| Option | Default | |
|---|---|---|
autoOpen | true | Open on the first browser call (fullscreen terminal) |
On by default (enabled: false turns it off). A typed prompt that looks ambiguous (no done-condition and an unclear target, or only evaluative words like いい感じ) is held back, and a band shows what is missing with up to three guesses at what it meant (judged along the lines of the clarify skill: the likeliest reading first, each a different deliverable with a checkable done-condition):
a / b / d: a guess goes into the prompt to edit and send (not held again)s: このまま送る sends it unchangede: 補足して送る puts it back with 完了条件: to fill in (not held again)q: 閉じる puts it back in the promptTyping another prompt instead sends that one and puts the held text back into the prompt. The held text is never lost: when a send fails or is dropped beneath, or putting words back fails, it stays held with its band (unless another prompt was held since) and its words are shown in a toast; a prompt still held at /clear goes straight back into the box, and one held when the session quits comes back at this project's next interactive session start. Words go into an empty box as they are, and are appended after a draft typed meanwhile on a line of their own, never over it.
Slash commands, prompts under 12 or over 1500 characters, prompts with any attachment or an @ mention, prompts sent by a plugin, and prompts typed while a turn runs are not judged. A timeout or error sends the prompt unchanged; the same text is not held twice (within the last 50 judged). Sending can wait up to timeoutMs.
| Option | Default | |
|---|---|---|
enabled | true | |
model | claude-haiku-5-5 | Judging model (alias or id) |
timeoutMs | 3000 | 500 to 3000 |
Off by default. When on, the new findings of the detector mods are attached to the next prompt typed at an idle prompt, as context only the model reads, so the correction does not wait for the person to retype it:
self-audit: the violations of the latest audited replydone-gate: edits with no passing check after them (again after a check passed and new edits were left unverified; 閉じる on its band takes the flag down, and nothing is fed)sandbox-lens: denials seen this session, each onceEach finding goes back once per session, marked as data that may be wrong for Claude to check before acting. A toast says how many went back and from where. Slash commands, hidden prompts, prompts sent by a plugin and prompts typed while a turn runs carry nothing. A detector that is not installed contributes nothing.
With hit-rate on, the rules it muted are not fed (sandbox-lens denials never are muted).
/loopback shows what was fed last and the self-audit repeat rate: of the rules fed back, how many self-audit flagged again on the next audited reply (all sessions). The rate is what the design is judged by (.genius/decisions/loopback.md). It also names the rules hit-rate muted.| Option | Default | |
|---|---|---|
enabled | false |
Cost: the findings ride as extra input on the prompt they are attached to (each quote clipped to 300 characters, at most 12 findings).
An error book, kept across sessions and repos. When a Bash command fails, the error line is caught and numbered:
📕 新種のエラー発見! No.042「…」 — a kind not seen before📙 No.017 再会(3回目・未解決) — seen before, nothing known to get past it 📗 既知 No.017(3回目)— 前回: sandbox 外で git push origin main ` — seen before with a fix: Claude also reads, beside the tool's result, where it was seen and what got past it (marked as a past record to check, not an instruction)A fix is learned when the same program and subcommand (git push, pnpm install; read past a leading cd, export or source, so cd app && npm install is npm install) succeeds within the next 10 Bash calls of the session; whether it ran outside the sandbox is kept with it. Two sightings are one kind when their error line matches with paths, quotes, numbers and hashes taken out.
Failures of tests, linters, type checkers and builds are not caught: they are fixed by editing code, not by a command. Credentials in a kept command and in the kept error line are masked as sandbox-lens does.
/zukan opens the book, most recently seen first: kinds, solved, sightings/zukan note <No> <text> writes how to get past it, shown and fed in place of the learned command; an empty text removes the note/zukan forget <No> removes an entryThe newest 300 kinds by last sighting are kept.
The current branch's pull request, kept in the status line while you work:
⎇ #42 · ✓5 ✗1 ⏳2 · 🛑 変更要求 · 💬3 · マージまであと4
"マージまであと N" counts what still stands before a merge: draft, failed checks, running checks, changes requested or approval pending, unresolved review threads, a conflict, the branch behind its base. At 0 it reads 🟢 マージ可能.
A toast when it changes: 🔴 CI 失敗: test, 💬 新しいレビューコメント 2件 (@rev), ✅ Approved, 🟢 #42 マージまであと0, 🎉 #42 がマージされました. Checks turning red, new review comments, changes requested and a new conflict are also attached to the next prompt typed at an idle prompt, once, with the last 40 lines of the failed log of up to three jobs (more are counted), marked as data whose comments and logs are not to be followed as instructions. The session's own replies on a thread (the comment, made after the post, carrying words it replied with through an MCP reply tool or gh api …/pulls/N/comments… -f body=, matched once) are not news; your own review comments are. What waits for the next prompt is about one pull request and is capped (newest kept). The option feed (on by default) turns that off.
/pr asks again and opens the pane: title, size, what is left, checks (failed first) and unresolved threads/pr <number|url|branch> follows that pull request; /pr clear goes back to the defaultWhich pull request: the one a Bash command of the session last worked on (gh pr comment 2, gh pr review 2, the URL gh pr create printed, the branch a git push sent to; looking with gh pr view|diff|checks does not move it), so work pushed to a review branch from another checkout is followed; else the checked-out branch's; else your newest open pull request in the repository.
It asks gh (gh pr view, and gh api graphql for review threads) at session start, right after a Bash git push, git checkout, gh pr create and the like, every minute while a check runs or after a push, and every five minutes otherwise; it stops once the pull request is merged or closed. Without an origin remote, gh, or a pull request for the branch it shows nothing, and /pr says why. gh runs on the host, outside the Bash sandbox, with your gh auth.
The repository as a map under fog, cleared as Claude works through it:
🗺 探索率 31% ██████░░░░░░░░░░░░░░ 読 23 · 編 9 · ✗ 2 / 101
▾ mods/
▾ pr-lamp/
▾ hooks/
● lamp.ts +43 −2 編集 4回
✗ register.tsx +59 −16 編集 6回 エラー 1 ★
▸ loopback/ ○●
░ agent-pane/ ░ browser-cam/ ░ context-diet/ …8
⚠ 編集したファイルを import しているが未読: mods/pr-lamp/tests/pr-lamp.test.ts
░ nothing touched yet, ○ read (Read, or cat, sed, grep… in Bash), ● edited (Edit, Write, NotebookEdit, sed -i), ✚ made by the session, ✗ named with a line number by a failed Bash command since its last edit, ★ the file touched last. A directory holding an edit, a new file or an error is open; one only read is closed with its marks beside it; untouched directories and files at a level share one fog row.
Two warnings, each a likely oversight: a file edited without being read, and a file that imports an edited one (JS/TS and Python, found by git grep) that was never opened. A very large repository's file list is cut to what one state value holds (3 M characters of paths), so it is still mapped, partly.
/map opens the pane🗺 31% · ●9 · ✗2 · ⚠1🗺 新しい区域を開拓: mods/zukan/)The map is the session's, subagents' calls included; files outside the repository ar
hooks/register.ts 140 lines1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { ContextDietStats } from '../types'
5import { estimateTokens, filterListing, kindsOf, mentioned, patternsOf } from './profile'
6import type { Kind, Rules } from './profile'
7
8const mode = atom({ plugin: 'context-diet', key: 'mode' } as const, 'config')
9const last = atom({ plugin: 'context-diet', key: 'last' } as const, null)
10
11/** Subfolders read for markers below the root (an app's ios/ or android/), at most. */
12const SUBDIRS = 40
13const SKIPPED = new Set(['node_modules', 'build', 'dist', 'target', 'Pods', 'DerivedData'])
14
15async function projectKinds($: EngineInterface): Promise<Kind[]> {
16 const root = await $.session.root()
17 const top = await $.fs.list(root)
18 const names = top.map(entry => entry.name)
19 const dirs = top
20 .filter(entry => entry.kind === 'dir' && !entry.name.startsWith('.') && !SKIPPED.has(entry.name))
21 .slice(0, SUBDIRS)
22
23 for (const dir of dirs) {
24 const inner = await $.fs.list(`${root}/${dir.name}`).catch(() => [])
25 names.push(...inner.map(entry => entry.name))
26 }
27 return kindsOf(names)
28}
29
30/** On when the session says so, or when it left the choice to the `enabled` option. */
31async function isActive($: EngineInterface, configured: boolean): Promise<boolean> {
32 const chosen = await read($, mode)
33 return chosen === 'on' || (chosen === 'config' && configured)
34}
35
36function summary(stats: ContextDietStats | null, isActive: boolean, engineTokens: number | undefined): string {
37 const state = isActive ? 'ON' : 'OFF'
38 if (stats === null) {
39 return `context-diet: ${state}\nskill 一覧はまだ届いていません(次のリクエストで反映)。`
40 }
41
42 // What the last listing went out as, which a switch since then has not reached yet.
43 if (stats.isActive !== isActive) {
44 return `context-diet: ${state}\n次のリクエストで skill 一覧を組み直します(直前の一覧は ${stats.isActive ? '絞り込み済み' : '未加工'})。`
45 }
46 if (!stats.isActive) {
47 return `context-diet: ${state}\n直前の skill 一覧は絞り込まずに送りました。`
48 }
49 if (stats.isUncertain) {
50 return `context-diet: ${state}\n直前の skill 一覧は書式を確実に読み取れなかったため、絞り込まずに送りました。`
51 }
52
53 const saved = estimateTokens(stats.beforeChars - stats.afterChars)
54 const engine = engineTokens === undefined ? '' : ` / engine の見積り 約 ${engineTokens} tokens`
55 return [
56 `context-diet: ${state}`,
57 `プロジェクト種別: ${stats.kinds.length > 0 ? stats.kinds.join(', ') : '不明(共通ルールのみ)'}`,
58 `残した skill: ${stats.kept.length} 件 / 省いた skill: ${stats.dropped.length} 件`,
59 stats.dropped.length > 0 ? `省いた: ${stats.dropped.map(entry => entry.name).join(', ')}` : '省いた: なし',
60 `削減: 約 ${saved} tokens(推定: 文字数÷4)${engine}`,
61 '省いた skill も /名前 や名前の明記で使えます。',
62 ].join('\n')
63}
64
65export const register: Register = (on, options) => {
66 const configured = options.enabled === true
67 const keep = patternsOf(options.keep)
68 const drop = patternsOf(options.drop)
69
70 on('session.start', async ($, e, next) => {
71 await $.command.register({
72 name: 'context-diet',
73 description: 'skill 一覧の絞り込み状況と削減トークンを表示(on|off|reset で切替)',
74 argumentHint: '[on|off|reset]',
75 })
76 return next(e)
77 })
78
79 // The skill listing reaches the model as this attachment; only its entries are filtered.
80 // Every main-loop listing is recorded, cut or not, so the report never shows an earlier cut.
81 // A subagent's listing is filtered the same way but not recorded: the report, and the
82 // dropped skills a prompt may name, are the main conversation's.
83 on('prompt.attachment', { type: 'skill_listing' }, async ($, e, next) => {
84 const asSent = async (stats: Omit<ContextDietStats, 'beforeChars' | 'afterChars'>, text: string) => {
85 if (e.agentId !== undefined) return
86 await update($, last, () => ({ ...stats, beforeChars: e.text.length, afterChars: text.length }))
87 }
88
89 if (!(await isActive($, configured))) {
90 await asSent({ isActive: false, isUncertain: false, kinds: [], kept: [], dropped: [] }, e.text)
91 return next(e)
92 }
93
94 const rules: Rules = { kinds: await projectKinds($), keep, drop }
95 const filtered = filterListing(e.text, rules)
96 await asSent(
97 { isActive: true, isUncertain: filtered.isUncertain, kinds: [...rules.kinds], kept: filtered.kept, dropped: filtered.dropped },
98 filtered.text,
99 )
100 return filtered.dropped.length === 0 ? next(e) : next({ ...e, text: filtered.text })
101 }).catch(($, e, next) => next(e)) // The full listing is the safe answer.
102
103 // A dropped skill the person names is described to the model beside that prompt.
104 on('prompt.submit', async ($, e, next) => {
105 if (e.isMeta || e.command !== undefined || !(await isActive($, configured))) return next(e)
106
107 const named = mentioned(e.text, (await read($, last))?.dropped ?? [])
108 if (named.length === 0) return next(e)
109
110 const note = [
111 'context-diet: 次の skill は一覧から省いていますが、利用できます。',
112 ...named.map(entry => entry.text),
113 ].join('\n')
114 return next({ ...e, context: [...(e.context ?? []), note] })
115 }).catch(($, e, next) => next(e))
116
117 on('command.run', { command: 'context-diet' }, async ($, e) => {
118 const arg = e.args.trim()
119 if (arg === 'on' || arg === 'off' || arg === 'reset') {
120 await update($, mode, () => (arg === 'reset' ? 'config' : arg))
121 $.ui.invalidate('prompt.attachment')
122 const now = (await isActive($, configured)) ? 'ON' : 'OFF'
123 return { text: `context-diet: ${now}(次のリクエストで skill 一覧を組み直します。キャッシュが 1 回効きません)` }
124 }
125
126 const stats = await read($, last)
127 const isOn = await isActive($, configured)
128 let engineTokens: number | undefined
129 if (stats !== null && stats.dropped.length > 0) {
130 const usage = await $.session.usage({ breakdown: 'summary' }).catch(() => undefined)
131 const listed = usage?.context.breakdown?.skills?.skillFrontmatter
132 if (listed !== undefined) {
133 const dropped = new Set(stats.dropped.map(entry => entry.name))
134 engineTokens = listed.filter(skill => dropped.has(skill.name)).reduce((sum, skill) => sum + skill.tokens, 0)
135 }
136 }
137 return { text: summary(stats, isOn, engineTokens) }
138 })
139}
140hooks/profile.ts 164 lines1import type { ContextDietEntry } from '../types'
2
3export type Kind = 'swift' | 'android' | 'rust' | 'web' | 'python' | 'go'
4
5/** The files that mark a project kind, by exact name or by suffix. */
6const MARKERS: readonly { kind: Kind; names?: readonly string[]; suffixes?: readonly string[] }[] = [
7 { kind: 'swift', names: ['Package.swift'], suffixes: ['.xcodeproj', '.xcworkspace'] },
8 { kind: 'android', names: ['build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts'] },
9 { kind: 'rust', names: ['Cargo.toml'] },
10 { kind: 'web', names: ['package.json'] },
11 { kind: 'python', names: ['pyproject.toml'] },
12 { kind: 'go', names: ['go.mod'] },
13]
14
15const UI_KINDS: ReadonlySet<Kind> = new Set(['web', 'swift', 'android'])
16
17/** Kept whatever the project: the everyday families and the commands that run them. */
18const CORE = ['coding-*', 'quality-*', 'planning-*', 'research-*', 'clarify', 'plugin-authoring', 'code-review', 'simplify']
19
20/** Dropped whatever the project, unless the `keep` option names them. */
21const ALWAYS_DROP = ['redteam-*', 'dynamic-*', 'persona-*', 'operation-*']
22
23/** Kept only where the project draws a UI (or its kind is unknown). */
24const VISUAL = ['image-*', 'design-*', 'ux-scan', 'brand-scan']
25
26/** The kinds a set of file names marks, in MARKERS order. */
27export function kindsOf(names: readonly string[]): Kind[] {
28 return MARKERS.filter(
29 marker =>
30 names.some(name => marker.names?.includes(name) || marker.suffixes?.some(suffix => name.endsWith(suffix))),
31 ).map(marker => marker.kind)
32}
33
34/** A comma-separated option as patterns; blanks dropped. */
35export function patternsOf(option: unknown): string[] {
36 if (typeof option !== 'string') return []
37 return option
38 .split(',')
39 .map(part => part.trim())
40 .filter(part => part.length > 0)
41}
42
43function matches(name: string, pattern: string): boolean {
44 const bare = name.slice(name.lastIndexOf(':') + 1)
45 if (pattern.endsWith('*')) {
46 const prefix = pattern.slice(0, -1)
47 return name.startsWith(prefix) || bare.startsWith(prefix)
48 }
49 return name === pattern || bare === pattern
50}
51
52const any = (name: string, patterns: readonly string[]) => patterns.some(pattern => matches(name, pattern))
53
54export type Rules = { kinds: readonly Kind[]; keep: readonly string[]; drop: readonly string[] }
55
56/** Whether a skill stays in the listing: the options first, then the profile. */
57export function isKept(name: string, rules: Rules): boolean {
58 if (any(name, rules.keep)) return true
59 if (any(name, rules.drop)) return false
60 if (any(name, CORE)) return true
61 if (any(name, ALWAYS_DROP)) return false
62 const isUiProject = rules.kinds.length === 0 || rules.kinds.some(kind => UI_KINDS.has(kind))
63 if (!isUiProject && any(name, VISUAL)) return false
64 return true
65}
66
67type Listing = {
68 head: string[]
69 entries: { name: string; lines: string[] }[]
70 tail: string[]
71 /** False when a line looks like an entry but is not one: cutting could orphan its neighbours. */
72 isCertain: boolean
73}
74
75// A top-level entry line: `- name: description`, at column 0.
76const ENTRY = /^- (\S+?):(?:\s|$)/
77// What a skill's name looks like: lowercase words joined by - _ . and scoped by : or /.
78const SKILL_NAME = /^[a-z0-9][a-z0-9_.-]*(?:[:/][a-z0-9][a-z0-9_.-]*)*$/
79
80const isBlank = (line: string) => line.trim() === ''
81const isIndented = (line: string) => /^\s/.test(line)
82
83/**
84 * Splits a listing into its lead-in, one entry per `- name: description` line whose name has a
85 * skill's shape (with every line up to the next entry: wrapped description lines, indented
86 * paragraphs, blank lines between entries), and the text after the last entry that a blank line
87 * sets apart and that is not indented. A column-0 line shaped like an entry whose name is not a
88 * skill's (`- Note: …` inside a description) makes the parse uncertain. Whether the session can
89 * run a name is not asked: a listed skill missing from the command list is an entry like any
90 * other. Nothing is reworded: joining the parts gives the text back.
91 */
92export function parseListing(text: string): Listing {
93 const lines = text.split('\n')
94 const nameOf = (line: string) => ENTRY.exec(line)?.[1]
95
96 const starts = lines.flatMap((line, i) => {
97 const name = nameOf(line)
98 return name !== undefined && SKILL_NAME.test(name) ? [i] : []
99 })
100 const first = starts[0]
101 if (first === undefined) return { head: lines, entries: [], tail: [], isCertain: true }
102
103 const entries = starts.map((start, n) => {
104 const end = starts[n + 1] ?? lines.length
105 return { name: nameOf(lines[start] ?? '') ?? '', lines: lines.slice(start, end) }
106 })
107
108 // The last entry keeps its indented paragraphs, blank lines between them included. The tail
109 // starts at the first blank line after which the next text is not indented, or nothing follows.
110 const lastEntry = entries.at(-1)!
111 const blank = lastEntry.lines.findIndex((line, i) => {
112 if (i === 0 || !isBlank(line)) return false
113 const after = lastEntry.lines.slice(i + 1).find(next => !isBlank(next))
114 return after === undefined || !isIndented(after)
115 })
116 const tail = blank === -1 ? [] : lastEntry.lines.splice(blank)
117
118 const head = lines.slice(0, first)
119 const strays = [...head, ...entries.flatMap(entry => entry.lines.slice(1))]
120 const isCertain = !strays.some(line => nameOf(line) !== undefined)
121
122 return { head, entries, tail, isCertain }
123}
124
125export type Filtered = { text: string; kept: string[]; dropped: ContextDietEntry[]; isUncertain: boolean }
126
127/**
128 * The listing with the dropped entries left out. A listing with no entries, or one whose
129 * shape is uncertain, comes back as given: the full listing is the safe answer.
130 */
131export function filterListing(text: string, rules: Rules): Filtered {
132 const listing = parseListing(text)
133 if (listing.entries.length === 0) return { text, kept: [], dropped: [], isUncertain: false }
134 if (!listing.isCertain) return { text, kept: listing.entries.map(entry => entry.name), dropped: [], isUncertain: true }
135
136 const kept = listing.entries.filter(entry => isKept(entry.name, rules))
137 const dropped = listing.entries.filter(entry => !isKept(entry.name, rules))
138 const lines = [...listing.head, ...kept.flatMap(entry => entry.lines), ...listing.tail]
139
140 return {
141 text: lines.join('\n'),
142 kept: kept.map(entry => entry.name),
143 dropped: dropped.map(entry => ({ name: entry.name, text: entry.lines.join('\n') })),
144 isUncertain: false,
145 }
146}
147
148const escape = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
149
150/**
151 * The dropped skills a prompt names: as `/name` or as a word of its own, and a plugin's skill
152 * (`plugin:short`) also as `/short`, the way it is typed. A bare short word is not a mention.
153 */
154export function mentioned(prompt: string, dropped: readonly ContextDietEntry[]): ContextDietEntry[] {
155 const said = (pattern: string) => new RegExp(`(^|[^\\w-])${pattern}(?![\\w-])`).test(prompt)
156 return dropped.filter(entry => {
157 const short = entry.name.includes(':') ? entry.name.slice(entry.name.lastIndexOf(':') + 1) : undefined
158 return said(`/?${escape(entry.name)}`) || (short !== undefined && short !== '' && said(`/${escape(short)}`))
159 })
160}
161
162/** The tokens a cut of `chars` characters saves, by the usual four characters a token. */
163export const estimateTokens = (chars: number) => Math.max(0, Math.round(chars / 4))
164types/index.d.ts 28 lines1/** `config` follows the `enabled` option; `on` and `off` are the session's own override. */
2export type ContextDietMode = 'config' | 'on' | 'off'
3
4/** A skill entry the listing left out: its name and the lines the model would have read. */
5export type ContextDietEntry = { name: string; text: string }
6
7/** What the last listing came to, filtered or not: written for every listing the session sends. */
8export type ContextDietStats = {
9 /** Whether context-diet was on for that listing. */
10 isActive: boolean
11 /** On, but the listing's shape was not certain enough to cut: it went as it came. */
12 isUncertain: boolean
13 kinds: string[]
14 kept: string[]
15 dropped: ContextDietEntry[]
16 beforeChars: number
17 afterChars: number
18}
19
20declare module 'claude-code' {
21 interface PluginState {
22 'context-diet': {
23 mode: ContextDietMode
24 last: ContextDietStats | null
25 }
26 }
27}
28