agent-tree

1import type { Register } from 'claude-code'
2
3import { registerPane } from '../src/pane'
4import { registerSession } from '../src/session'
5import { registerTree } from '../src/tree'
6
7export { webLines } from '../src/pane'
8
9export const register: Register = (on, options) => {
10  registerSession(on, options)
11  registerTree(on, options)
12  registerPane(on, options)
13}
14

1import { atom, read } from 'claude-code'
2import type { Register } from 'claude-code'
3
4import type { AgentNode, AgentStatus, Web } from '../types'
5import { contextText, costText, head, k, pageUrl, secs, tokens, usd } from './format'
6import { INITIAL_TREE, INITIAL_WEB } from './state'
7import { FIRST_PORT, PORT_TRIES } from './web/server'
8
9const PANE = 'agent-tree' // a literal here, for the scan; the same id as state's PANE
10
11const tree = atom({ plugin: 'agent-tree', key: 'tree' } as const, INITIAL_TREE)
12const web = atom({ plugin: 'agent-tree', key: 'web' } as const, INITIAL_WEB)
13
14const NARROW = 70 // below this many columns each detail gets its own line
15const LAST_PORT = FIRST_PORT + PORT_TRIES - 1
16const LABEL: Record<AgentStatus, string> = { running: 'running', done: 'ok', error: 'error', aborted: 'aborted' }
17
18// the pane's lines about the page: its address, or why there is none
19export const webLines = (w: Web, isNarrow: boolean): string[] => {
20  if (w.status === 'starting') return ['Web: starting…']
21  if (w.status === 'failed') {
22    return [w.error === 'EADDRINUSE' ? `Web: ports ${FIRST_PORT}-${LAST_PORT} in use` : `Web: ${w.error}`]
23  }
24  const url = `Web: ${pageUrl(w.port, w.token)}`
25  if (w.busy.length === 0) return [url]
26  const note = `${w.busy.join(', ')} in use`
27
28  return isNarrow ? [url, `  ${note}`] : [`${url} (${note})`]
29}
30
31// the lines of a node: joined on a wide pane, one detail per line on a narrow one
32const detailLines = (a: AgentNode, isNarrow: boolean): string[] => {
33  const toolCount = `${a.tools} tool${a.tools === 1 ? '' : 's'}`
34  const usage = a.status === 'running' ? [toolCount] : [tokens(a), `${toolCount} · ${secs(a.durationMs)}`]
35  const spend = [costText(a), contextText(a)].filter(s => s !== '')
36  const lines = isNarrow
37    ? [`[${LABEL[a.status]}] ${a.type}`, head(a), a.description, ...usage, ...spend]
38    : [`[${LABEL[a.status]}] ${a.type} · ${head(a)}`, [a.description, ...usage].join(' · '), ...(spend.length > 0 ? [spend.join(' · ')] : [])]
39
40  return a.summary === '' ? lines : [...lines, a.summary]
41}
42
43// draws the pane: the orchestrator, its subagents and the page's address
44export const registerPane: Register = on => {
45  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
46    const { Box, Text } = $.ui.resolve(e)
47    const { main, agents } = await read($, tree)
48    const w = await read($, web)
49    const cols = e.props.bodyColumns
50    const isNarrow = cols < NARROW
51    // cuts a line to the pane width, so it never wraps
52    const fit = (s: string) => (s.length > cols ? `${s.slice(0, Math.max(1, cols - 1))}…` : s)
53    const sumIn = agents.reduce((s, a) => s + a.tokensIn, 0)
54    const sumOut = agents.reduce((s, a) => s + a.tokensOut, 0)
55    const sumCost = agents.reduce((s, a) => s + (a.costUsd ?? 0), 0)
56    const mainSpend = [costText(main), contextText(main)].filter(s => s !== '').join(' · ')
57
58    return (
59      <Box flexDirection="column">
60        <Text mono weight="bold">{fit(isNarrow ? 'Main session' : `Main session · ${head(main)}`)}</Text>
61        {isNarrow && <Text mono dimColor>{fit(`  ${head(main)}`)}</Text>}
62        <Text mono dimColor>{fit(`  ${tokens(main)}`)}</Text>
63        {mainSpend !== '' && <Text mono dimColor>{fit(`  ${mainSpend}`)}</Text>}
64        {agents.length === 0 && <Text mono dimColor>{fit('└─ no subagents this round')}</Text>}
65        {agents.map((a, i) => {
66          const isLast = i === agents.length - 1
67          const [first = '', ...rest] = detailLines(a, isNarrow)
68
69          return (
70            <Box flexDirection="column">
71              <Text mono color={a.status === 'error' ? 'error' : undefined} dimColor={a.status === 'done'}>
72                {fit(`${isLast ? '└─' : '├─'} ${first}`)}
73              </Text>
74              {rest.map(line => <Text mono dimColor>{fit(`${isLast ? '   ' : '│  '}  ${line}`)}</Text>)}
75            </Box>
76          )
77        })}
78        {agents.length > 0 && <Text mono dimColor>{fit(`Subagents: ${k(sumIn)} in / ${k(sumOut)} out${sumCost > 0 ? ` · ~${usd(sumCost)}` : ''}`)}</Text>}
79        {webLines(w, isNarrow).map(line => (
80          <Text mono dimColor={w.status !== 'failed'} color={w.status === 'failed' ? 'warning' : undefined}>{fit(line)}</Text>
81        ))}
82      </Box>
83    )
84  })
85}
86

1import type { Register } from 'claude-code'
2
3import { choose } from './view'
4import { serve } from './web/serve'
5
6// the session's start (server, question, command) and the command that asks again
7export const registerSession: Register = on => {
8  on('session.start', async ($, e, next) => {
9    // the server lives as long as the session: its child ends with the module
10    void serve($)
11    void choose($)
12    await $.command.register({ name: 'agent-tree', description: 'Choose how to see the agent tree' })
13
14    return next(e)
15  })
16
17  on('command.run', { command: 'agent-tree' }, async $ => {
18    void choose($)
19
20    return { text: 'Choose how to see the agents.' }
21  })
22}
23

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register, TurnUsage } from 'claude-code'
3
4import type { AgentNode, AgentStatus, Tree } from '../types'
5import { callLabel, costText } from './format'
6import { costOf, rate, windowOf } from './pricing'
7import { INITIAL_TREE, MAX_AGENTS, MAX_ANSWER, MAX_CALLS, node } from './state'
8import { push } from './web/serve'
9
10const tree = atom({ plugin: 'agent-tree', key: 'tree' } as const, INITIAL_TREE)
11
12const STATUS: Record<string, AgentStatus> = { answer: 'done', aborted: 'aborted', error: 'error', refusal: 'error' }
13
14const save = async ($: EngineInterface, fn: (t: Tree) => Tree) => {
15  await update($, tree, fn)
16  void push($)
17}
18
19// applies fn to the node of the loop (a subagent by id, or the main one)
20const patch = (t: Tree, agentId: string | undefined, fn: (n: AgentNode) => AgentNode): Tree =>
21  agentId === undefined
22    ? { ...t, main: fn(t.main) }
23    : { ...t, agents: t.agents.map(a => (a.id === agentId ? fn(a) : a)) }
24
25const addUsage = (n: AgentNode, u?: TurnUsage): AgentNode => !u ? n : {
26  ...n,
27  tokensIn: n.tokensIn + u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens,
28  cacheRead: n.cacheRead + u.cache_read_input_tokens,
29  tokensOut: n.tokensOut + u.output_tokens,
30}
31
32// one request: how much its prompt filled the context, and what it cost (nothing, if the model has no price)
33const addRequest = (n: AgentNode, u: TurnUsage): AgentNode => {
34  const cost = costOf(u.model, u)
35
36  return {
37    ...n,
38    contextTokens: u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens,
39    contextWindow: windowOf(u.model) ?? n.contextWindow,
40    costUsd: cost === undefined ? n.costUsd : (n.costUsd ?? 0) + cost,
41    // a request on a model with no price leaves the total short: it is shown as such, and not rated
42    isCostPartial: n.isCostPartial === true || cost === undefined || undefined,
43  }
44}
45
46// keeps the tree of the orchestrator and its subagents up to date from the loop's events
47export const registerTree: Register = on => {
48  // a new user prompt: mark the tree to be cleared on the next spawn
49  on('turn.start', async ($, e, next) => {
50    if (e.agentId === undefined && e.text !== '') await update($, tree, t => ({ ...t, isStale: true }))
51
52    return next(e)
53  })
54
55  on('agent.spawn', async ($, e, next) => {
56    const spawned = await next(e)
57    if (spawned.agentId === undefined) return spawned
58
59    const added = { ...node(spawned.agentId, e.subagentType, e.description, spawned.model), parentId: e.parentAgentId }
60    await save($, t => {
61      const kept = t.isStale ? t.agents.filter(a => a.status === 'running') : t.agents
62
63      return { ...t, isStale: false, agents: [...kept, added].slice(-MAX_AGENTS) }
64    })
65
66    return spawned
67  })
68
69  // the real model and effort of each request, and what each request cost and filled
70  on('turn.step', async function* ($, e, next) {
71    await save($, t => patch(t, e.agentId, n => ({ ...n, model: e.model, effort: e.effort?.toString() })))
72
73    // the chunks pass through unchanged; the one that stops the request carries its usage
74    const stream = next(e)
75    try {
76      for (;;) {
77        const step = await stream.next()
78        if (step.done) return step.value
79
80        const chunk = step.value
81        if (chunk.kind === 'stop' && chunk.usage) {
82          const usage = chunk.usage
83          await save($, t => patch(t, e.agentId, n => addRequest(n, usage)))
84        }
85        yield chunk
86      }
87    } finally {
88      // what `yield*` did on its own: an interrupted request closes the stream beneath
89      await stream.return(undefined as never)
90    }
91  })
92
93  on('tool.call', async ($, e, next) => {
94    // SubagentHandback is how a subagent hands its report back: not work worth listing
95    if (e.agentId !== undefined && e.tool !== 'SubagentHandback') {
96      const call = callLabel({ ...e })
97      await save($, t => patch(t, e.agentId, n => ({ ...n, tools: n.tools + 1, calls: [...n.calls, call].slice(-MAX_CALLS) })))
98    }
99
100    return next(e)
101  })
102
103  on('turn.complete', async ($, e, next) => {
104    const done = await next(e)
105    await save($, t => patch(t, e.agentId, n => {
106      const used = addUsage(n, e.usage)
107      if (e.agentId === undefined) return used
108
109      return {
110        ...used,
111        status: STATUS[e.reason] ?? 'done',
112        durationMs: n.durationMs + e.durationMs,
113        summary: (e.answer.trim().split('\n')[0] ?? '').slice(0, 200),
114        answer: e.answer.trim().slice(0, MAX_ANSWER),
115        // a verdict on a run that ended with its answer and whose whole cost is known: a run that was
116        // stopped or failed would read as praise for doing nothing
117        rating: used.costUsd === undefined || used.isCostPartial || STATUS[e.reason] !== 'done' ? undefined : rate(used.costUsd),
118      }
119    }))
120
121    // a subagent finished: say so, and a failed or aborted one louder
122    if (e.agentId !== undefined) {
123      const agent = (await read($, tree)).agents.find(a => a.id === e.agentId)
124      if (agent !== undefined) {
125        const cost = costText(agent)
126        const what = `${agent.type}: ${agent.description}${cost === '' ? '' : ` · ${cost}`}`
127        if (agent.status === 'done') $.ui.toast(`Agent finished · ${what}`)
128        else {
129          $.ui.toast(`Agent ${agent.status === 'aborted' ? 'aborted' : 'failed'} · ${what}`)
130          // an abort is usually the user's own doing (Esc stops every agent): only a failure notifies
131          if (agent.status === 'error') void $.ui.notify(what, { title: 'Agent failed' }).catch(() => undefined)
132        }
133      }
134    }
135
136    return done
137  })
138}
139

1import type { AgentNode } from '../types'
2
3const DETAIL_KEYS = ['file_path', 'command', 'pattern', 'path', 'url', 'query', 'description', 'prompt']
4
5// a tool call as one line: the tool and the first thing it was given (`Grep: useState`)
6export const callLabel = (call: { tool: string; [input: string]: unknown }): string => {
7  const key = DETAIL_KEYS.find(name => typeof call[name] === 'string')
8  const detail = key === undefined ? '' : String(call[key]).replace(/\s+/g, ' ').trim().slice(0, 80)
9
10  return detail === '' ? call.tool : `${call.tool}: ${detail}`
11}
12
13// an estimated cost in USD: more digits for the cents a small agent costs (the limits sit just
14// under 0.01 and 1, so a cost that rounds up to them never shows as `$0.0100` or `$1.000`)
15export const usd = (cost: number) => `$${cost < 0.00995 ? cost.toFixed(4) : cost < 0.9995 ? cost.toFixed(3) : cost.toFixed(2)}`
16
17// `~$0.0123 · ok`: the estimated cost, and the verdict once a subagent has ended; '' with no price
18// (a `+` after the cost: a request on a model with no price is not in it)
19export const costText = (n: AgentNode): string =>
20  n.costUsd === undefined ? '' : `~${usd(n.costUsd)}${n.isCostPartial ? '+' : ''}${n.rating === undefined ? '' : ` · ${n.rating}`}`
21
22// `ctx 126.0k / 1.0M (13%)`: what the last request's prompt held, against the window the mod assumes
23// for the model (shown, so a smaller real window is not hidden); '' before any request
24export const contextText = (n: AgentNode): string => {
25  if (n.contextTokens === 0) return ''
26  const share = n.contextWindow > 0
27    ? ` / ${k(n.contextWindow)} (${Math.max(1, Math.round((n.contextTokens / n.contextWindow) * 100))}%)`
28    : ''
29
30  return `ctx ${k(n.contextTokens)}${share}`
31}
32
33// where the page is, with the key its data needs
34export const pageUrl = (port: number, token: string) => `http://127.0.0.1:${port}/?t=${token}`
35
36export const k = (n: number) => (n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`)
37export const secs = (ms: number) => `${(ms / 1000).toFixed(1)}s`
38export const short = (model: string) => model.replace(/^claude-/, '')
39export const tokens = (n: AgentNode) => `${k(n.tokensIn)} in (${k(n.cacheRead)} cache) / ${k(n.tokensOut)} out`
40export const head = (n: AgentNode) => [short(n.model) || '?', n.effort].filter(Boolean).join(' · ')
41

1import type { AgentNode, Tree, View, Web } from '../types'
2
3// The engine's scan reads an atom's reference only where `read`/`update` use it, so each file
4// declares its own `atom({ plugin: 'agent-tree', key }, ...)`; what they share lives here.
5
6export const PANE = 'agent-tree'
7export const MAX_AGENTS = 20
8export const MAX_CALLS = 50 // tool calls kept per agent
9export const MAX_ANSWER = 4000 // characters of an agent's answer kept
10
11export const node = (id: string, type: string, description: string, model: string): AgentNode => ({
12  id, type, description, model,
13  status: 'running', tokensIn: 0, cacheRead: 0, tokensOut: 0, tools: 0, contextTokens: 0, contextWindow: 0, calls: [], durationMs: 0, summary: '', answer: '',
14})
15
16export const INITIAL_TREE: Tree = { main: node('main', 'Main session', '', ''), agents: [], isStale: false }
17export const INITIAL_WEB: Web = { status: 'starting', port: 0, token: '', busy: [], error: '' }
18export const INITIAL_VIEW: View = { chosen: false, pane: false, web: false, window: false, isShown: false }
19

1// The local page's server: a Node script with no dependencies, handed to `node -` on
2// stdin, so the mod needs no path to its own folder. It prints one line per event the
3// mod reads: `BUSY <port>`, `LISTEN <port> <key>` or `FAILED <port> <code>`.
4// POST /state takes the tree as JSON; GET /events streams it (server-sent events); any
5// other GET answers the page. Only 127.0.0.1 is bound, a foreign Host is refused, and
6// /state and /events need the key the server made when it started (`?t=<key>`): the tree
7// holds commands and answers, so another local process or a website must not read or
8// replace it. The page itself holds no data, so it is served without the key.
9
10export const FIRST_PORT = 47821
11export const PORT_TRIES = 10
12
13export const serverSource = (page: string, icon: string): string => String.raw`
14const http = require('http');
15const crypto = require('crypto');
16const FIRST = ${FIRST_PORT}, LAST = ${FIRST_PORT + PORT_TRIES - 1};
17const PAGE = ${JSON.stringify(page)};
18const ICON = ${JSON.stringify(icon)};
19const KEY = crypto.randomBytes(8).toString('hex');
20let state = 'null';
21const clients = new Set();
22
23const server = http.createServer((req, res) => {
24  if (!/^(127\.0\.0\.1|localhost):\d+$/.test(req.headers.host || '')) { res.writeHead(403); res.end(); return; }
25  const url = new URL(req.url, 'http://127.0.0.1');
26  if (url.pathname === '/favicon.png') { res.writeHead(200, { 'content-type': 'image/png' }); res.end(Buffer.from(ICON, 'base64')); return; }
27  const isData = url.pathname === '/state' || url.pathname === '/events';
28  if (isData && url.searchParams.get('t') !== KEY) { res.writeHead(403); res.end(); return; }
29  if (req.method === 'POST' && url.pathname === '/state') {
30    let body = '';
31    req.on('data', c => { body += c; if (body.length > 1e6) req.destroy(); });
32    req.on('end', () => {
33      state = body;
34      for (const c of clients) c.write('data: ' + state + '\n\n');
35      res.end();
36    });
37    return;
38  }
39  if (url.pathname === '/events') {
40    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
41    res.write('data: ' + state + '\n\n');
42    clients.add(res);
43    req.on('close', () => clients.delete(res));
44    return;
45  }
46  res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
47  res.end(PAGE);
48});
49
50let port = FIRST;
51server.on('error', err => {
52  if (err.code !== 'EADDRINUSE') { console.log('FAILED ' + port + ' ' + err.code); process.exit(1); }
53  console.log('BUSY ' + port);
54  if (port === LAST) { console.log('FAILED ' + port + ' EADDRINUSE'); process.exit(1); }
55  port++;
56  server.listen(port, '127.0.0.1');
57});
58server.on('listening', () => console.log('LISTEN ' + port + ' ' + KEY));
59server.listen(port, '127.0.0.1');
60`
61

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface } from 'claude-code'
3
4import { optionsFor, parseChoice, QUESTION } from './choice'
5import { pageUrl } from './format'
6import { INITIAL_VIEW, INITIAL_WEB, PANE } from './state'
7import { openWindow } from './web/window'
8
9const web = atom({ plugin: 'agent-tree', key: 'web' } as const, INITIAL_WEB)
10const view = atom({ plugin: 'agent-tree', key: 'view' } as const, INITIAL_VIEW)
11
12async function isWindows($: EngineInterface) {
13  const run = await $.process.run(['cmd', '/c', 'ver']).catch(() => undefined)
14
15  return run?.exitCode === 0
16}
17
18// Shows the page the way the user chose, once both the choice and the server's port are known:
19// whichever comes last calls it, and it acts once. (Function declarations: the engine follows
20// `$` across files only into those.)
21export async function reveal($: EngineInterface) {
22  const w = await read($, web)
23  const v = await read($, view)
24  if (!v.chosen || v.isShown || w.status !== 'listening') return
25
26  await update($, view, x => ({ ...x, isShown: true }))
27  const url = pageUrl(w.port, w.token)
28  if (v.web) {
29    $.ui.toast(`Agent Tree: ${url}`)
30    $.ui.status(`Agent Tree: ${url}`)
31  }
32  if (v.window) await openWindow($, url)
33}
34
35// asks how to see the agents, in the engine's own question dialog, and applies the answer
36export async function choose($: EngineInterface) {
37  const options = optionsFor(await isWindows($))
38  const answer = await $.ui.ask(QUESTION, { options, header: 'Agent Tree', multiSelect: true }).catch(() => '')
39  const picked = parseChoice(answer)
40
41  await update($, view, () => ({ ...picked, chosen: true, isShown: false }))
42  if (picked.pane) await $.ui.open({ id: PANE, title: 'Agents' })
43  await reveal($)
44}
45

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface } from 'claude-code'
3
4import { INITIAL_TREE, INITIAL_WEB } from '../state'
5import { reveal } from '../view'
6import { ICON } from './icon'
7import { PAGE } from './page'
8import { serverSource } from './server'
9
10const tree = atom({ plugin: 'agent-tree', key: 'tree' } as const, INITIAL_TREE)
11const web = atom({ plugin: 'agent-tree', key: 'web' } as const, INITIAL_WEB)
12
13const PUSH_GAP_MS = 100 // at most about ten sends a second, however many events come
14
15// one send at a time: a burst of events (parallel agents) is folded into the next send, and
16// what is sent is always the latest tree, so a slow request cannot land after a newer one
17let isSending = false
18let isDirty = false
19
20// sends the tree to the local page, when its server listens
21// (function declarations: the engine follows `$` across files only into those)
22export async function push($: EngineInterface) {
23  isDirty = true
24  if (isSending) return
25  isSending = true
26  try {
27    while (isDirty) {
28      isDirty = false
29      const w = await read($, web)
30      if (w.status !== 'listening') return
31      const body = JSON.stringify(await read($, tree))
32      await $.http.fetch(`http://127.0.0.1:${w.port}/state?t=${w.token}`, { method: 'POST', body }).catch(() => undefined)
33      await $.clock.sleep(PUSH_GAP_MS).catch(() => undefined)
34    }
35  } finally {
36    isSending = false
37  }
38}
39
40// runs the page's server for the module's life, reading the lines it prints
41export async function serve($: EngineInterface) {
42  await update($, web, () => INITIAL_WEB)
43  try {
44    let rest = ''
45    for await (const { stream, text } of $.process.spawn({ argv: ['node', '-'], input: serverSource(PAGE, ICON) })) {
46      if (stream !== 'stdout') continue
47      const lines = (rest + text).split('\n')
48      rest = lines.pop() ?? ''
49      for (const line of lines) {
50        // BUSY <port>, LISTEN <port> <key>, FAILED <port> <code>
51        const [word = '', port = '', code = ''] = line.trim().split(' ')
52        if (word === 'BUSY') await update($, web, w => ({ ...w, busy: [...w.busy, Number(port)] }))
53        if (word === 'FAILED') await update($, web, w => ({ ...w, status: 'failed', error: code }))
54        if (word === 'LISTEN') {
55          await update($, web, w => ({ ...w, status: 'listening', port: Number(port), token: code }))
56          await push($)
57          await reveal($)
58        }
59      }
60    }
61    await update($, web, w => (w.status === 'failed' ? w : { ...w, status: 'failed', error: 'server stopped' }))
62  } catch {
63    await update($, web, w => ({ ...w, status: 'failed', error: 'node not found' })).catch(() => undefined)
64  }
65}
66

1import type { CostRating } from '../types'
2
3type Usage = {
4  input_tokens: number
5  output_tokens: number
6  cache_read_input_tokens: number
7  cache_creation_input_tokens: number
8}
9
10// A price row: USD per million tokens, and the model's context window in tokens. `cacheRead` is
11// stated where it is not the usual tenth of the input price; `over` is a dearer tier for a
12// prompt longer than `tokens`.
13type Price = { in: number; out: number; window: number; cacheRead?: number; over?: { tokens: number; in: number; out: number } }
14
15const M = 1_000_000
16
17// List prices of Anthropic's own API (the claude-api reference, cached 2026-10-06). They change:
18// the cost the mod shows is an estimate, and a model missing here shows no cost at all.
19// A model id matches the longest key it contains, so `claude-opus-5-5` wins over `claude-opus-5`.
20const PRICES: Record<string, Price> = {
21  'claude-fable-5': { in: 10, out: 50, window: M, cacheRead: 0.25 },
22  'claude-mythos-5': { in: 10, out: 50, window: M, cacheRead: 0.25 },
23  'claude-opus-5': { in: 5, out: 25, window: M },
24  'claude-opus-5-5': { in: 4, out: 20, window: M, cacheRead: 0.2 },
25  // only the 4.x models whose price is confirmed: an older one (4, 4.1, 4.5) shows no cost rather than a wrong one
26  'claude-opus-4-6': { in: 5, out: 25, window: M },
27  'claude-opus-4-7': { in: 5, out: 25, window: M },
28  'claude-opus-4-8': { in: 5, out: 25, window: M },
29  'claude-sonnet-5': { in: 2, out: 10, window: M },
30  'claude-sonnet-5-5': { in: 2, out: 10, window: M, cacheRead: 0.2 },
31  'claude-sonnet-4-6': { in: 3, out: 15, window: M },
32  'claude-haiku-5-5': { in: 0.1, out: 0.5, window: M, over: { tokens: 100_000, in: 0.5, out: 2.5 } },
33  'claude-haiku-4-5': { in: 1, out: 5, window: 200_000 },
34}
35
36const WRITE_FACTOR = 1.25 // writing the prompt cache (5-minute) costs this much times the input price
37const READ_FACTOR = 0.1 // reading it costs this much, unless the row says otherwise
38
39const KEYS = Object.keys(PRICES).sort((a, b) => b.length - a.length) // longest first, once
40
41const priceOf = (model: string): Price | undefined => {
42  const key = KEYS.find(name => model.includes(name))
43
44  return key === undefined ? undefined : PRICES[key]
45}
46
47export const windowOf = (model: string): number | undefined => priceOf(model)?.window
48
49// what one request cost, in USD; undefined for a model with no price row
50export const costOf = (model: string, usage: Usage): number | undefined => {
51  const price = priceOf(model)
52  if (price === undefined) return undefined
53
54  const prompt = usage.input_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens
55  const tier = price.over !== undefined && prompt > price.over.tokens ? price.over : price
56  const read = (price.cacheRead ?? price.in * READ_FACTOR) * (tier.in / price.in)
57
58  return (
59    usage.input_tokens * tier.in +
60    usage.cache_creation_input_tokens * tier.in * WRITE_FACTOR +
61    usage.cache_read_input_tokens * read +
62    usage.output_tokens * tier.out
63  ) / M
64}
65
66// A verdict on what a subagent spent, not on how well it worked: the estimated cost of its whole
67// run against these ceilings, in USD. Change them here to suit the budget.
68const CEILINGS: readonly [CostRating, number][] = [
69  ['perfect', 0.03],
70  ['ok', 0.15],
71  ['fair', 0.6],
72  ['poor', 2],
73]
74
75export const rate = (costUsd: number): CostRating => CEILINGS.find(([, ceiling]) => costUsd <= ceiling)?.[0] ?? 'awful'
76

1import type { View } from '../types'
2
3export const QUESTION = 'How do you want to see the agent orchestration?'
4
5export const LABEL = { pane: 'Agents pane', web: 'Web page', window: 'Edge window' } as const
6
7// the window needs Edge, so it is offered on Windows only
8export const optionsFor = (isWindows: boolean): string[] =>
9  isWindows ? [LABEL.pane, LABEL.web, LABEL.window] : [LABEL.pane, LABEL.web]
10
11// the answer is the labels chosen, comma-joined; anything else (free text, a dismissed
12// dialog) falls back to the pane, so the user always sees something
13export const parseChoice = (answer: string): Pick<View, 'pane' | 'web' | 'window'> => {
14  const picked = answer.split(',').map(s => s.trim())
15  const view = {
16    pane: picked.includes(LABEL.pane),
17    web: picked.includes(LABEL.web),
18    window: picked.includes(LABEL.window),
19  }
20
21  return view.pane || view.web || view.window ? view : { pane: true, web: false, window: false }
22}
23

1import type { EngineInterface } from 'claude-code'
2
3// Opens the page as its own window (Edge's app mode: no tabs, no address bar).
4// A function declaration: the engine follows `$` across files only into those.
5export async function openWindow($: EngineInterface, url: string) {
6  // `start` finds Edge through Windows' app paths, so no install path is needed
7  await $.process.run(['cmd', '/c', 'start', '', 'msedge', `--app=${url}`]).catch(() => undefined)
8}
9