One status line that says what is going on: the goal (the request, or the todo in progress), the target (the file, page or command in hand), what is running…

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 93 lines1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { HudState } from '../types'
5import { blank, detailOf, firstLine, lineOf, stepOf, summaryOf, targetOf } from './hud'
6
7const hud = atom({ plugin: 'focus-hud', key: 'hud' } as const, blank())
8
9const TICK_MS = 1_000
10
11let seq = 0
12let last: string | undefined
13
14async function draw($: EngineInterface, state?: HudState): Promise<void> {
15 const line = lineOf(state ?? (await read($, hud)), await $.clock.now())
16 if (line === last) return
17 last = line
18 $.ui.status(line)
19}
20
21async function change($: EngineInterface, fn: (s: HudState) => HudState): Promise<void> {
22 await draw($, await update($, hud, fn))
23}
24
25export const register: Register = on => {
26 on('session.start', async ($, e, next) => {
27 await $.command.register({ name: 'focus', description: '今の目的・対象・実行中の処理・待ち理由をまとめて表示' })
28 const started = await next(e)
29 last = undefined
30 await draw($)
31 // The seconds tick on while something runs; an idle session is not redrawn.
32 $.clock.every(TICK_MS, () => {
33 void (async () => {
34 const state = await read($, hud)
35 if (state.isRunning || state.calls.length > 0) await draw($, state)
36 })().catch(() => undefined)
37 })
38 return started
39 })
40
41 on('prompt.submit', async ($, e, next) => {
42 if (e.origin.kind === 'composer' && e.command === undefined && !e.isMeta && e.text.trim() !== '') {
43 await change($, s => ({ ...s, goal: firstLine(e.text), step: '' }))
44 }
45 return next(e)
46 }).catch(($, e, next) => next(e))
47
48 on('turn.start', async ($, e, next) => {
49 if (e.agentId === undefined) {
50 const now = await $.clock.now()
51 await change($, s => ({ ...s, isRunning: true, turnStartedAt: now }))
52 }
53 return next(e)
54 })
55
56 on('turn.complete', async ($, e, next) => {
57 if (e.agentId === undefined) await change($, s => ({ ...s, isRunning: false, calls: s.calls.filter(call => call.agentId !== undefined), asking: [] }))
58 return next(e)
59 })
60
61 on('tool.call', async ($, e, next) => {
62 const tool = String(e.tool)
63 const input = e as unknown as Record<string, unknown>
64 const id = e.tool_use_id ?? `call-${++seq}`
65 const now = await $.clock.now()
66 const target = e.agentId === undefined ? targetOf(tool, input) : undefined
67 const step = tool === 'TodoWrite' ? stepOf(input.todos) : undefined
68 await change($, s => ({
69 ...s,
70 calls: [...s.calls, { id, tool, summary: summaryOf(tool, input), startedAt: now, ...(e.agentId === undefined ? {} : { agentId: e.agentId }) }],
71 ...(target === undefined || tool === 'TodoWrite' ? {} : { target }),
72 ...(step === undefined ? {} : { step }),
73 }))
74 try {
75 return await next(e)
76 } finally {
77 await change($, s => ({ ...s, calls: s.calls.filter(call => call.id !== id), asking: s.asking.filter(one => one !== id) }))
78 }
79 }).catch(($, e, next) => next(e)) // an observer: a failure here never changes the call
80
81 // A call the person must allow: the line says so until it runs or is refused.
82 on('tool.check', async ($, e, next) => {
83 const verdict = await next(e)
84 if (verdict.decision === 'ask' && e.tool_use_id !== undefined) {
85 const id = e.tool_use_id
86 await change($, s => ({ ...s, asking: [...new Set([...s.asking, id])] }))
87 }
88 return verdict
89 }).catch(($, e, next) => next(e))
90
91 on('command.run', { command: 'focus' }, async $ => ({ text: detailOf(await read($, hud), await $.clock.now()) }))
92}
93hooks/hud.ts 97 lines1// The HUD, pure: what a call is about, and the one line drawn from the session's state.
2
3import type { HudCall, HudState } from '../types'
4
5export const blank = (): HudState => ({ goal: '', step: '', target: '', isRunning: false, turnStartedAt: 0, calls: [], asking: [] })
6
7const clip = (text: string, max: number) => {
8 const one = text.replace(/\s+/g, ' ').trim()
9 return one.length > max ? `${one.slice(0, max - 1)}…` : one
10}
11const base = (path: string) => path.slice(path.replace(/\/+$/, '').lastIndexOf('/') + 1)
12const host = (url: string) => url.replace(/^https?:\/\//, '').split(/[/?#]/)[0] ?? url
13
14export const firstLine = (text: string, max = 40): string => clip(text.split('\n').find(line => line.trim() !== '') ?? '', max)
15
16/** What a call acts on, short: a file's name, a page's host, a command's program. */
17export function targetOf(tool: string, input: Record<string, unknown>): string | undefined {
18 const str = (key: string) => (typeof input[key] === 'string' ? (input[key] as string) : undefined)
19 const path = str('file_path') ?? str('notebook_path') ?? str('path')
20 if (path !== undefined) return base(path)
21 const url = str('url')
22 if (url !== undefined) return host(url)
23 if (tool === 'Bash') {
24 const command = str('command') ?? ''
25 const words = command.replace(/^(?:\s*(?:cd\s+\S+|export\s+\S+)\s*&&\s*)+/, '').trim().split(/\s+/)
26 const first = words.find(word => !/^\w+=/.test(word)) ?? ''
27 const program = base(first)
28 const sub = words[words.indexOf(first) + 1]
29 return clip(sub !== undefined && /^[a-z][\w:-]*$/.test(sub) ? `${program} ${sub}` : program, 30)
30 }
31 const pattern = str('pattern') ?? str('query')
32 return pattern === undefined ? undefined : clip(`"${pattern}"`, 30)
33}
34
35export function summaryOf(tool: string, input: Record<string, unknown>): string {
36 const short = tool.replace(/^mcp__(?:[^_]+(?:_[^_]+)*)__/, '')
37 const target = targetOf(tool, input)
38 return target === undefined ? short : `${short} ${target}`
39}
40
41/** The todo in progress, from a TodoWrite call's list. */
42export function stepOf(todos: unknown): string | undefined {
43 if (!Array.isArray(todos)) return undefined
44 const doing = todos.find(one => typeof one === 'object' && one !== null && (one as { status?: unknown }).status === 'in_progress') as { content?: unknown; activeForm?: unknown } | undefined
45 if (doing === undefined) return ''
46 const text = typeof doing.activeForm === 'string' ? doing.activeForm : typeof doing.content === 'string' ? doing.content : ''
47 return clip(text, 40)
48}
49
50export const elapsed = (ms: number): string => {
51 const s = Math.max(0, Math.floor(ms / 1000))
52 return s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s / 60)}m${String(s % 60).padStart(2, '0')}s` : `${Math.floor(s / 3600)}h${String(Math.floor((s % 3600) / 60)).padStart(2, '0')}m`
53}
54
55const ASKING_TOOLS = new Set(['AskUserQuestion', 'ExitPlanMode'])
56const AGENT_TOOLS = new Set(['Agent', 'Task'])
57
58/** What the session waits on now, in a few words. */
59export function waitOf(s: HudState, now: number): string {
60 const asked = s.calls.find(call => s.asking.includes(call.id))
61 if (asked !== undefined) return `許可待ち: ${asked.summary}`
62 const question = s.calls.find(call => ASKING_TOOLS.has(call.tool))
63 if (question !== undefined) return 'あなたの回答待ち'
64 if (!s.isRunning) return 'あなたの入力待ち'
65 const agents = s.calls.filter(call => AGENT_TOOLS.has(call.tool))
66 const own = s.calls.filter(call => call.agentId === undefined && !AGENT_TOOLS.has(call.tool))
67 const oldest = own[0]
68 if (oldest !== undefined) return `${oldest.tool} の終了待ち (${elapsed(now - oldest.startedAt)})`
69 if (agents.length > 0) return `サブエージェント ${agents.length}件の終了待ち`
70 return `応答生成中 (${elapsed(now - s.turnStartedAt)})`
71}
72
73/** The one line: goal › step · target · running · wait. Parts with nothing to say are left out. */
74export function lineOf(s: HudState, now: number): string | undefined {
75 if (s.goal === '' && !s.isRunning && s.calls.length === 0) return undefined
76 const running = s.calls.filter(call => call.agentId === undefined)
77 const parts = [
78 s.goal === '' ? '' : `🎯 ${s.goal}${s.step === '' ? '' : ` › ${s.step}`}`,
79 s.target === '' ? '' : `📄 ${s.target}`,
80 running.length === 0 ? '' : `⚙ ${running.at(-1)?.summary}${running.length > 1 ? ` +${running.length - 1}` : ''}`,
81 `⏳ ${waitOf(s, now)}`,
82 ]
83 return parts.filter(Boolean).join(' · ')
84}
85
86/** The detail /focus answers with. */
87export function detailOf(s: HudState, now: number): string {
88 const rows = [
89 `目的: ${s.goal || '(まだ依頼がありません)'}`,
90 `手順: ${s.step || '—'}`,
91 `対象: ${s.target || '—'}`,
92 `実行中: ${s.calls.length === 0 ? '—' : s.calls.map((call: HudCall) => `${call.summary}${call.agentId === undefined ? '' : '(サブエージェント)'} ${elapsed(now - call.startedAt)}`).join(' / ')}`,
93 `待ち: ${waitOf(s, now)}`,
94 ]
95 return rows.join('\n')
96}
97types/index.d.ts 28 lines1/** A tool call under way. */
2export type HudCall = { id: string; tool: string; summary: string; startedAt: number; agentId?: string }
3
4/** What the line is drawn from. */
5export type HudState = {
6 /** The person's latest request, first line. */
7 goal: string
8 /** The todo list's item in progress, if any. */
9 step: string
10 /** The file, page or program last acted on. */
11 target: string
12 /** Whether a turn of the main loop runs, and since when. */
13 isRunning: boolean
14 turnStartedAt: number
15 /** Calls under way, oldest first. */
16 calls: HudCall[]
17 /** Calls waiting on the person's permission, by id. */
18 asking: string[]
19}
20
21declare module 'claude-code' {
22 interface PluginState {
23 'focus-hud': {
24 hud: HudState
25 }
26 }
27}
28