cld-pi 0.0.0-stage → 0.0.1

package/js/host.js

@@ -0,0 +1,131 @@
+// node sidecar spawned by `claude-p` in interactive mode. Speaks JSON lines
+// on stdio (see src/pi/sidecar.zig). stderr is discarded by the binary, so
+// everything diagnostic goes to ~/claude/-p/host.log -- only while that file
+// exists (touch it to turn logging on; claude-p removes it on exit).
+import { spawn } from 'node:child_process'
+import { appendFileSync, existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import inspector from 'node:inspector'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { createHost, lineSplitter } from './rpc.js'
+import { commandStubs } from './stubs.js'
+import { openTab, pickTab } from './tab.js'
+
+const dataDir = process.env.CLAUDE_P_DIR || join(homedir(), 'claude', '-p')
+mkdirSync(dataDir, { recursive: true })
+const logFile = join(dataDir, 'host.log')
+const log = (...a) => {
+  const line = a.map(x => (x instanceof Error ? x.stack : typeof x === 'string' ? x : JSON.stringify(x))).join(' ')
+  try {
+    if (existsSync(logFile)) appendFileSync(logFile, `${new Date().toISOString()} ${line}\n`)
+  } catch {}
+}
+
+// Desktop notification; best effort (notify-send on Linux, osascript on macOS).
+const notify = msg => {
+  const [cmd, args] =
+    process.platform === 'darwin'
+      ? ['osascript', ['-e', `display notification ${JSON.stringify(msg)} with title "Claude Code"`]]
+      : ['notify-send', ['-a', 'Claude Code', 'Claude Code', msg]]
+  const p = spawn(cmd, args, { stdio: 'ignore', detached: true })
+  p.on('error', e => log('notify failed', e.message))
+  p.unref()
+}
+
+// pi.sh: one shell line. Resolves at the shell's exit (plus a moment for
+// output to drain) so `cmd &` doesn't hold it up.
+const sh = line =>
+  new Promise(resolve => {
+    const p = spawn('/bin/sh', ['-c', line], { stdio: ['ignore', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    p.stdout.on('data', d => (stdout += d))
+    p.stderr.on('data', d => (stderr += d))
+    p.on('error', e => resolve({ code: 127, stdout, stderr: String(e) }))
+    p.on('exit', code => setTimeout(() => resolve({ code: code ?? 1, stdout, stderr }), 50))
+  })
+
+const stubs = commandStubs(process.argv[2] || process.env.CLAUDE_P_PLUGIN_DIR)
+process.on('exit', stubs.cleanup)
+// The binary closes our stdin on exit; signals take the shorter path (and
+// still run the 'exit' cleanup above).
+for (const sig of ['SIGTERM', 'SIGHUP', 'SIGINT']) process.on(sig, () => process.exit(0))
+const send = msg => process.stdout.write(JSON.stringify(msg) + '\n')
+const host = createHost(send, log, { notify, sh, tab: pickTab(), openTab, stubs })
+const { pi, dispatch } = host
+// Timers plugins create are charged to them (cleared when turned off).
+host.installTimerHooks()
+
+// Debugging is on by default: open chrome://inspect (F12) and poke the global
+// `pi`, e.g. pi`hello`. Listens on 127.0.0.1 only; 9229 is what chrome://inspect
+// discovers out of the box, a random port is the fallback when it's taken
+// (another claude-p). CLAUDE_P_INSPECT=0 turns it off, =<port> picks one.
+globalThis.pi = pi
+const inspectEnv = process.env.CLAUDE_P_INSPECT
+if (inspectEnv !== '0') {
+  const ports = inspectEnv ? [Number(inspectEnv)] : [9229, 0]
+  for (const port of ports) {
+    // A busy port doesn't throw: node prints to stderr and url() stays empty.
+    try {
+      inspector.open(port, '127.0.0.1')
+    } catch (e) {
+      log(`inspector: port ${port}`, e.message)
+    }
+    if (inspector.url()) break
+    log(`inspector: port ${port} unavailable`)
+  }
+  const url = inspector.url()
+  if (url) {
+    log('inspector', url)
+    try {
+      writeFileSync(join(dataDir, 'inspect'), url + '\n')
+    } catch {}
+  }
+}
+
+pi.on({
+  init: m => log('init', { cols: m.cols, rows: m.rows, pid: m.pid }),
+  sessionStart: p => log('sessionStart', p?.session_id),
+})
+
+// Default plugins shipped in js/plugins/, then the user's ~/claude/-p/*.js
+// (listed as ~/name.js). Each can be turned off from the badge's list.
+const loadDir = async (dir, prefix) => {
+  let files = []
+  try {
+    // .js relies on Node's ESM syntax detection (22.12+); .mjs works everywhere.
+    files = readdirSync(dir).filter(f => /\.m?js$/.test(f)).sort()
+  } catch {}
+  for (const f of files) {
+    try {
+      const mod = await import(pathToFileURL(join(dir, f)).href)
+      if (typeof mod.default !== 'function') throw new Error('no default export function')
+      await host.loadPlugin(prefix + f, mod.default)
+      log('plugin', prefix + f)
+    } catch (e) {
+      log(`plugin ${prefix + f} failed`, e)
+    }
+  }
+}
+await loadDir(join(import.meta.dirname, 'plugins'), '')
+await loadDir(dataDir, '~/')
+// The binary waits for this before spawning claude: the command stubs must
+// be on disk by the time claude scans --plugin-dir.
+send({ t: 'ready' })
+
+process.stdin.setEncoding('utf8')
+process.stdin.on(
+  'data',
+  lineSplitter(line => {
+    try {
+      dispatch(JSON.parse(line))
+    } catch (e) {
+      log('bad line', line, e)
+    }
+  }),
+)
+// The binary closes our stdin on exit; follow it down.
+process.stdin.on('end', () => process.exit(0))
+process.on('uncaughtException', e => log('uncaught', e))
+process.on('unhandledRejection', e => log('unhandled', e))

package/js/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/js/plugins/add-dir.js

@@ -0,0 +1,15 @@
+// /ad <dir>: /add-dir it (answering CC's "Yes, for this session"), then
+// show `tree -L 2` of it.
+const confirm = 'Yes, for this session'
+
+export default pi => {
+  pi.command('ad', async ([dir]) => {
+    if (!dir) return pi.dialog({ body: 'usage: /ad <dir>', timeout: 2500 })
+    await pi`/add-dir ${dir}`
+    if (await pi.tui.wait(confirm, 3000)) {
+      await pi.tui.press('enter')
+      await pi.tui.wait(s => !s.text.includes(confirm), 3000)
+    }
+    await pi`!tree -L 2 ${dir}`
+  })
+}

package/js/plugins/f12.js

@@ -0,0 +1,296 @@
+// Chrome tabs (P5) + pi.ext.f12.
+//   `//` + Tab      fzf over the open tabs (title — host); the pick is
+//                   screenshotted to $TMPDIR and typed as `@/tmp/….png`
+//                   plus `@/tmp/….f12.md`: its URL, what F12 shows
+//                   (console, exceptions, network errors) and how to reach
+//                   the same tab through the chrome-devtools MCP.
+//   `//gh/` + Tab   URLs from the tabs and Chrome's history whose host
+//                   matches `gh` (github.com), typed as-is.
+// Every site picked either way goes into ~/.F12-mcp.json's allowedUrlPattern
+// (pi.ext.f12.addTrust), the config of the chrome-devtools MCP that gives
+// Claude the browser; the first `//` offers that MCP's install command.
+// pi.ext.f12.devtools(urlOrTargetId, {reload, ms}) reads a tab's live F12
+// (console, exceptions, network errors) for plugins and for `%%js` cells
+// (goal-v1.ipynb) driven through scripts/cdp-eval.mjs.
+// Chrome must have remote debugging allowed (chrome://inspect/#remote-debugging);
+// CLAUDE_P_CDP=<port|url> points at another browser (agent tests: 9224).
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+import * as cdpLib from '../cdp.js'
+
+export const inspectUrl = 'chrome://inspect/#remote-debugging'
+export const mcpInstall =
+  'claude mcp add chrome-devtools --scope user -- npx -y chrome-devtools-mcp@latest \\\n  --autoConnect --config ~/.F12-mcp.json --watchConfig'
+
+/** `//gh/rest` → { site: 'gh', rest }; `//` or `//title` (tab mode) → null. */
+export function parseToken(tok) {
+  const m = /^\/\/([^/\s]+)\/(.*)$/.exec(tok)
+  return m ? { site: m[1].toLowerCase(), rest: m[2] } : null
+}
+
+const bareHost = url => {
+  try {
+    return new URL(url).host.replace(/^www\./, '')
+  } catch {
+    return ''
+  }
+}
+
+/** `gh` names github.com: a prefix of the host, or its letters in order from the first. */
+export function siteMatch(site, host) {
+  host = host.toLowerCase()
+  if (!site || !host) return false
+  if (host.startsWith(site)) return true
+  if (host[0] !== site[0]) return false
+  let i = 0
+  for (const ch of host.split('.')[0]) if (ch === site[i]) i++
+  return i === site.length
+}
+
+/** http(s) URLs on a matching site, deduplicated, in the given order. */
+export function urlItems(site, urls) {
+  const seen = new Set()
+  return urls.filter(u => /^https?:/.test(u) && siteMatch(site, bareHost(u)) && !seen.has(u) && seen.add(u))
+}
+
+/** One fzf line per tab: `title — host` (unique, single line). */
+export function tabItems(targets) {
+  const seen = new Map()
+  return targets.map(t => {
+    const base = `${(t.title || t.url).replace(/\s+/g, ' ').trim()} — ${bareHost(t.url) || t.url}`
+    const n = (seen.get(base) ?? 0) + 1
+    seen.set(base, n)
+    return { label: n > 1 ? `${base} (${n})` : base, target: t }
+  })
+}
+
+/** The tab a key names: its targetId, its URL exactly, or a URL prefix. */
+export function tabByKey(targets, key) {
+  key = String(key ?? '')
+  if (!key) return null
+  return (
+    targets.find(t => t.targetId === key) ??
+    targets.find(t => t.url === key) ??
+    targets.find(t => t.url.startsWith(key)) ??
+    null
+  )
+}
+
+/** allowedUrlPattern for a page: its origin, any path. null for non-web URLs. */
+export function trustPattern(url) {
+  try {
+    const u = new URL(url)
+    return /^https?:$/.test(u.protocol) ? `${u.protocol}//${u.host}/*` : null
+  } catch {
+    return null
+  }
+}
+
+/** Append `pattern` to the config's allowedUrlPattern (creating the file); true if it was new. */
+export async function addTrust(file, pattern) {
+  let cfg = {}
+  try {
+    cfg = JSON.parse(await readFile(file, 'utf8'))
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw new Error(`${file}: ${e.message}`)
+  }
+  const list = cfg.allowedUrlPattern ?? []
+  if (list.includes(pattern)) return false
+  cfg.allowedUrlPattern = [...list, pattern]
+  await writeFile(file, JSON.stringify(cfg, null, 2) + '\n')
+  return true
+}
+
+/**
+ * Drop every addTrust grant. The key goes entirely: the chrome-devtools MCP
+ * rejects an empty allowedUrlPattern, `{}` means "nothing trusted".
+ */
+export async function clearTrust(file) {
+  let cfg
+  try {
+    cfg = JSON.parse(await readFile(file, 'utf8')) || {}
+  } catch (e) {
+    if (e.code === 'ENOENT') return false // nothing was trusted
+    throw new Error(`${file}: ${e.message}`)
+  }
+  if (!('allowedUrlPattern' in cfg)) return false
+  delete cfg.allowedUrlPattern
+  await writeFile(file, JSON.stringify(cfg, null, 2) + '\n')
+  return true
+}
+
+/** Whether ~/.claude.json has a chrome-devtools MCP server (user or any project scope). */
+export function mcpInstalled(claudeJson) {
+  let cfg
+  try {
+    cfg = JSON.parse(claudeJson)
+  } catch {
+    return false
+  }
+  const scopes = [cfg.mcpServers, ...Object.values(cfg.projects ?? {}).map(p => p?.mcpServers)]
+  return scopes.some(s => s && 'chrome-devtools' in s)
+}
+
+/**
+ * The `.f12.md` handed to Claude with a tab's screenshot. `entries` from
+ * cdp.devtools (null: couldn't read them); the last `max` are kept.
+ */
+export function f12Report({ title, url, png, entries, mcp, max = 60 }) {
+  const lines = [`# Chrome tab: ${title || url}`, '', `URL: ${url}`, `Screenshot: ${png}`, '']
+  lines.push(
+    mcp
+      ? 'This tab is open in the user\'s Chrome. For more than this snapshot (DOM, network, scripts, clicks) use the chrome-devtools MCP: list_pages, then select_page on this URL.'
+      : 'This tab is open in the user\'s Chrome. (The chrome-devtools MCP is not installed, so this snapshot is all there is.)',
+    '',
+  )
+  if (!entries) return [...lines, 'DevTools: could not read the console.', ''].join('\n')
+  const cut = s => (s.length > 400 ? `${s.slice(0, 400)}…` : s)
+  const kept = entries.slice(-max)
+  lines.push(`## DevTools console (${entries.length}${entries.length > kept.length ? `, last ${kept.length}` : ''})`, '')
+  if (!kept.length) lines.push('(empty)')
+  for (const e of kept) lines.push(`- [${e.kind === 'console' ? e.level : `${e.kind} ${e.level}`}] ${cut(e.text.replace(/\s*\n\s*/g, ' ⏎ '))}${e.at ? `  (${e.at})` : ''}`)
+  return [...lines, ''].join('\n')
+}
+
+const copy = (pi, text) => pi.sh`printf %s ${text} | (wl-copy || xclip -selection clipboard || pbcopy) 2>/dev/null`
+
+/**
+ * The plugin, with its world injectable for tests: `home` (for
+ * ~/.F12-mcp.json and ~/.claude.json), `env`, and the CDP functions.
+ */
+export const f12 = ({ home = homedir(), env = process.env, cdp = cdpLib, shots = tmpdir() } = {}) => pi => {
+  const mcpConfig = join(home, '.F12-mcp.json')
+  const trust = async pattern => {
+    try {
+      await addTrust(mcpConfig, pattern)
+    } catch (e) {
+      pi.dialog({ body: `allowedUrlPattern not updated: ${e.message}`, timeout: 4000 })
+    }
+  }
+  const ext = { addTrust: trust }
+  pi.ext.f12 = ext
+
+  // chrome-devtools-mcp --config fails when the file is missing. `{}`, not an
+  // empty allowedUrlPattern: the MCP rejects an empty list.
+  const installed = async () => mcpInstalled(await readFile(join(home, '.claude.json'), 'utf8').catch(() => ''))
+  const ensureConfig = async () => {
+    if (!existsSync(mcpConfig)) await writeFile(mcpConfig, '{}\n')
+  }
+  installed()
+    .then(yes => yes && ensureConfig())
+    .catch(() => {})
+  pi.tui.dispose(() => delete pi.ext.f12)
+
+  // One connection for the session: with chrome://inspect's switch, each
+  // new one may ask the user to Allow it.
+  let browser = null // Promise<{ cdp, dir } | null>
+  const open = async () => {
+    const b = await browser
+    if (b?.cdp && !b.cdp.closed) return b
+    browser = (async () => {
+      const at = await cdp.findBrowser({ env, home })
+      if (!at) return null
+      const allow = setTimeout(() => pi.dialog({ body: 'Chrome: click Allow to let cld-pi connect', timeout: 6000 }), 1500)
+      try {
+        return { cdp: await cdp.connect(at.url), dir: at.dir }
+      } catch {
+        return { cdp: null, dir: at.dir }
+      } finally {
+        clearTimeout(allow)
+      }
+    })()
+    return browser
+  }
+  pi.tui.dispose(() => browser?.then(b => b?.cdp?.close()))
+
+  const offline = () =>
+    pi.dialog({
+      title: 'Chrome remote debugging is off',
+      body: `Open ${inspectUrl} in Chrome,\nallow remote debugging, then Tab again.\nallowedUrlPattern needs Chrome 149+.`,
+      'Copy URL': () => void copy(pi, inspectUrl),
+      OK: () => {},
+    })
+
+  /** Live F12 for a tab (`url`, URL prefix, or targetId); null if there is none. */
+  const devtools = async (target, { reload = false, ms = 300 } = {}) => {
+    const b = await open()
+    if (!b?.cdp) {
+      offline()
+      return null
+    }
+    const t = tabByKey(await cdp.tabs(b.cdp).catch(() => []), target)
+    if (!t) {
+      pi.dialog({ body: `No Chrome tab for ${target}`, timeout: 4000 })
+      return null
+    }
+    // A reload starts the console over, so the replay is the fresh page's.
+    if (reload) await cdp.reload(b.cdp, t.targetId).catch(() => {})
+    return cdp.devtools(b.cdp, t.targetId, ms)
+  }
+  ext.devtools = devtools
+
+  // First `//`: offer the chrome-devtools MCP (its --config file has to exist first).
+  const offerMcp = async () => {
+    const marker = join(pi.tui.state.init?.dataDir ?? join(home, 'claude', '-p'), 'f12-mcp-offered')
+    if (existsSync(marker)) return
+    await writeFile(marker, '')
+    await ensureConfig()
+    if (await installed()) return
+    pi.dialog({
+      title: 'Let Claude use this Chrome?',
+      body: `Install the chrome-devtools MCP (once, in a shell):\n\n${mcpInstall}\n\nSites you pick with // are added to ~/.F12-mcp.json.`,
+      Copy: () => void copy(pi, mcpInstall.replace('\\\n  ', '')),
+      Later: () => {},
+    })
+  }
+
+  let shown = new Map() // fzf line → tab, from the last `//` Tab
+  pi.complete(
+    '//',
+    async tok => {
+      const url = parseToken(tok)
+      const b = await open()
+      if (url) {
+        const onTabs = b?.cdp ? (await cdp.tabs(b.cdp).catch(() => [])).map(t => t.url) : []
+        const visited = (await cdp.history(b?.dir)).map(h => h.url)
+        return urlItems(url.site, [...onTabs, ...visited])
+      }
+      if (!b?.cdp) {
+        offline()
+        return []
+      }
+      const items = tabItems(await cdp.tabs(b.cdp))
+      shown = new Map(items.map(i => [i.label, i.target]))
+      return items.map(i => i.label)
+    },
+    async (item, tok) => {
+      if (parseToken(tok)) {
+        const p = trustPattern(item)
+        if (p) await trust(p)
+        return item
+      }
+      const t = shown.get(item)
+      const b = await browser
+      if (!t || !b?.cdp) return null
+      let png
+      try {
+        png = await cdp.screenshot(b.cdp, t.targetId)
+      } catch (e) {
+        pi.dialog({ body: `screenshot failed: ${e.message}`, timeout: 4000 })
+        return null
+      }
+      const base = join(shots, `cld-pi-${bareHost(t.url).replace(/[^\w.-]/g, '_') || 'tab'}-${Date.now()}`)
+      await writeFile(`${base}.png`, png)
+      const entries = await cdp.devtools(b.cdp, t.targetId).catch(() => null)
+      await writeFile(`${base}.f12.md`, f12Report({ title: t.title, url: t.url, png: `${base}.png`, entries, mcp: await installed() }))
+      const p = trustPattern(t.url)
+      if (p) await trust(p)
+      offerMcp().catch(() => {})
+      return `@${base}.png @${base}.f12.md`
+    },
+  )
+}
+
+export default f12()

package/js/plugins/herdry.js

@@ -0,0 +1,52 @@
+// herdry: when Claude finishes or needs you (the same Stop / Notification
+// hooks notify.js listens to), spin the tab title the way CC spins its
+// status line — "✻ <message>" — until the terminal gets focus.
+// pi.tui.title sets the tab (D-Bus for Yakuake / Konsole / Guake, the
+// window title elsewhere) and puts the old title back.
+
+const base = [...'·✢*✶✻✽']
+const frames = [...base, ...base.slice(1, -1).reverse()] // ·✢*✶✻✽✻✶*✢, CC's cycle
+const frameMs = 150
+const giveUpMs = 30 * 60 * 1000 // no focus reports at all? stop eventually
+const firstLine = s => (s ?? '').trim().split('\n')[0].slice(0, 120)
+
+export function spinner(pi, { every = frameMs } = {}) {
+  const { tui } = pi
+  let timer = null
+  let text = ''
+  let frame = 0
+  let started = 0
+  let busy = false
+
+  const stop = async () => {
+    if (!timer) return
+    clearInterval(timer)
+    timer = null
+    await tui.title(null)
+  }
+
+  const spin = msg => {
+    if (tui.state.focused === true) return
+    text = msg
+    if (timer) return // already spinning: just show the newer message
+    started = Date.now()
+    timer = setInterval(async () => {
+      if (Date.now() - started > giveUpMs) return stop()
+      if (busy) return // a slow D-Bus call: skip a frame rather than pile up
+      busy = true
+      await tui.title(`${frames[frame++ % frames.length]} ${text}`)
+      busy = false
+    }, every)
+  }
+
+  pi.on({
+    stop: p => spin(firstLine(p?.last_assistant_message) || 'Claude is done'),
+    notification: p => spin(p?.message || 'Claude needs your attention'),
+    focus: focused => {
+      if (focused) stop()
+    },
+  })
+  tui.dispose(stop)
+}
+
+export default pi => spinner(pi)

package/js/plugins/img.js

@@ -0,0 +1,35 @@
+// img: click a screen row that names a .png / .webp file and look at it.
+// pi.click gives the row the click landed on (rows above CC's input box);
+// the file opens in imv, or xdg-open's image viewer where imv is missing.
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { isAbsolute, join, resolve } from 'node:path'
+
+/** Path-like tokens on one grid row that end in .png / .webp. */
+export function imagePaths(row) {
+  const out = []
+  const re = /(?:^|[\s"'`(\[@])((?:~|\.{1,2})?[^\s"'`()\[\]<>|]*\.(?:png|webp))(?=$|[\s"'`)\].,;:])/gi
+  for (const m of String(row ?? '').matchAll(re)) {
+    const tok = m[1].replace(/^@/, '') // f12 types `@/tmp/shot.png`
+    if (tok && !out.includes(tok)) out.push(tok)
+  }
+  return out
+}
+
+/** `~` and relative paths → the path the sidecar can open. */
+export const imagePath = (tok, cwd = process.cwd()) => {
+  if (tok === '~' || tok.startsWith('~/')) return join(homedir(), tok.slice(1))
+  return isAbsolute(tok) ? tok : resolve(cwd, tok)
+}
+
+export default pi => {
+  pi.click(row => {
+    const line = pi.tui.state.scr?.rows?.[row]
+    for (const tok of imagePaths(line)) {
+      const file = imagePath(tok)
+      if (!existsSync(file)) continue
+      pi.sh`if command -v imv >/dev/null 2>&1; then imv ${file} >/dev/null 2>&1; else xdg-open ${file} >/dev/null 2>&1; fi &`
+      return
+    }
+  })
+}

package/js/plugins/magpie.js

@@ -0,0 +1,14 @@
+// /m: open the magpie panel; offer the install command when it's missing.
+const install = 'curl -fsSL https://usemagpie.ai/install.sh | sh'
+
+export default pi => {
+  pi.command('m', async () => {
+    const bin = `${process.env.HOME}/.local/bin/magpie`
+    if ((await pi.sh`test -x ${bin}`).code === 0) return pi.sh`${bin} panel >/dev/null 2>&1 &`
+    await pi.dialog({
+      title: 'magpie is not installed',
+      body: `OK copies the installer:\n${install}`,
+      OK: () => pi.sh`printf %s ${install} | (wl-copy || xclip -selection clipboard || pbcopy) 2>/dev/null`.then(() => {}),
+    })
+  })
+}

package/js/plugins/notify.js

@@ -0,0 +1,13 @@
+// Desktop notification when Claude finishes a turn (Stop) or needs you
+// (Notification) — unless the terminal is known to have focus.
+const firstLine = s => (s ?? '').trim().split('\n')[0].slice(0, 120)
+
+export default pi => {
+  const ping = msg => {
+    if (pi.tui.state.focused !== true) pi.notify(msg)
+  }
+  pi.on({
+    stop: p => ping(firstLine(p?.last_assistant_message) || 'Claude is done'),
+    notification: p => ping(p?.message || 'Claude needs your attention'),
+  })
+}

package/js/plugins/pace.js

@@ -0,0 +1,75 @@
+// Bottom-right snack: how long the last ● took (one assistant content
+// block; ticking while the next one is on its way) and what the last 3
+// minutes cost. Goes see-through while the wheel is scrolling (back 0.5 s
+// after the last notch). Follows the transcript (pi.tui.state.transcript) a few new
+// lines at a time; costs come from session.js like the Ctrl+P panel's.
+import { messageCost, tailEntries } from '../session.js'
+
+const windowMs = 3 * 60_000
+
+export const duration = ms => {
+  const s = ms / 1000
+  return s < 60 ? `${s.toFixed(1)}s` : `${Math.floor(s / 60)}m${String(Math.floor(s % 60)).padStart(2, '0')}s`
+}
+
+/** The numbers, fed transcript entries; `view(now)` is the snack text. */
+export function createPace() {
+  const seen = new Set()
+  const costs = [] // [ts, $]
+  let prev = null // ts of the latest user / assistant entry
+  let last = null // ms the latest ● took
+  let running = false
+  return {
+    add(d) {
+      const ts = Date.parse(d.timestamp)
+      if ((d.type !== 'user' && d.type !== 'assistant') || Number.isNaN(ts)) return
+      if (d.type === 'assistant' && prev != null) last = ts - prev
+      const c = messageCost(d, seen)
+      if (c) costs.push([ts, c])
+      prev = ts
+      running = true
+    },
+    /** The turn ended (Stop): stop ticking. */
+    stop() {
+      running = false
+    },
+    view(now) {
+      while (costs.length && costs[0][0] < now - windowMs) costs.shift()
+      const spent = costs.reduce((sum, [, c]) => sum + c, 0)
+      const live = running && prev != null ? now - prev : null
+      const took = live ?? last
+      if (took == null && !costs.length) return null
+      return `● ${took == null ? '–' : duration(took)}${live != null ? '…' : ''} · 3m $${spent.toFixed(2)}`
+    },
+  }
+}
+
+export default pi => {
+  const tail = tailEntries()
+  let pace = createPace()
+  let path = null
+  let scrolling = null // timer until the wheel counts as settled
+  const tick = () => {
+    const p = pi.tui.state.transcript
+    const fresh = p !== path
+    if (fresh) [path, pace] = [p, createPace()]
+    for (const d of tail(p)) pace.add(d)
+    if (fresh) pace.stop() // history (a resumed session), not a running turn
+    const text = pace.view(Date.now())
+    pi.notify(text ?? '', 'snackRD', scrolling ? { bg: 'none' } : {})
+  }
+  pi.on({
+    wheel: () => {
+      const was = scrolling
+      clearTimeout(scrolling)
+      scrolling = setTimeout(() => ((scrolling = null), tick()), 500)
+      if (!was) tick()
+    },
+    stop: () => {
+      tick()
+      pace.stop()
+      tick()
+    },
+  })
+  setInterval(tick, 1000)
+}