aiblueprint-cli 1.4.108 → 1.4.109

package/README.md

@@ -18,6 +18,7 @@ npx aiblueprint-cli@latest agents setup
 - **🤖 Skills** - 30+ reusable workflow skills
 - **🎭 Agents** - 3 specialized AI agents for codebase exploration
 - **⚡ Scripts** - Built-in statusline utilities
+- **🧩 Mods** - Claude Code function-hook mods (usage band, skills sync)
 
 ## 📦 Installation
 
@@ -109,6 +110,13 @@ installs every directory under `agents-config/skills/`.
 - **Snipper** - Fast code modifications
 - **websearch** - Quick web research
 
+### Mods
+
+Installed into `~/.claude/mods/` and enabled through `CLAUDE_CODE_PLUGIN_DIRS`:
+
+- **aiblueprint** - Usage band above the prompt: session context and cost, 5-hour and weekly limits with pace and reset time
+- **agent4everything** - Links every `.agents/skills` skill (global and per project) into `.claude/skills`
+
 ### Shell Shortcuts
 
 - `cc` - Claude Code with permissions skipped
@@ -147,6 +155,7 @@ npx skills add Melvynx/aiblueprint --skill skill-manager
 | `environments-manager` | Set up per-worktree agent environments |
 | `rules-manager` | Create and maintain agent rule files |
 | `skill-manager` | Manage skills and rules across Claude Code, Codex, and Cursor |
+| `test-audit` | Gate new tests and prune low-value, implementation-coupled ones |
 | `use-style` | Apply named UI style guides before implementation |
 
 ## 🤖 Assistant Pro

package/agents-config/claude-config/mods/agent4everything/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "agent4everything",
+  "version": "0.1.0",
+  "description": "Maps .agents/skills (global and per project) into .claude/skills so every skill is active, without duplicating existing ones"
+}

package/agents-config/claude-config/mods/agent4everything/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.ts"] }

package/agents-config/claude-config/mods/agent4everything/hooks/register.ts

@@ -0,0 +1,96 @@
+import type { Register } from 'claude-code'
+
+// `$` as a hook receives it.
+type Engine = Parameters<Parameters<Parameters<Register>[0]>[2]>[0]
+
+type Linked = { root: string; name: string }
+
+const SKILL_FILES = ['SKILL.md', 'skill.md']
+
+const realPath = async ($: Engine, path: string) =>
+  (await $.fs.stat(path, { resolve: true }).catch(() => undefined))?.realPath
+
+const homeDir = async ($: Engine) =>
+  (await $.process.run(['printenv', 'HOME'])).stdout.trim()
+
+// The session's cwd and every ancestor below $HOME, then $HOME itself (global).
+const rootsFor = (cwd: string, home: string) => {
+  const roots: string[] = []
+  let dir = cwd.replace(/\/+$/, '')
+  while (dir.startsWith(`${home}/`)) {
+    roots.push(dir)
+    dir = dir.slice(0, dir.lastIndexOf('/'))
+  }
+  if (!cwd.startsWith(`${home}/`) && cwd !== home) roots.push(cwd)
+  roots.push(home)
+  return roots
+}
+
+const isSkillDir = async ($: Engine, dir: string) => {
+  const stat = await $.fs.stat(dir).catch(() => undefined)
+  if (stat?.kind !== 'dir') return false
+  for (const file of SKILL_FILES) {
+    if (await $.fs.exists(`${dir}/${file}`)) return true
+  }
+  return false
+}
+
+// Links each <root>/.agents/skills/<name> missing from <root>/.claude/skills.
+const syncRoot = async ($: Engine, root: string): Promise<Linked[]> => {
+  const source = `${root}/.agents/skills`
+  const target = `${root}/.claude/skills`
+  if (!(await $.fs.exists(source))) return []
+
+  // .claude/skills already is .agents/skills (a symlinked folder): nothing to map.
+  const sourceReal = await realPath($, source)
+  if (sourceReal !== undefined && sourceReal === (await realPath($, target))) return []
+
+  // Every name already in .claude/skills, dangling links included, case-insensitive.
+  const existing = new Set(
+    (await $.fs.list(target).catch(() => [])).map(entry => entry.name.toLowerCase()),
+  )
+
+  const linked: Linked[] = []
+  for (const entry of await $.fs.list(source)) {
+    const { name } = entry
+    if (name.startsWith('.') || name.startsWith('__')) continue
+    if (existing.has(name.toLowerCase())) continue
+    if (!(await isSkillDir($, `${source}/${name}`))) continue
+
+    if (linked.length === 0) await $.process.run(['mkdir', '-p', target])
+    const ran = await $.process.run(['ln', '-s', `../../.agents/skills/${name}`, `${target}/${name}`])
+    if (ran.exitCode === 0) linked.push({ root, name })
+    else $.ui.log(`agent4everything: ln failed for ${name}: ${ran.stderr.trim()}`, { to: 'debug' })
+  }
+  return linked
+}
+
+const syncAll = async ($: Engine, cwd: string) => {
+  const home = await homeDir($)
+  const linked: Linked[] = []
+  for (const root of rootsFor(cwd, home)) linked.push(...(await syncRoot($, root)))
+  if (linked.length > 0) {
+    $.ui.toast(`agent4everything: linked ${linked.map(l => l.name).join(', ')}`)
+  }
+  return linked
+}
+
+export const register: Register = on => {
+  // Awaited before the first prompt: links exist before the session reads skills again.
+  on('session.start', async ($, e, next) => {
+    await syncAll($, e.cwd).catch(error => $.ui.log(`agent4everything: ${error}`, { to: 'debug' }))
+    return next(e)
+  })
+
+  // Startup, resume, /clear, compact: sync again and have the engine re-read skills.
+  on('classic.SessionStart', async ($, e, next) => {
+    await syncAll($, e.cwd).catch(() => [])
+    const result = await next(e)
+    return { ...result, reloadSkills: true }
+  })
+
+  on('classic.CwdChanged', async ($, e, next) => {
+    await syncAll($, e.new_cwd).catch(() => [])
+    return next(e)
+  })
+}

package/agents-config/claude-config/mods/aiblueprint/.claude-plugin/plugin.json

@@ -0,0 +1,71 @@
+{
+  "name": "aiblueprint",
+  "version": "0.7.0",
+  "description": "AIBlueprint usage band above the prompt: session cost, 5-hour and weekly limits with pacing and reset time.",
+  "author": {
+    "name": "Melvyn"
+  },
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "showSession": {
+      "type": "boolean",
+      "title": "Session chip",
+      "description": "Show the session cost chip.",
+      "default": true
+    },
+    "showFiveHour": {
+      "type": "boolean",
+      "title": "5h chip",
+      "description": "Show the 5-hour session limit.",
+      "default": true
+    },
+    "showWeek": {
+      "type": "boolean",
+      "title": "Week chip",
+      "description": "Show the weekly limit (all models).",
+      "default": true
+    },
+    "showBars": {
+      "type": "boolean",
+      "title": "Bars",
+      "description": "Draw a progress bar in the 5h and Week chips.",
+      "default": true
+    },
+    "showPace": {
+      "type": "boolean",
+      "title": "Pace",
+      "description": "Show the +/- pace: positive means you use less than the time elapsed.",
+      "default": true
+    },
+    "showReset": {
+      "type": "boolean",
+      "title": "Reset time",
+      "description": "Show when each limit resets.",
+      "default": true
+    },
+    "sessionLabel": {
+      "type": "string",
+      "title": "Session label",
+      "description": "Label of the cost chip.",
+      "default": "S"
+    },
+    "fiveHourLabel": {
+      "type": "string",
+      "title": "5h label",
+      "description": "Label of the 5-hour chip.",
+      "default": "5h"
+    },
+    "weekLabel": {
+      "type": "string",
+      "title": "Week label",
+      "description": "Label of the weekly chip.",
+      "default": "Week"
+    },
+    "refreshSeconds": {
+      "type": "number",
+      "title": "Refresh (seconds)",
+      "description": "How often the band reads usage again.",
+      "default": 30
+    }
+  }
+}

package/agents-config/claude-config/mods/aiblueprint/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

package/agents-config/claude-config/mods/aiblueprint/hooks/register.tsx

@@ -0,0 +1,309 @@
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register, SessionUsage } from 'claude-code'
+
+import type { Limit, Usage } from '../types'
+
+const SESSION_MS = 5 * 3600 * 1000
+const WEEK_MS = 7 * 24 * 3600 * 1000
+let limitsCache: Promise<string | undefined> | undefined
+// The status line script's cache under $HOME/.claude; undefined when HOME cannot be read.
+const limitsCachePath = ($: EngineInterface) =>
+  (limitsCache ??= $.process
+    .run(['printenv', 'HOME'])
+    .then(({ stdout }) => stdout.trim() ? `${stdout.trim()}/.claude/scripts/statusline/data/usage-limits-cache.json` : undefined)
+    .catch(() => undefined))
+
+const GREEN = '#57ab5a'
+const YELLOW = '#d4a72c'
+const ORANGE = '#ff8700'
+const RED = '#e5534b'
+const TRACK = '#8b8b8b'
+const BLUE = '#539bf5'
+const BAR_WIDTH = 36
+
+const usageAtom = atom({ plugin: 'aiblueprint', key: 'usage' } as const, null)
+const settingsOpenAtom = atom({ plugin: 'aiblueprint', key: 'settingsOpen' } as const, false)
+
+type Options = {
+  showSession: boolean
+  showFiveHour: boolean
+  showWeek: boolean
+  showBars: boolean
+  showPace: boolean
+  showReset: boolean
+  sessionLabel: string
+  fiveHourLabel: string
+  weekLabel: string
+  refreshSeconds: number
+}
+
+const DEFAULTS: Options = {
+  showSession: true,
+  showFiveHour: true,
+  showWeek: true,
+  showBars: true,
+  showPace: true,
+  showReset: true,
+  sessionLabel: 'S',
+  fiveHourLabel: '5h',
+  weekLabel: 'Week',
+  refreshSeconds: 30,
+}
+
+// The toggles the ⚙ row shows, in order.
+const TOGGLES = [
+  { field: 'showSession', label: 'Session' },
+  { field: 'showFiveHour', label: '5h' },
+  { field: 'showWeek', label: 'Week' },
+  { field: 'showBars', label: 'Barres' },
+  { field: 'showPace', label: 'Pace' },
+  { field: 'showReset', label: 'Reset' },
+] as const
+
+let isRunning = false
+let isPending = false
+
+function fillColor(percent: number) {
+  if (percent < 50) return GREEN
+  if (percent < 75) return YELLOW
+  if (percent < 90) return ORANGE
+  return RED
+}
+
+// Pace > 0: under the week's pace (budget left), < 0: burning faster than time passes.
+function paceColor(pace: number) {
+  if (pace >= 0) return GREEN
+  if (pace > -10) return YELLOW
+  return RED
+}
+
+function formatPace(pace: number) {
+  return `${pace >= 0 ? '+' : ''}${pace.toFixed(1)}%`
+}
+
+function formatCost(cost: number) {
+  return `$${cost < 10 ? cost.toFixed(2) : cost.toFixed(1)}`
+}
+
+// One unit only, the biggest that fits: 6j, 13h, 45m.
+function formatResetsIn(ms: number) {
+  const minutes = Math.max(0, Math.floor(ms / 60_000))
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}j`
+}
+
+function barSvg(percent: number, color: string) {
+  const filled = Math.max(0, Math.min(BAR_WIDTH, Math.round((percent / 100) * BAR_WIDTH)))
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${BAR_WIDTH}" height="4" viewBox="0 0 ${BAR_WIDTH} 4"><rect width="${BAR_WIDTH}" height="4" rx="2" fill="${TRACK}" fill-opacity="0.25"/><rect width="${filled}" height="4" rx="2" fill="${color}"/></svg>`
+}
+
+function barText(percent: number) {
+  const filled = Math.max(0, Math.min(5, Math.round((percent / 100) * 5)))
+  return `${'█'.repeat(filled)}${'░'.repeat(5 - filled)}`
+}
+
+// The same windows as the Plan usage limits panel: Session = the 5-hour limit, Week = the 7-day limit.
+function limitOf(usage: SessionUsage, kind: string, windowMs: number, now: number): Limit | undefined {
+  const limit = usage.rateLimits.find(item => item.kind === kind)
+  if (!limit) return undefined
+  const resetsInMs = limit.resetsAt ? new Date(limit.resetsAt).getTime() - now : undefined
+  const elapsedPercent = resetsInMs !== undefined ? ((windowMs - resetsInMs) / windowMs) * 100 : undefined
+  return {
+    percent: limit.percentUsed,
+    pace: elapsedPercent !== undefined ? elapsedPercent - limit.percentUsed : undefined,
+    resetsInMs,
+  }
+}
+
+function contextOf(usage: SessionUsage): Usage['context'] {
+  const { tokens, window, percent } = usage.context
+  const value = percent ?? (tokens !== undefined && window > 0 ? (tokens / window) * 100 : undefined)
+  return value === undefined ? undefined : { percent: value, tokens, window }
+}
+
+function formatTokens(count: number) {
+  return count >= 1000 ? `${Math.round(count / 1000)}k` : `${count}`
+}
+
+function formatContext(context: NonNullable<Usage['context']>) {
+  const tokens = context.tokens ?? Math.round((context.percent / 100) * context.window)
+  return `${formatTokens(tokens)}/${formatTokens(context.window)}`
+}
+
+// A pill with the token count written inside, like the context window bar. A darker fill and a
+// shadowed label keep the text readable over both the filled part and the empty track.
+const PILL_WIDTH = 84
+const PILL_HEIGHT = 16
+
+function contextSvg(context: NonNullable<Usage['context']>) {
+  const filled = Math.max(0, Math.min(PILL_WIDTH, Math.round((context.percent / 100) * PILL_WIDTH)))
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${PILL_WIDTH}" height="${PILL_HEIGHT}" viewBox="0 0 ${PILL_WIDTH} ${PILL_HEIGHT}"><defs><clipPath id="p"><rect width="${PILL_WIDTH}" height="${PILL_HEIGHT}" rx="${PILL_HEIGHT / 2}"/></clipPath></defs><g clip-path="url(#p)"><rect width="${PILL_WIDTH}" height="${PILL_HEIGHT}" fill="#3a3f47"/><rect width="${filled}" height="${PILL_HEIGHT}" fill="#2f6fd1"/></g><text x="${PILL_WIDTH / 2}" y="11.5" text-anchor="middle" font-family="-apple-system, BlinkMacSystemFont, system-ui, sans-serif" font-size="10.5" font-weight="700" fill="#ffffff" stroke="#000000" stroke-opacity="0.35" stroke-width="2" paint-order="stroke">${formatContext(context)}</text></svg>`
+}
+
+function compute(usage: SessionUsage, now: number): Usage {
+  return {
+    cost: usage.cost?.usd ?? 0,
+    context: contextOf(usage),
+    session: limitOf(usage, 'five_hour', SESSION_MS, now),
+    week: limitOf(usage, 'seven_day', WEEK_MS, now),
+  }
+}
+
+// Keeps the terminal status line script on the engine's own readings, so it never calls the usage API.
+async function seedLimitsCache($: EngineInterface, usage: SessionUsage, now: number) {
+  const window = (kind: string) => {
+    const limit = usage.rateLimits.find(item => item.kind === kind)
+    return limit ? { utilization: limit.percentUsed, resets_at: limit.resetsAt ?? null } : null
+  }
+  const sevenDay = window('seven_day')
+  if (!sevenDay) return
+  const path = await limitsCachePath($)
+  if (!path) return
+  await $.fs
+    .write(path, JSON.stringify({ data: { five_hour: window('five_hour'), seven_day: sevenDay }, timestamp: now }, null, 2))
+    .catch(() => undefined)
+}
+
+async function refresh($: EngineInterface): Promise<void> {
+  if (isRunning) {
+    isPending = true
+    return
+  }
+  isRunning = true
+  try {
+    const [usage, now] = await Promise.all([$.session.usage(), $.clock.now()])
+    const next = compute(usage, now)
+    await update($, usageAtom, () => next)
+    await seedLimitsCache($, usage, now)
+  } catch {
+    // keep the last band
+  } finally {
+    isRunning = false
+  }
+  if (isPending) {
+    isPending = false
+    await refresh($)
+  }
+}
+
+// Writes one userConfig field the way /config does; the module reloads with the new options.
+async function setOption($: EngineInterface, field: string, value: boolean) {
+  const rows = await $.config.list()
+  const row = rows.find(item => item.key.startsWith('aiblueprint') && item.key.endsWith(`.${field}`))
+  if (!row) {
+    $.ui.toast(`aiblueprint: réglage ${field} introuvable dans /config`)
+    return
+  }
+  const { deny } = await $.config.set({ key: row.key, value })
+  if (deny) $.ui.toast(`aiblueprint: ${deny}`)
+}
+
+async function toggleSettings($: EngineInterface) {
+  await update($, settingsOpenAtom, isOpen => !isOpen)
+}
+
+export const register: Register = (on, rawOptions) => {
+  const options: Options = { ...DEFAULTS, ...(rawOptions as Partial<Options>) }
+  const refreshMs = Math.max(5, options.refreshSeconds) * 1000
+
+  on('session.start', async ($, e, next) => {
+    const started = await next(e)
+    $.ui.status(undefined)
+    void refresh($)
+    $.clock.every(refreshMs, () => refresh($))
+    return started
+  })
+
+  on('session.measure', async ($, e, next) => {
+    const measured = await next(e)
+    void refresh($)
+    return measured
+  })
+
+  on('turn.complete', async ($, e, next) => {
+    const completed = await next(e)
+    void refresh($)
+    return completed
+  })
+
+  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    const [usage, isSettingsOpen] = await Promise.all([read($, usageAtom), read($, settingsOpenAtom)])
+    if (e.props.hasSurvey || usage === null) return next(e)
+
+    const limits = [
+      { key: 'five-hour', label: options.fiveHourLabel, limit: options.showFiveHour ? usage.session : undefined },
+      { key: 'week', label: options.weekLabel, limit: options.showWeek ? usage.week : undefined },
+    ].filter((item): item is { key: string; label: string; limit: Limit } => item.limit !== undefined)
+
+    const { Box, Text, Button } = $.ui.resolve(e)
+    const settingsRow = isSettingsOpen && (
+      <Box key="settings" flexDirection="row" gap={1} flexWrap="wrap">
+        {TOGGLES.map(({ field, label }) => (
+          <Button
+            key={`toggle-${field}`}
+            label={`${options[field] ? '✓' : '·'} ${label}`}
+            dimColor={!options[field]}
+            onPress={() => setOption($, field, !options[field])}
+          />
+        ))}
+      </Box>
+    )
+    const gear = <Button key="gear" label="⚙" plain dimColor={!isSettingsOpen} onPress={() => toggleSettings($)} />
+
+    if (e.surface === 'terminal') {
+      return (
+        <Box flexDirection="column">
+          <Box flexDirection="row" gap={3}>
+            {options.showSession && (
+              <Text key="session">
+                <Text dimColor>{options.sessionLabel} </Text>
+                {usage.context !== undefined && <Text color={BLUE}>{options.showBars ? `${barText(usage.context.percent)} ` : ''}{formatContext(usage.context)} </Text>}
+                <Text bold>{formatCost(usage.cost)}</Text>
+              </Text>
+            )}
+            {limits.map(({ key, label, limit }) => (
+              <Text key={key}>
+                <Text dimColor>{label} </Text>
+                {options.showBars && <Text color={fillColor(limit.percent)}>{barText(limit.percent)} </Text>}
+                <Text bold>{Math.round(limit.percent)}%</Text>
+                {options.showPace && limit.pace !== undefined && <Text color={paceColor(limit.pace)}> {formatPace(limit.pace)}</Text>}
+                {options.showReset && limit.resetsInMs !== undefined && <Text dimColor> {formatResetsIn(limit.resetsInMs)}</Text>}
+              </Text>
+            ))}
+            {gear}
+          </Box>
+          {settingsRow}
+        </Box>
+      )
+    }
+
+    const { Svg } = $.ui.resolve(e)
+    return (
+      <Box flexDirection="column" gap={1}>
+        <Box flexDirection="row" gap={1} flexWrap="wrap" alignItems="center">
+          {options.showSession && (
+            <Box key="session" flexDirection="row" alignItems="center" gap={1} borderStyle="round" borderDimColor paddingX={1}>
+              <Text dimColor>{options.sessionLabel}</Text>
+              {usage.context !== undefined && (
+                <Svg source={contextSvg(usage.context)} alt={`Contexte ${formatContext(usage.context)}`} width={PILL_WIDTH} height={PILL_HEIGHT} />
+              )}
+              <Text bold>{formatCost(usage.cost)}</Text>
+            </Box>
+          )}
+          {limits.map(({ key, label, limit }) => (
+            <Box key={key} flexDirection="row" alignItems="center" gap={1} borderStyle="round" borderDimColor paddingX={1}>
+              <Text dimColor>{label}</Text>
+              {options.showBars && <Svg source={barSvg(limit.percent, fillColor(limit.percent))} alt={`${label} ${Math.round(limit.percent)}%`} width={BAR_WIDTH} height={4} />}
+              <Text bold>{Math.round(limit.percent)}%</Text>
+              {options.showPace && limit.pace !== undefined && <Text bold color={paceColor(limit.pace)}>{formatPace(limit.pace)}</Text>}
+              {options.showReset && limit.resetsInMs !== undefined && <Text dimColor>{formatResetsIn(limit.resetsInMs)}</Text>}
+            </Box>
+          ))}
+          {gear}
+        </Box>
+        {settingsRow}
+      </Box>
+    )
+  })
+}

package/agents-config/claude-config/mods/aiblueprint/tests/band.test.tsx

@@ -0,0 +1,74 @@
+import { expect, mock, test } from 'claude-code/testing'
+
+const NOW = Date.parse('2026-10-05T01:00:00Z')
+
+test('the band draws Session and Week on terminal and desktop', async ($, on) => {
+  const clock = mock.clock(on, { now: NOW })
+  on('fs.write', () => undefined)
+  on('session.usage', () => ({ value: {
+    startedAt: NOW - 60_000,
+    context: { tokens: 78_000, window: 200_000, percent: 39 },
+    rateLimits: [
+      { kind: 'five_hour', percentUsed: 7, resetsAt: '2026-10-05T03:01:00Z' },
+      { kind: 'seven_day', percentUsed: 6, resetsAt: '2026-10-11T09:00:00Z' },
+    ],
+    cost: { usd: 1.234 },
+  } }) as never)
+  on('session.measure', () => ({ changed: [] }) as never)
+  await $.session.measure({ context: { tokens: 78_000, window: 200_000, percent: 39 }, rateLimits: [] } as never)
+  await clock.advance(1_000)
+
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const ui = await $.ui.mount({
+      plugin: 'aiblueprint',
+      surface,
+      component: 'AbovePrompt',
+      props: { hasSurvey: false, isWorking: false, maxRows: 10 },
+    } as never)
+    expect(await ui.find({ type: 'Text', text: /^S ?$/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /Week/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /^5h/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /\$1\.23/ })).toBeDefined()
+    if (surface === 'terminal') expect(await ui.find({ type: 'Text', text: /78k\/200k/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /^7%$/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /^ ?2h$/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /\+3\.\d%/ })).toBeDefined()
+    await ui.unmount()
+  }
+})
+
+test('the settings hide chips and the ⚙ row writes the option', { options: { showWeek: false, fiveHourLabel: '5H' } } as never, async ($, on) => {
+  const clock = mock.clock(on, { now: NOW })
+  const writes: unknown[] = []
+  on('fs.write', () => undefined)
+  on('session.usage', () => ({ value: {
+    startedAt: NOW - 60_000,
+    context: { tokens: 78_000, window: 200_000, percent: 39 },
+    rateLimits: [
+      { kind: 'five_hour', percentUsed: 7, resetsAt: '2026-10-05T03:01:00Z' },
+      { kind: 'seven_day', percentUsed: 6, resetsAt: '2026-10-11T09:00:00Z' },
+    ],
+    cost: { usd: 1.234 },
+  } }) as never)
+  on('session.measure', () => ({ changed: [] }) as never)
+  on('config.list', () => ({ value: [{ key: 'aiblueprint.showWeek', label: 'Week chip', kind: 'boolean', value: false }] }) as never)
+  on('config.set', ($, e) => {
+    writes.push(e)
+    return { value: (e as { value: unknown }).value } as never
+  })
+  await $.session.measure({ context: { tokens: 78_000, window: 200_000, percent: 39 }, rateLimits: [] } as never)
+  await clock.advance(1_000)
+
+  const ui = await $.ui.mount({
+    plugin: 'aiblueprint',
+    surface: 'desktop',
+    component: 'AbovePrompt',
+    props: { hasSurvey: false, isWorking: false, maxRows: 10 },
+  } as never)
+  expect(await ui.find({ type: 'Text', text: /^5H$/ })).toBeDefined()
+  expect(await ui.find({ type: 'Text', text: /^Week$/ })).toBeUndefined()
+  await ui.press({ key: 'gear' })
+  await ui.press({ key: 'toggle-showWeek' })
+  expect(writes).toEqual([expect.objectContaining({ key: 'aiblueprint.showWeek', value: true })])
+  await ui.unmount()
+})

package/agents-config/claude-config/mods/aiblueprint/types/index.d.ts

@@ -0,0 +1,14 @@
+export type Limit = { percent: number; pace?: number; resetsInMs?: number }
+
+export type Usage = {
+  cost: number
+  context?: { percent: number; tokens?: number; window: number }
+  session?: Limit
+  week?: Limit
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    aiblueprint: { usage: Usage | null; settingsOpen: boolean }
+  }
+}