mantra

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { MantraLive, MantraTool } from '../types'
5import { clip, fmtClock, hash, toolDetail, toolGlyph, toolName } from './lib/kz.ts'
6
7// Word packs: every word written for KOZMOS. The spinner keeps the engine's
8// ellipsis and timer; only the word and the tail after it change.
9const PACKS: Readonly<Record<string, readonly string[]>> = {
10  cosmic: [
11    'Warping', 'Orbiting', 'Stargazing', 'Drifting', 'Slingshotting', 'Terraforming', 'Comet-chasing',
12    'Moonwalking', 'Docking', 'Hyperjumping', 'Gravitating', 'Eclipsing', 'Pulsating', 'Spacewalking',
13    'Star-charting', 'Accreting', 'Ionizing', 'Coalescing', 'Redshifting', 'Transiting', 'Quasar-hunting',
14    'Nebula-weaving', 'Starhopping', 'Igniting', 'Free-falling', 'Aligning planets', 'Beaming down',
15  ],
16  zen: [
17    'Breathing', 'Contemplating', 'Raking sand', 'Steeping', 'Pondering', 'Settling', 'Centering',
18    'Listening', 'Unfolding', 'Balancing', 'Sitting still', 'Noticing', 'Letting go', 'Arranging stones',
19    'Watering', 'Pruning', 'Flowing', 'Softening', 'Grounding', 'Releasing', 'Pouring tea', 'Folding paper',
20    'Observing', 'Stilling', 'Rippling', 'Sweeping the path', 'Lighting incense',
21  ],
22  pirate: [
23    'Plundering', 'Hoisting sails', 'Swashbuckling', 'Charting courses', 'Parleying', 'Keelhauling',
24    'Marooning', 'Boarding', 'Splicing the mainbrace', 'Swabbing decks', 'Dropping anchor', 'Sailing',
25    'Treasure-hunting', 'Spyglassing', 'Navigating', 'Mutinying', 'Firing cannons', 'Looting', 'Tacking',
26    'Yo-ho-hoing', 'Pumping bilge', 'Belaying', 'Climbing rigging', 'Pillaging', 'Reading the map',
27    'Burying gold', 'Raising the flag',
28  ],
29  turkish: [
30    'Düşünüyor', 'Kurcalıyor', 'Demleniyor', 'Harmanlıyor', 'Yoğuruyor', 'Kurguluyor', 'Didikliyor',
31    'Eşeliyor', 'Örüyor', 'Süzüyor', 'Tartıyor', 'Ayıklıyor', 'Pişiriyor', 'Mayalanıyor', 'Kavuruyor',
32    'Ölçüp biçiyor', 'Toparlıyor', 'Çözümlüyor', 'Tasarlıyor', 'Karıştırıyor', 'Damıtıyor', 'Tarıyor',
33    'Dokuyor', 'Şekillendiriyor', 'Hesaplıyor', 'Ayarlıyor', 'Cilalıyor', 'Kafa yoruyor',
34  ],
35  hacker: [
36    'Compiling', 'Grepping', 'Piping', 'Forking', 'Hashing', 'Fuzzing', 'Patching', 'Bootstrapping',
37    'Spelunking', 'Decrypting', 'Rebasing', 'Bit-twiddling', 'Tunneling', 'Sniffing packets', 'Overclocking',
38    'Refactoring', 'Linking', 'Disassembling', 'Recursing', 'Caching', 'Daemonizing', 'Hot-swapping',
39    'Defragging', 'Yak-shaving', 'Multiplexing', 'Grokking', 'Pinging',
40  ],
41}
42const PACK_NAMES = Object.keys(PACKS)
43const ROTATE_MS = 4000
44
45const blank = (): MantraLive => ({ tools: {}, agents: [], isWorking: false, turnSeed: 0, now: 0 })
46const liveAtom = atom({ plugin: 'mantra', key: 'live' } as const, blank())
47const packAtom = atom({ plugin: 'mantra', key: 'pack' } as const, '')
48const onAtom = atom({ plugin: 'mantra', key: 'isOn' } as const, true)
49
50let live: MantraLive = blank()
51let lastPublished = ''
52
53async function publish($: EngineInterface): Promise<void> {
54  live.now = await $.clock.now()
55  const busy = live.isWorking || Object.keys(live.tools).length > 0
56  // While nothing runs the clock does not matter: an idle line never redraws.
57  const key = JSON.stringify({ ...live, now: busy ? Math.floor(live.now / 1000) : 0 })
58  if (key === lastPublished) return
59  lastPublished = key
60  const snap: MantraLive = { ...live, tools: { ...live.tools }, agents: [...live.agents] }
61  await update($, liveAtom, () => snap)
62}
63
64/** Publishes in the background: a failed publish only skips one redraw. */
65function kick($: EngineInterface): void {
66  void publish($).catch(() => undefined)
67}
68
69/** What the tail calls a tool: the command for a shell, the file or pattern otherwise. */
70function toolLabel(tool: string, input: unknown): string {
71  const e = input as Record<string, unknown>
72  if ((tool === 'Bash' || tool === 'PowerShell') && typeof e.command === 'string') return clip(e.command.replace(/\n[\s\S]*/, ''), 28)
73  return clip(toolDetail(tool, input) || toolName(tool), 28)
74}
75
76/** The pack's word for this spinner now: deterministic per turn, instance and 4 s slot. */
77function wordAt(words: readonly string[], requestId: string, seed: number, now: number): string {
78  const start = hash(`${requestId}:${seed}`) % words.length
79  return words[(start + Math.floor(now / ROTATE_MS)) % words.length] as string
80}
81
82async function setPack($: EngineInterface, pack: string): Promise<void> {
83  await update($, packAtom, () => pack)
84  await $.store.set('pack', pack)
85}
86
87async function setOn($: EngineInterface, isOn: boolean): Promise<void> {
88  await update($, onAtom, () => isOn)
89  await $.store.set('isOn', isOn)
90}
91
92export const register: Register = (on, options) => {
93  // The engine holds `pack` to the manifest's options (default cosmic).
94  const defaultPack = String(options.pack)
95
96  on('session.start', async ($, e, next) => {
97    const started = await next(e)
98    live = blank()
99    lastPublished = ''
100    await $.command.register({
101      name: 'mantra',
102      description: `KOZMOS: theme the spinner (/mantra ${PACK_NAMES.join('|')}|on|off)`,
103      argumentHint: `[${PACK_NAMES.join('|')}|on|off]`,
104      immediate: true,
105    })
106    try {
107      const pack = await $.store.get('pack')
108      if (typeof pack === 'string' && PACKS[pack]) await update($, packAtom, () => pack)
109      const isOn = await $.store.get('isOn')
110      await update($, onAtom, () => isOn !== false)
111    } catch {
112      // Defaults stand.
113    }
114    $.clock.every(1000, () => {
115      if (live.isWorking || Object.keys(live.tools).length) kick($)
116    })
117    return started
118  })
119
120  on('command.run', { command: 'mantra' }, async ($, e) => {
121    const arg = e.args.trim().toLowerCase()
122    if (arg === 'off' || arg === 'on') {
123      await setOn($, arg === 'on')
124      return { text: arg === 'on' ? 'Mantra on.' : 'Mantra off: the spinner is the engine’s again.' }
125    }
126    const pick = PACKS[arg]
127    if (pick) {
128      await setPack($, arg)
129      await setOn($, true)
130      const sample = pick.slice(0, 3).join(', ')
131      return { text: `Mantra pack: ${arg} (${sample}, …)` }
132    }
133    if (arg) return { text: `Unknown pack "${arg}". Packs: ${PACK_NAMES.join(', ')}; or on, off.` }
134    const isOn = !(await read($, onAtom))
135    await setOn($, isOn)
136    const pack = (await read($, packAtom)) || defaultPack
137    return { text: isOn ? `Mantra on (${pack}). Packs: ${PACK_NAMES.join(', ')}.` : 'Mantra off.' }
138  })
139
140  on('turn.start', async ($, e, next) => {
141    live.isWorking = true
142    live.turnSeed = hash(e.turnId)
143    live.tools = {}
144    kick($)
145    return next(e)
146  }).catch(($, e, next) => next(e))
147
148  on('turn.step', async function* ($, e, next) {
149    if (e.agentId === undefined && e.effort !== undefined && String(e.effort) !== live.effort) {
150      live.effort = String(e.effort)
151      kick($)
152    }
153    return yield* next(e)
154  })
155
156  on('turn.complete', async ($, e, next) => {
157    if (e.agentId === undefined) {
158      live.isWorking = false
159      live.tools = {}
160      kick($)
161    }
162    return next(e)
163  }).catch(($, e, next) => next(e))
164
165  on('tool.call', async ($, e, next) => {
166    const loop = e.agentId ?? 'main'
167    const tool = String(e.tool)
168    const mine: MantraTool = { name: tool, label: toolLabel(tool, e), startedAt: await $.clock.now() }
169    live.tools[loop] = mine
170    if (e.agentId !== undefined && !live.agents.includes(e.agentId)) live.agents = [...live.agents, e.agentId].slice(-50)
171    kick($)
172    try {
173      return await next(e)
174    } finally {
175      if (live.tools[loop] === mine) delete live.tools[loop]
176      kick($)
177    }
178  }).catch(($, e, next) => next(e))
179
180  on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
181    if (!(await read($, onAtom))) return next(e)
182    // The pack atom only ever holds a known pack (checked on load and on /mantra).
183    const words = PACKS[(await read($, packAtom)) || defaultPack] as readonly string[]
184    const state = await read($, liveAtom)
185
186    const isOwnLoop = state.agents.includes(e.requestId)
187    const tool = state.tools[e.requestId] ?? (isOwnLoop ? undefined : state.tools.main)
188    const now = Math.max(state.now, tool?.startedAt ?? 0)
189    const tail: string[] = []
190    if (tool) tail.push(`${toolGlyph(tool.name)} ${tool.label} ${fmtClock(now - tool.startedAt)}`)
191    else if (e.props.mode === 'thinking' && state.effort) tail.push(`∴ ${state.effort}`)
192    const suffix = tail.length ? `${e.props.suffix} · ${tail.join(' · ')}` : e.props.suffix
193
194    // The desktop's word says what the step is doing ("Creating notes.md"):
195    // keep it, and theme only the generic "Working".
196    const keepsWord = e.surface !== 'terminal' && e.props.word !== 'Working'
197    const word = keepsWord ? e.props.word : wordAt(words, e.requestId, state.turnSeed, state.now)
198    if (word === e.props.word && suffix === e.props.suffix) return next(e)
199    return next({ ...e, props: { ...e.props, word, suffix } })
200  })
201}
202

1// GENERATED by scripts/sync-shared.mjs from shared/kz.ts. Do not edit here.
2// KOZMOS shared kit. Source of truth: shared/kz.ts at the bundle root.
3// `node scripts/sync-shared.mjs` copies it into every mod as hooks/lib/kz.ts,
4// because a hooks module may only import files inside its own plugin.
5// Edit the root copy, never a mod's copy.
6
7// ---------------------------------------------------------------------------
8// Palette: one neon family across every KOZMOS mod.
9
10export const KZ = {
11  violet: '#a78bfa',
12  magenta: '#f472b6',
13  cyan: '#22d3ee',
14  teal: '#2dd4bf',
15  green: '#4ade80',
16  lime: '#a3e635',
17  yellow: '#facc15',
18  amber: '#fb923c',
19  red: '#f87171',
20  blue: '#60a5fa',
21  clay: '#d97757',
22  ink: '#1f1e1d',
23  mist: '#9ca3af',
24} as const
25
26/** Tool families, colored the same in every mod. */
27export function toolColor(tool: string): string {
28  const t = String(tool)
29  if (t === 'Bash' || t === 'PowerShell') return KZ.green
30  if (t === 'Edit' || t === 'Write' || t === 'NotebookEdit' || t === 'MultiEdit') return KZ.yellow
31  if (t === 'Read' || t === 'Glob' || t === 'Grep' || t === 'LSP') return KZ.blue
32  if (t === 'Agent' || t === 'Task' || t === 'Workflow') return KZ.violet
33  if (t.startsWith('Web')) return KZ.cyan
34  if (t.startsWith('Todo') || t.startsWith('Task')) return KZ.teal
35  if (t.startsWith('mcp__')) return KZ.magenta
36  return KZ.mist
37}
38
39/** A short glyph per tool family. */
40export function toolGlyph(tool: string): string {
41  const t = String(tool)
42  if (t === 'Bash' || t === 'PowerShell') return '$'
43  if (t === 'Edit' || t === 'Write' || t === 'NotebookEdit') return '✎'
44  if (t === 'Read') return '◉'
45  if (t === 'Glob' || t === 'Grep') return '⌕'
46  if (t === 'Agent') return '◈'
47  if (t.startsWith('Web')) return '◍'
48  if (t.startsWith('Todo') || t.startsWith('Task')) return '☑'
49  if (t.startsWith('mcp__')) return '⬡'
50  return '•'
51}
52
53// ---------------------------------------------------------------------------
54// Colors.
55
56export function hexToRgb(hex: string): [number, number, number] {
57  const h = hex.replace('#', '')
58  const n = parseInt(h.length === 3 ? h.split('').map(c => c + c).join('') : h, 16)
59  return [(n >> 16) & 255, (n >> 8) & 255, n & 255]
60}
61
62export function rgbToHex(r: number, g: number, b: number): string {
63  const c = (v: number) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')
64  return `#${c(r)}${c(g)}${c(b)}`
65}
66
67export function mix(a: string, b: string, t: number): string {
68  const [r1, g1, b1] = hexToRgb(a)
69  const [r2, g2, b2] = hexToRgb(b)
70  const k = clamp01(t)
71  return rgbToHex(r1 + (r2 - r1) * k, g1 + (g2 - g1) * k, b1 + (b2 - b1) * k)
72}
73
74/** Green at 0, yellow at 0.6, red at 1: the heat of a gauge. */
75export function heat(t: number): string {
76  const k = clamp01(t)
77  return k < 0.6 ? mix(KZ.green, KZ.yellow, k / 0.6) : mix(KZ.yellow, KZ.red, (k - 0.6) / 0.4)
78}
79
80/** A smooth rainbow for hues 0..1 (for auroras, plasma and the like). */
81export function hue(h: number, s = 0.75, l = 0.6): string {
82  const k = ((h % 1) + 1) % 1
83  const a = s * Math.min(l, 1 - l)
84  const f = (n: number) => {
85    const x = (n + k * 12) % 12
86    return l - a * Math.max(-1, Math.min(x - 3, 9 - x, 1))
87  }
88  return rgbToHex(f(0) * 255, f(8) * 255, f(4) * 255)
89}
90
91export function hexToInt(hex: string): number {
92  const [r, g, b] = hexToRgb(hex)
93  return (r << 16) | (g << 8) | b
94}
95
96// ---------------------------------------------------------------------------
97// Numbers and text.
98
99export const clamp01 = (v: number): number => (Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 0)
100
101export function fmtTokens(n: number): string {
102  if (!Number.isFinite(n)) return '—'
103  // Each unit starts where the one below would round up to 1000 of itself.
104  if (n >= 999.5e6) return `${(n / 1e9).toFixed(1)}B`
105  if (n >= 999_500) return `${(n / 1e6).toFixed(n >= 1e7 ? 0 : 1)}M`
106  if (n >= 999.5) return `${(n / 1e3).toFixed(n >= 1e4 ? 0 : 1)}k`
107  return `${Math.round(n)}`
108}
109
110export function fmtUsd(usd: number): string {
111  if (!Number.isFinite(usd)) return '$—'
112  if (usd < 0.01 && usd > 0) return '<$0.01'
113  return usd < 100 ? `$${usd.toFixed(2)}` : `$${Math.round(usd)}`
114}
115
116/** 0:42, 3:07, 1:02:33. */
117export function fmtClock(ms: number): string {
118  const s = Math.max(0, Math.round(ms / 1000))
119  const h = Math.floor(s / 3600)
120  const m = Math.floor((s % 3600) / 60)
121  const ss = String(s % 60).padStart(2, '0')
122  return h ? `${h}:${String(m).padStart(2, '0')}:${ss}` : `${m}:${ss}`
123}
124
125/** 42s, 7m, 2h41m, 3d4h: compact durations for countdowns. */
126export function fmtSpan(ms: number): string {
127  const s = Math.max(0, Math.round(ms / 1000))
128  if (s < 60) return `${s}s`
129  const m = Math.floor(s / 60)
130  if (m < 60) return `${m}m`
131  const h = Math.floor(m / 60)
132  if (h < 48) return `${h}h${String(m % 60).padStart(2, '0')}m`
133  return `${Math.floor(h / 24)}d${h % 24}h`
134}
135
136export function fmtPct(p: number | undefined): string {
137  return p === undefined || !Number.isFinite(p) ? '—' : `${Math.round(p)}%`
138}
139
140export function clip(s: string, max: number): string {
141  const one = s.replace(/\s+/g, ' ').trim()
142  return one.length > max ? one.slice(0, Math.max(1, max - 1)) + '…' : one
143}
144
145export function padEnd(s: string, n: number): string {
146  return s.length >= n ? s.slice(0, n) : s + ' '.repeat(n - s.length)
147}
148
149export function padStart(s: string, n: number): string {
150  return s.length >= n ? s.slice(s.length - n) : ' '.repeat(n - s.length) + s
151}
152
153/** `claude-opus-5-5[1m]` → `Opus 5.5`. */
154export function modelName(id: string | undefined): string {
155  if (!id) return '—'
156  const m = /(fable|mythos|opus|sonnet|haiku)-(\d+)(?:-(\d{1,2})(?!\d))?/i.exec(id)
157  if (!m) return id.replace(/^claude-/, '').replace(/\[.*\]$/, '')
158  const fam = m[1]!
159  return `${fam.charAt(0).toUpperCase()}${fam.slice(1).toLowerCase()} ${m[2]}${m[3] ? '.' + m[3] : ''}`
160}
161
162/** Last path segment, either slash. */
163export function baseName(p: string): string {
164  const parts = p.split(/[\\/]/).filter(Boolean)
165  return parts[parts.length - 1] ?? p
166}
167
168/** A stable small hash for seeding. */
169export function hash(s: string): number {
170  let h = 2166136261
171  for (let i = 0; i < s.length; i++) {
172    h ^= s.charCodeAt(i)
173    h = Math.imul(h, 16777619)
174  }
175  return h >>> 0
176}
177
178/** Deterministic 0..1 noise from two ints. */
179export function noise(x: number, y: number): number {
180  const s = Math.sin(x * 12.9898 + y * 78.233) * 43758.5453
181  return s - Math.floor(s)
182}
183
184/** A seeded PRNG (mulberry32). */
185export function rng(seed: number): () => number {
186  let a = seed >>> 0
187  return () => {
188    a = (a + 0x6d2b79f5) >>> 0
189    let t = a
190    t = Math.imul(t ^ (t >>> 15), t | 1)
191    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
192    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
193  }
194}
195
196// ---------------------------------------------------------------------------
197// Text gauges for the terminal.
198
199const EIGHTHS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']
200
201/** A smooth bar with eighth blocks: `█████▍    `. */
202export function bar(ratio: number, width: number, empty = '░'): string {
203  const w = Math.max(1, Math.floor(width))
204  const exact = clamp01(ratio) * w
205  const full = Math.floor(exact)
206  const part = EIGHTHS[Math.floor((exact - full) * 8)] ?? ''
207  const used = full + (part ? 1 : 0)
208  return '█'.repeat(full) + part + empty.repeat(Math.max(0, w - used))
209}
210
211/** A segmented gauge: `▰▰▰▱▱▱`. */
212export function pips(ratio: number, width: number, on = '▰', off = '▱'): string {
213  const w = Math.max(1, Math.floor(width))
214  const n = Math.round(clamp01(ratio) * w)
215  return on.repeat(n) + off.repeat(w - n)
216}
217
218const SPARK = '▁▂▃▄▅▆▇█'
219
220/** A sparkline of the last `width` values, scaled to their own max (or `max`). */
221export function sparkline(values: readonly number[], width: number, max?: number): string {
222  const tail = values.slice(-Math.max(1, width))
223  const top = max ?? Math.max(1e-9, ...tail)
224  const line = tail.map(v => SPARK[Math.min(7, Math.max(0, Math.round((v / top) * 7)))] ?? '▁').join('')
225  return line.padStart(width, ' ')
226}
227
228/** Braille line graph, 2 samples per cell, `rows` cells tall. */
229export function brailleGraph(values: readonly number[], width: number, rows: number, max?: number): string[] {
230  const samples = values.slice(-(width * 2))
231  const top = max ?? Math.max(1e-9, ...samples)
232  const dotsTall = rows * 4
233  const grid: number[][] = Array.from({ length: rows }, () => Array.from({ length: width }, () => 0))
234  const offset = width * 2 - samples.length
235  // Dot bits per column, from the bottom row of a cell up.
236  const LEFT = [0x40, 0x04, 0x02, 0x01]
237  const RIGHT = [0x80, 0x20, 0x10, 0x08]
238  samples.forEach((v, i) => {
239    const x = offset + i
240    const col = Math.floor(x / 2)
241    const isRight = x % 2 === 1
242    const h = Math.round(clamp01(v / top) * (dotsTall - 1))
243    for (let d = 0; d <= h; d++) {
244      const row = rows - 1 - Math.floor(d / 4)
245      const bits = isRight ? RIGHT : LEFT
246      const cellRow = grid[row]
247      if (cellRow && col >= 0) cellRow[col] = (cellRow[col] ?? 0) | bits[d % 4]!
248    }
249  })
250  return grid.map(r => r.map(b => String.fromCharCode(0x2800 + b)).join(''))
251}
252
253// ---------------------------------------------------------------------------
254// Raster: a grid of colored cells, packed as the engine wants it.
255
256const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
257
258export function toBase64(bytes: Uint8Array): string {
259  let out = ''
260  let i = 0
261  for (; i + 2 < bytes.length; i += 3) {
262    const n = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!
263    out += B64[(n >> 18) & 63]! + B64[(n >> 12) & 63]! + B64[(n >> 6) & 63]! + B64[n & 63]!
264  }
265  const rest = bytes.length - i
266  if (rest === 1) {
267    const n = bytes[i]! << 16
268    out += B64[(n >> 18) & 63]! + B64[(n >> 12) & 63]! + '=='
269  } else if (rest === 2) {
270    const n = (bytes[i]! << 16) | (bytes[i + 1]! << 8)
271    out += B64[(n >> 18) & 63]! + B64[(n >> 12) & 63]! + B64[(n >> 6) & 63]! + '='
272  }
273  return out
274}
275
276/** The terminal's own default color, for a cell's foreground or background. */
277export const DEFAULT_COLOR = 0x01000000
278
279export class Canvas {
280  readonly cols: number
281  readonly rows: number
282  private readonly words: Uint32Array
283
284  constructor(cols: number, rows: number) {
285    this.cols = Math.max(1, Math.min(512, Math.floor(cols)))
286    this.rows = Math.max(1, Math.min(256, Math.floor(rows)))
287    this.words = new Uint32Array(this.cols * this.rows * 3)
288    this.clear()
289  }
290
291  clear(bg: number = DEFAULT_COLOR): void {
292    for (let i = 0; i < this.cols * this.rows; i++) {
293      this.words[i * 3] = 0x20
294      this.words[i * 3 + 1] = DEFAULT_COLOR
295      this.words[i * 3 + 2] = bg
296    }
297  }
298
299  /** Puts one width-1 character; colors are '#rrggbb' or a packed int. */
300  set(x: number, y: number, ch: string, fg?: string | number, bg?: string | number): void {
301    const cx = Math.floor(x)
302    const cy = Math.floor(y)
303    if (cx < 0 || cy < 0 || cx >= this.cols || cy >= this.rows) return
304    const i = (cy * this.cols + cx) * 3
305    const code = ch.codePointAt(0) ?? 0x20
306    this.words[i] = code > 0xffff || code < 0x20 ? 0x20 : code
307    if (fg !== undefined) this.words[i + 1] = typeof fg === 'number' ? fg : hexToInt(fg)
308    if (bg !== undefined) this.words[i + 2] = typeof bg === 'number' ? bg : hexToInt(bg)
309  }
310
311  /** Writes a string left to right, clipped to the canvas. */
312  text(x: number, y: number, s: string, fg?: string | number, bg?: string | number): void {
313    let cx = x
314    for (const ch of s) {
315      this.set(cx, y, ch, fg, bg)
316      cx++
317    }
318  }
319
320  /** Paints a cell's background only, keeping its character. */
321  paint(x: number, y: number, bg: string | number): void {
322    const cx = Math.floor(x)
323    const cy = Math.floor(y)
324    if (cx < 0 || cy < 0 || cx >= this.cols || cy >= this.rows) return
325    this.words[(cy * this.cols + cx) * 3 + 2] = typeof bg === 'number' ? bg : hexToInt(bg)
326  }
327
328  /** Two vertical pixels per cell with the upper-half block: `py` is in half-cells. */
329  pixel(x: number, py: number, color: string): void {
330    const cx = Math.floor(x)
331    const cy = Math.floor(py / 2)
332    if (cx < 0 || cy < 0 || cx >= this.cols || cy >= this.rows) return
333    const i = (cy * this.cols + cx) * 3
334    const c = hexToInt(color)
335    const isTop = Math.floor(py) % 2 === 0
336    if (this.words[i] !== 0x2580) {
337      this.words[i] = 0x2580
338      this.words[i + 1] = DEFAULT_COLOR
339      this.words[i + 2] = DEFAULT_COLOR
340    }
341    if (isTop) this.words[i + 1] = c
342    else this.words[i + 2] = c
343  }
344
345  /** The `cells` prop of a Raster. */
346  encode(): string {
347    return toBase64(new Uint8Array(this.words.buffer))
348  }
349}
350
351// ---------------------------------------------------------------------------
352// SVG for the desktop: one drawing per row (the desktop wraps siblings).
353
354export const FONT = "-apple-system,BlinkMacSystemFont,'Segoe UI',Inter,sans-serif"
355export const MONO = "ui-monospace,'Cascadia Code','SF Mono',Consolas,monospace"
356
357const XML_ESC: Record<string, string> = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }
358
359export function xml(s: string): string {
360  return s.replace(/[&<>"']/g, c => XML_ESC[c]!)
361}
362
363/** Theme-aware classes every KOZMOS drawing shares: t text, s secondary, m muted, k track, p panel. */
364export const SVG_BASE_CSS = `
365.t{fill:#1f1f1f}.s{fill:#5f5f5c}.m{fill:#8e8e8a}.k{fill:#e7e5e0}.p{fill:#f5f4f1}.ln{stroke:#e1dfda}
366@media (prefers-color-scheme: dark){.t{fill:#ededed}.s{fill:#b4b4b0}.m{fill:#7c7c78}.k{fill:#2d2d2b}.p{fill:#232322}.ln{stroke:#363634}}
367.pulse{animation:kzp 1.6s ease-in-out infinite}@keyframes kzp{50%{opacity:.35}}
368.spin{transform-box:fill-box;transform-origin:center;animation:kzs 2s linear infinite}@keyframes kzs{to{transform:rotate(360deg)}}
369@media (prefers-reduced-motion: reduce){*{animation:none!important}}
370`
371
372export function svg(width: number, height: number, body: string, css = ''): string {
373  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><style>${SVG_BASE_CSS}${css}</style>${body}</svg>`
374}
375
376/** Rough width of UI text in px, for fitting labels. */
377export function textWidth(s: string, size: number): number {
378  let w = 0
379  for (const ch of s) w += (/[\s.,:;'|!il1()[\]]/.test(ch) ? 0.3 : /[A-Z@%MWmw]/.test(ch) ? 0.72 : 0.56) * size
380  return w
381}
382
383export function fitText(s: string, size: number, maxW: number): string {
384  if (textWidth(s, size) <= maxW) return s
385  let out = ''
386  for (const ch of s) {
387    if (textWidth(out + ch + '…', size) > maxW) break
388    out += ch
389  }
390  return out + '…'
391}
392
393/** A rounded progress bar as SVG markup. */
394export function svgBar(x: number, y: number, w: number, h: number, ratio: number, color: string): string {
395  const fw = Math.max(0, Math.min(w, w * clamp01(ratio)))
396  return `<rect class="k" x="${x}" y="${y}" width="${w}" height="${h}" rx="${h / 2}"/>` +
397    (fw > 0 ? `<rect x="${x}" y="${y}" width="${Math.max(h, fw)}" height="${h}" rx="${h / 2}" fill="${color}"/>` : '')
398}
399
400/** SVG text helper. */
401export function svgText(x: number, y: number, s: string, opts: { cls?: string; size?: number; weight?: number; anchor?: 'start' | 'middle' | 'end'; fill?: string; mono?: boolean } = {}): string {
402  const { cls = 't', size = 12, weight = 400, anchor = 'start', fill, mono = false } = opts
403  return `<text ${fill ? `fill="${fill}"` : `class="${cls}"`} x="${x}" y="${y}" font-family="${mono ? MONO : FONT}" font-size="${size}" font-weight="${weight}" text-anchor="${anchor}" font-variant-numeric="tabular-nums">${xml(s)}</text>`
404}
405
406/** Pixel width a desktop pane or band gives a drawing for `columns` reported columns. */
407export function pxOf(columns: number | undefined, fallback = 60, slack = 8): number {
408  return Math.max(200, Math.min(1600, (columns || fallback) * 8 - slack))
409}
410
411// ---------------------------------------------------------------------------
412// Prices, USD per million tokens: input, output, cache read, cache write (5 min).
413// Anthropic first-party rates as of 2026-10. Used only where the engine reports
414// tokens and not money (a subagent's own spend); the session total comes from
415// $.session.usage().cost, which is the engine's.
416
417const PRICES: [RegExp, [number, number, number, number]][] = [
418  [/fable|mythos/i, [10, 50, 0.25, 12.5]],
419  [/opus-5-5/i, [4, 20, 0.2, 5]],
420  [/opus/i, [5, 25, 0.5, 6.25]],
421  [/sonnet-5/i, [2, 10, 0.2, 2.5]],
422  [/sonnet/i, [3, 15, 0.3, 3.75]],
423  [/haiku-5/i, [0.1, 0.5, 0.01, 0.125]],
424  [/haiku/i, [1, 5, 0.1, 1.25]],
425]
426
427export type Usage = {
428  input_tokens?: number
429  output_tokens?: number
430  cache_read_input_tokens?: number
431  cache_creation_input_tokens?: number
432}
433
434export function priceOf(model: string): [number, number, number, number] {
435  return PRICES.find(([re]) => re.test(model))?.[1] ?? [4, 20, 0.2, 5]
436}
437
438export function costOf(model: string, u: Usage | null | undefined): number {
439  if (!u) return 0
440  const [i, o, r, w] = priceOf(model)
441  return ((u.input_tokens ?? 0) * i + (u.output_tokens ?? 0) * o + (u.cache_read_input_tokens ?? 0) * r + (u.cache_creation_input_tokens ?? 0) * w) / 1e6
442}
443
444export function tokensOf(u: Usage | null | undefined): number {
445  if (!u) return 0
446  return (u.input_tokens ?? 0) + (u.output_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0)
447}
448
449/** The context a request filled: everything it read plus what it wrote. */
450export function contextOf(u: Usage | null | undefined): number {
451  return tokensOf(u)
452}
453
454export function windowOf(model: string): number {
455  return /haiku-4/i.test(model) ? 200_000 : 1_000_000
456}
457
458// ---------------------------------------------------------------------------
459// Rate limits.
460
461export type Limit = { kind: string; percentUsed: number; resetsAt?: string }
462
463export function limitLabel(kind: string): string {
464  if (kind === 'five_hour') return '5h'
465  if (kind === 'seven_day') return '7d'
466  if (kind === 'spend_limit') return '$'
467  return kind.replace(/_/g, ' ')
468}
469
470/** Milliseconds until a window resets, or undefined. */
471export function untilReset(l: Limit, now: number): number | undefined {
472  if (!l.resetsAt) return undefined
473  const t = Date.parse(l.resetsAt)
474  return Number.isFinite(t) ? Math.max(0, t - now) : undefined
475}
476
477/** The length of a window in ms, for burn-rate math. */
478export function windowMs(kind: string): number | undefined {
479  if (kind === 'five_hour') return 5 * 3600_000
480  if (kind === 'seven_day') return 7 * 24 * 3600_000
481  return undefined
482}
483
484// ---------------------------------------------------------------------------
485// Tool calls, described in a few words.
486
487/** What a tool call is about: the command, the file, the pattern, the agent's task. */
488export function toolDetail(tool: string, input: unknown): string {
489  const e = (input ?? {}) as Record<string, unknown>
490  const s = (k: string) => (typeof e[k] === 'string' ? (e[k] as string) : '')
491  const t = String(tool)
492  if (t === 'Bash' || t === 'PowerShell') return clip(s('description') || s('command'), 60)
493  if (s('file_path')) return baseName(s('file_path'))
494  if (s('notebook_path')) return baseName(s('notebook_path'))
495  if (t === 'Agent') return clip(s('description') || s('subagent_type'), 60)
496  if (s('pattern')) return clip(s('pattern'), 60)
497  if (s('url')) return clip(s('url').replace(/^https?:\/\//, ''), 60)
498  if (s('query')) return clip(s('query'), 60)
499  if (s('subject')) return clip(s('subject'), 60)
500  if (Array.isArray(e.todos)) return `${(e.todos as unknown[]).length} todos`
501  if (t.startsWith('mcp__')) return t.split('__').slice(1).join(' · ')
502  return ''
503}
504
505/** `mcp__server__tool` → `server·tool`; built-ins unchanged. */
506export function toolName(tool: string): string {
507  const t = String(tool)
508  return t.startsWith('mcp__') ? t.split('__').slice(1).join('·') : t
509}
510

1/** The tool a loop is running now. */
2export type MantraTool = { name: string; label: string; startedAt: number }
3
4export type MantraLive = {
5  /** Running tool per loop: 'main', or a subagent's id. */
6  tools: Record<string, MantraTool>
7  /** Loops seen calling tools, so a subagent's spinner never borrows main's tool. */
8  agents: string[]
9  effort?: string
10  isWorking: boolean
11  /** Seeds the word order for the turn. */
12  turnSeed: number
13  now: number
14}
15
16declare module 'claude-code' {
17  interface PluginState {
18    mantra: { live: MantraLive; pack: string; isOn: boolean }
19  }
20}
21