From ff909b2ec75fc00f58e158794cf99b3ceb59a960 Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:23:21 +0530 Subject: [PATCH 01/12] docs: design for the Claude Code state cap Argos gains a coloured square on the pet's head driven by Claude Code's state: red when Claude is waiting for confirmation, amber while it runs, green when the task is done. The square rather than cap art is deliberate. It occupies the slot the real cap will occupy, so the transport, the frame seam and the head anchoring are all proven before anything is drawn. Scope is one session, macOS, local only. Multi-session aggregation is iteration 2 and touches only the state source. Co-Authored-By: Claude Opus 5 (1M context) --- .../2026-09-04-claude-state-cap-design.md | 171 ++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 docs/superpowers/specs/2026-09-04-claude-state-cap-design.md diff --git a/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md b/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md new file mode 100644 index 0000000..1fd2efa --- /dev/null +++ b/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md @@ -0,0 +1,171 @@ +# Claude Code state cap — design + +**Date:** 2026-09-04 +**Branch:** `claude-integration` +**Status:** approved, not yet implemented + +## Problem + +While Claude Code works, the user has no ambient signal for what it is doing. Checking means +switching to the terminal and reading it. The three states that matter are: + +- **waiting for confirmation** — Claude is blocked on the user. This is the only state that + demands attention. +- **running** — Claude is working. Nothing to do. +- **idle** — the task finished; ready for a new one. + +Argos already lives on screen over whatever the user is working on, so it is a free carrier for +that signal. + +## Solution + +The pet wears a coloured cap. The colour is driven by Claude Code's state. + +This spike ships a **coloured square** on the head rather than cap art, so the transport, the +frame seam and the head anchoring can all be proven before any art is drawn. The square occupies +the exact slot the real cap will occupy, so the geometry validated here is the geometry kept. + +**Scope of this spike:** one Claude Code session, macOS first, local only. + +## Non-goals + +Explicitly out of scope, listed so they are not smuggled in: + +- **Multi-session aggregation.** Deferred to iteration 2. Single session, last writer wins. +- **Real cap art.** Square only. +- **Animation or bubble changes.** The pet's motion and speech are untouched. The cap is + additive. +- **A settings toggle.** No user-facing on/off switch yet. +- **Windows and Linux verification.** The code is written to not break them (see "Shape region" + below), but only macOS is tested. + +## Architecture + +``` +Claude Code hook ──writes word──▶ ~/.argos/claude-state + │ + fs.watch + poll + ▼ + claude-state-source.ts (new, no Electron) + │ current(): ClaudeState + ▼ + pet-controller.ts (buildFrame) + │ PetFrame.claudeState + ▼ + pet.ts (one attribute set) + │ html[data-claude-state] + ▼ + pet.css (#claude-cap square) +``` + +Each arrow is one-directional and each box has one job. The renderer stays dumb, which +`tests/renderer/discipline.spec.ts` enforces by grepping it. + +### Transport: a file, written by hooks + +Claude Code hooks write a single word to a state file. + +| Hook | Writes | Cap colour | +|---|---|---| +| `Notification` | `waiting` | red | +| `UserPromptSubmit`, `PreToolUse`, `PostToolUse` | `running` | amber | +| `Stop` | `idle` | green | +| `SessionEnd` | *deletes the file* | no cap | + +Path: `~/.argos/claude-state`, overridable via `$ARGOS_CLAUDE_STATE_FILE` for tests. + +The hook body is `echo running > ~/.argos/claude-state`. No `jq`, no stdin parsing, no localhost +port, no new dependency on either side. A hook that cannot fail in an interesting way is worth +more in a spike than one that carries more information. + +**Staleness.** A session killed with `Ctrl+C` may never fire `SessionEnd`, leaving a file that +pins the cap on forever. The file's mtime is the guard: older than 15 minutes counts as no state. +This is why the file holds only a word — the timestamp already exists in the filesystem, so +putting one in the payload would be a second source of truth for the same fact. + +### Seam: a new frame field + +`petFrameSchema` in `apps/desktop/src/pet-frame.ts` gains: + +```ts +claudeState: z.enum(['none', 'waiting', 'running', 'idle']) +``` + +This is a **new field rather than a new value on `overlay`**. `overlay` is single-valued and +already owned by the sleep Z's, and a sleeping pet must still be able to wear the cap. Two +independent axes need two fields; folding them into one would make "asleep and waiting" +unrepresentable. + +### Shape region — the platform trap + +`pet-window.ts` sets the window shape region from the alpha mask. Electron's `setShape` +determines where the system permits *drawing*, not merely where clicks land: outside the region +**no pixels are painted at all**. This already bit the speech bubble and the sleep Z's, and is +documented at length in `apps/desktop/src/sprite/alpha-mask.ts`. + +A square drawn over the hair sits in transparent mask cells. Left alone it would be invisible on +Linux, and the screenshot harness would not catch it, because `webContents.capturePage()` renders +the web contents and never consults the window shape. + +Fix: the existing overlay branch already pushes a whole-sprite-cell rect, so the cap reuses it — +the condition becomes `overlay !== 'none' || claudeState !== 'none'`. No new geometry, one +changed expression. + +## Components + +**`apps/desktop/src/claude/claude-state-source.ts`** (new) + +Owns the state file and nothing else. Watches the *directory*, not the file: an atomic write +replaces the inode and a file-level watch goes dead against the old one. A 5-second poll backs +`fs.watch` up, because it is unreliable on some platforms and a missed event here means a stuck +cap. + +Interface: `current(): ClaudeState`, `onChange(cb)`, `stop()`. Pure Node — no Electron import — +so it can be unit-tested against a temp directory. + +This is also the single file that changes when multi-session lands, which is the reason the file +boundary is drawn here. + +**`apps/desktop/src/main/pet-controller.ts`** (changed) + +`buildFrame()` reads the source and sets `claudeState`. The existing `sendFrameIfChanged` +signature check means a colour change pushes exactly one frame and a steady colour pushes none. + +**`apps/desktop/src/renderer/pet.ts`** (changed) + +One line: `root.dataset.claudeState = frame.claudeState`. A pure attribute set, so it passes the +renderer-discipline test. + +**`apps/desktop/src/renderer/pet.css`** (changed) + +`#claude-cap`, built on the `#zzz` pattern: absolutely positioned from `--body-cx` and +`--body-top`, offset by a scaled amount. Those custom properties are already per-animation-state +and scale-aware, so the square tracks the head through every pose and every pet size without any +new arithmetic. + +Colours: red `#e5484d`, amber `#f5a524`, green `#30a46c`. + +## Error handling + +Every failure resolves to **no cap** rather than a wrong cap. A missing file, an unreadable file, +an unparseable word, and a stale mtime are all `none`. A status indicator that lies is worse than +one that is absent, because an absent cap is visibly absent while a wrong cap is silently wrong. + +The state source never throws into main. A watch that cannot be established falls back to the +poll alone. + +## Testing + +- **Unit — state source:** against a temp directory. Reads a word; sees a change; sees a delete; + treats a stale mtime as `none`; treats garbage content as `none`; survives a missing directory. +- **Unit — frame builder:** each `ClaudeState` reaches `PetFrame.claudeState`. +- **Schema:** the frame round-trips through zod with the new field. +- **Manual, and this is the actual integration test:** with Argos running, + `echo waiting > ~/.argos/claude-state` turns the square red, with Claude not involved at all. If + that works and the hooks do not, the hooks are the only remaining variable. + +## Iteration 2 (not now) + +Multi-session: hooks write `/.json` instead, and the source aggregates by +loudest-wins (any waiting → red, else any running → amber, else green). Only +`claude-state-source.ts` changes. Then the real cap art replaces the square. From 0efc90f8d90ca54133a1d1b7800e8bcee7ef3eb2 Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:27:45 +0530 Subject: [PATCH 02/12] docs: implementation plan for the Claude Code state cap Five tasks, each ending in a green test run and a commit: the state source, the frame seam and the square, the controller and shape region, the app wiring, then the hooks and hand verification. Records one deliberate gap - the app-shell wiring has no unit test, because no PetWindow or DisplayManager fake exists and building one for four lines of wiring is not worth it. Co-Authored-By: Claude Opus 5 (1M context) --- .../plans/2026-09-04-claude-state-cap.md | 1018 +++++++++++++++++ 1 file changed, 1018 insertions(+) create mode 100644 docs/superpowers/plans/2026-09-04-claude-state-cap.md diff --git a/docs/superpowers/plans/2026-09-04-claude-state-cap.md b/docs/superpowers/plans/2026-09-04-claude-state-cap.md new file mode 100644 index 0000000..09f74da --- /dev/null +++ b/docs/superpowers/plans/2026-09-04-claude-state-cap.md @@ -0,0 +1,1018 @@ +# Claude Code State Cap Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Put a coloured square on the pet's head that shows what Claude Code is doing — red waiting for confirmation, amber running, green done. + +**Architecture:** Claude Code hooks write one word to `~/.argos/claude-state`. A pure-Node module in main watches that file and exposes the current word. The pet controller reads it into a new `PetFrame` field, the renderer copies that field to a `data-` attribute, and CSS paints a square anchored to the head using the custom properties the sleep Z's already use. + +**Tech Stack:** TypeScript, Electron (main only), zod for the frame schema, vitest for tests, pnpm workspaces. No new dependencies. + +## Global Constraints + +Copied from the repo's own enforced rules — `tests/renderer/discipline.spec.ts` fails the build on each of these: + +- **Runtime dependencies stay exactly `["zod"]`.** `apps/desktop/package.json` `dependencies` is asserted to equal that list. Node builtins only. +- **Every renderer file under `apps/desktop/src/renderer/` stays below 150 non-blank, non-comment code lines.** `pet.ts` is at 137 today. +- **The renderer gets no timers, no `fetch`, no `eval`, no `innerHTML`, and no `import ... from 'electron'`.** Set attributes and `textContent`, nothing else. +- **Hand-written CSS contains no `steps(`, no `192px`, no `208px`.** Animation geometry has one source, `pet/spritesheet.json`. +- **No source file may contain the words `plugin`, `plugins`, `marketplace`, `catalog`, `lan-`, `lease` or `leases` in code** (comments are stripped before the check, but avoid them anyway). +- **Tests are Electron-free.** `vitest.config.ts` runs in the `node` environment. Anything a test touches must not import `electron`. +- Tests live at `tests/**/*.spec.ts`. Run with `pnpm test`. +- Platform target for this spike: **macOS**. The Linux shape-region fix is included because it is one expression, but it is not verified here. + +## File Structure + +**Created:** + +- `apps/desktop/src/claude/claude-state-source.ts` — owns the state file: reads it, watches it, reports changes. Pure Node, no Electron, so it unit-tests against a temp directory. This is the only file that changes when multi-session lands. +- `tests/claude/claude-state-source.spec.ts` — its tests. +- `tests/main/frame-region.spec.ts` — tests the frame schema's new field and the shape-region predicate. +- `docs/CLAUDE-CODE.md` — the hook snippet a user pastes into `~/.claude/settings.json`, and how to test without Claude. + +**Modified:** + +- `apps/desktop/src/pet-frame.ts` — adds `CLAUDE_STATES`, the `claudeState` frame field, and `frameNeedsCellRegion()`. +- `apps/desktop/src/main/pet-controller.ts` — a `getClaudeState` option, read in `buildFrame()`. +- `apps/desktop/src/main/pet-window.ts:186,338` — the shape region follows the cap as well as the sleep overlay. +- `apps/desktop/src/main/app-shell.ts:353,1018` — starts the source, feeds the controller, stops it on dispose. +- `apps/desktop/src/renderer/pet.html` — one `div`. +- `apps/desktop/src/renderer/pet.ts` — one attribute assignment. +- `apps/desktop/src/renderer/pet.css` — the square. +- `tests/renderer/discipline.spec.ts` — asserts the renderer publishes the attribute and the CSS consumes it. + +**Not unit-tested, deliberately:** the `app-shell.ts` wiring. There is no `PetWindow` or `DisplayManager` fake in the repo today and building one for four lines of wiring is not worth it. Typecheck plus the manual test in Task 5 covers it. This is a real gap, stated rather than hidden. + +--- + +### Task 1: The state source + +**Files:** +- Create: `apps/desktop/src/claude/claude-state-source.ts` +- Create: `tests/claude/claude-state-source.spec.ts` +- Modify: `apps/desktop/src/pet-frame.ts` (add `CLAUDE_STATES` only — the frame field comes in Task 2) + +**Interfaces:** +- Consumes: nothing. +- Produces: + - `CLAUDE_STATES: readonly ['none', 'waiting', 'running', 'idle']` and `type ClaudeState`, both exported from `apps/desktop/src/pet-frame.ts`. + - `defaultClaudeStateFile(): string` + - `createClaudeStateSource(options: ClaudeStateSourceOptions): ClaudeStateSource` + - `ClaudeStateSource = { start(): void; stop(): void; current(): ClaudeState; refresh(): ClaudeState }` + - `ClaudeStateSourceOptions = { file?: string; now?: () => number; pollMs?: number; onChange?: (state: ClaudeState) => void; log?: (message: string, meta?: unknown) => void }` + - `CLAUDE_STATE_STALE_MS: number` + +- [ ] **Step 1: Add the state list to the shared frame module** + +The list lives in `pet-frame.ts` rather than in the source module because both main and the renderer bundle need the type, and the renderer must never pull in `node:fs`. One list, two consumers. + +Add near the top of `apps/desktop/src/pet-frame.ts`, just below the existing `TONES` declaration: + +```ts +/** + * Claude Code's state, as the pet displays it. + * + * `none` is the absence of a signal — no state file, an unreadable one, or one too old to + * believe — and paints no cap at all. Every failure resolves here, because a status indicator + * that lies is worse than one that is absent: an absent cap is visibly absent, a wrong cap is + * silently wrong. + */ +export const CLAUDE_STATES = ['none', 'waiting', 'running', 'idle'] as const +export type ClaudeState = (typeof CLAUDE_STATES)[number] +``` + +- [ ] **Step 2: Write the failing tests** + +Create `tests/claude/claude-state-source.spec.ts`: + +```ts +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtempSync, rmSync, writeFileSync, utimesSync, existsSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { + createClaudeStateSource, + CLAUDE_STATE_STALE_MS, +} from '../../apps/desktop/src/claude/claude-state-source.js' + +let dir: string +let file: string + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), 'argos-claude-')) + file = join(dir, 'claude-state') +}) + +afterEach(() => { + rmSync(dir, { recursive: true, force: true }) +}) + +/** `refresh()` rather than the poll, so no test depends on a timer firing. */ +function sourceFor(onChange?: (s: string) => void) { + return createClaudeStateSource({ file, onChange }) +} + +describe('claude state source', () => { + it('reports none when the file does not exist', () => { + expect(sourceFor().refresh()).toBe('none') + }) + + it('reports none when the whole directory is missing', () => { + const source = createClaudeStateSource({ file: join(dir, 'nope', 'claude-state') }) + expect(source.refresh()).toBe('none') + }) + + it.each(['waiting', 'running', 'idle'])('reads %s', (word) => { + writeFileSync(file, `${word}\n`) + expect(sourceFor().refresh()).toBe(word) + }) + + it('ignores surrounding whitespace and case', () => { + writeFileSync(file, ' WAITING \n') + expect(sourceFor().refresh()).toBe('waiting') + }) + + it('treats an unknown word as none', () => { + writeFileSync(file, 'thinking') + expect(sourceFor().refresh()).toBe('none') + }) + + it('treats an empty file as none', () => { + writeFileSync(file, '') + expect(sourceFor().refresh()).toBe('none') + }) + + it('treats a stale file as none, however good its contents', () => { + // A session killed with Ctrl+C never fires SessionEnd, so the file outlives the session. + writeFileSync(file, 'waiting') + const old = new Date(Date.now() - CLAUDE_STATE_STALE_MS - 60_000) + utimesSync(file, old, old) + expect(sourceFor().refresh()).toBe('none') + }) + + it('picks up a change on the next refresh', () => { + writeFileSync(file, 'running') + const source = sourceFor() + expect(source.refresh()).toBe('running') + writeFileSync(file, 'waiting') + expect(source.refresh()).toBe('waiting') + }) + + it('reports a deletion as none', () => { + writeFileSync(file, 'running') + const source = sourceFor() + expect(source.refresh()).toBe('running') + rmSync(file) + expect(source.refresh()).toBe('none') + }) + + it('fires onChange once per distinct state, not once per read', () => { + const seen: string[] = [] + const source = sourceFor((s) => seen.push(s)) + writeFileSync(file, 'running') + source.refresh() + source.refresh() + writeFileSync(file, 'running\n') + source.refresh() + writeFileSync(file, 'waiting') + source.refresh() + expect(seen).toEqual(['running', 'waiting']) + }) + + it('exposes the last read through current() without touching the disk', () => { + writeFileSync(file, 'idle') + const source = sourceFor() + source.refresh() + rmSync(file) + expect(source.current()).toBe('idle') + }) + + it('creates the directory on start so the watch has something to watch', () => { + // Without this the watch silently does nothing until the first hook happens to create the + // directory, which looks exactly like the feature not working. + const nested = join(dir, 'made-by-start', 'claude-state') + const source = createClaudeStateSource({ file: nested }) + source.start() + source.stop() + expect(existsSync(join(dir, 'made-by-start'))).toBe(true) + }) + + it('start() then stop() leaves no live handles', () => { + const source = sourceFor() + source.start() + expect(() => source.stop()).not.toThrow() + expect(() => source.stop()).not.toThrow() + }) +}) +``` + +- [ ] **Step 3: Run the tests and watch them fail** + +```bash +pnpm test -- tests/claude/claude-state-source.spec.ts +``` + +Expected: every test fails to even load — `Failed to resolve import ".../claude/claude-state-source.js"`. + +- [ ] **Step 4: Write the implementation** + +Create `apps/desktop/src/claude/claude-state-source.ts`: + +```ts +/** + * Claude Code's state, read off a file that Claude Code's hooks write. + * + * The transport is a file holding one word, because a hook that is `echo running > file` cannot + * fail in an interesting way: no JSON to parse, no port to bind, no dependency on either side. + * + * No Electron import. This module is the one place that knows how the state arrives, so it is + * also the only file that changes when multi-session support lands — at which point it reads a + * directory of per-session files and aggregates them instead. + */ + +import { mkdirSync, readFileSync, statSync, watch, type FSWatcher } from 'node:fs' +import { homedir } from 'node:os' +import { dirname, join } from 'node:path' +import { CLAUDE_STATES, type ClaudeState } from '../pet-frame.js' + +/** + * How old a state file may be before it is disbelieved. + * + * A session killed with Ctrl+C may never fire its `SessionEnd` hook, leaving a file that would + * otherwise pin the cap on for the rest of the day. The mtime is the guard, which is why the + * file holds only a word: the timestamp already exists in the filesystem, and putting a second + * one in the payload would be a second source of truth for the same fact. + */ +export const CLAUDE_STATE_STALE_MS = 15 * 60_000 + +/** How often to re-read regardless of the watch. See `start()`. */ +const DEFAULT_POLL_MS = 5_000 + +export function defaultClaudeStateFile(): string { + return process.env.ARGOS_CLAUDE_STATE_FILE ?? join(homedir(), '.argos', 'claude-state') +} + +export interface ClaudeStateSourceOptions { + /** Defaults to `defaultClaudeStateFile()`. */ + file?: string + /** Injected so tests can drive staleness without waiting a quarter of an hour. */ + now?: () => number + pollMs?: number + onChange?: (state: ClaudeState) => void + log?: (message: string, meta?: unknown) => void +} + +export interface ClaudeStateSource { + start(): void + stop(): void + /** The last state read. Cheap: no disk access. */ + current(): ClaudeState + /** Re-read now and report a change if there is one. Returns the new state. */ + refresh(): ClaudeState +} + +const KNOWN = new Set(CLAUDE_STATES) + +function readState(file: string, nowMs: number): ClaudeState { + let raw: string + let mtimeMs: number + try { + mtimeMs = statSync(file).mtimeMs + raw = readFileSync(file, 'utf8') + } catch { + // Missing, unreadable, a directory, a permission error — all the same answer. + return 'none' + } + if (nowMs - mtimeMs > CLAUDE_STATE_STALE_MS) return 'none' + const word = raw.trim().toLowerCase() + return KNOWN.has(word) ? (word as ClaudeState) : 'none' +} + +export function createClaudeStateSource( + options: ClaudeStateSourceOptions = {}, +): ClaudeStateSource { + const file = options.file ?? defaultClaudeStateFile() + const now = options.now ?? Date.now + const pollMs = options.pollMs ?? DEFAULT_POLL_MS + const onChange = options.onChange ?? ((): void => {}) + const log = options.log ?? ((): void => {}) + + let state: ClaudeState = 'none' + let watcher: FSWatcher | null = null + let timer: NodeJS.Timeout | null = null + + const refresh = (): ClaudeState => { + const next = readState(file, now()) + if (next !== state) { + state = next + onChange(state) + } + return state + } + + return { + current: () => state, + refresh, + + start(): void { + // Make the directory ourselves so the watch has a target from the first launch, rather + // than silently doing nothing until the first hook happens to create it. + try { + mkdirSync(dirname(file), { recursive: true }) + } catch (error) { + log('claude-state: could not create the state directory', error) + } + + refresh() + + // Watch the *directory*, not the file: a writer that replaces the file swaps the inode, + // and a file-level watch is then pointed at something nothing will ever touch again. + try { + watcher = watch(dirname(file), { persistent: false }, () => { + refresh() + }) + } catch (error) { + log('claude-state: directory watch unavailable, polling only', error) + } + + // Backstop. fs.watch misses events on some platforms and filesystems, and a missed event + // here means a cap stuck on the wrong colour — the one failure the whole feature is + // supposed to prevent. + timer = setInterval(refresh, pollMs) + timer.unref?.() + }, + + stop(): void { + watcher?.close() + watcher = null + if (timer) clearInterval(timer) + timer = null + }, + } +} +``` + +- [ ] **Step 5: Run the tests and watch them pass** + +```bash +pnpm test -- tests/claude/claude-state-source.spec.ts +``` + +Expected: PASS, 15 tests. + +- [ ] **Step 6: Typecheck** + +```bash +pnpm typecheck +``` + +Expected: clean. + +- [ ] **Step 7: Commit** + +```bash +git add apps/desktop/src/claude/claude-state-source.ts apps/desktop/src/pet-frame.ts tests/claude/claude-state-source.spec.ts +git commit -m "feat: read Claude Code's state from a file + +One word in ~/.argos/claude-state, written by Claude Code hooks. The +hook is 'echo running > file' so it cannot fail in an interesting way. + +The file's mtime is the staleness guard, which is why the payload is a +bare word: a session killed with Ctrl+C never fires SessionEnd, and the +timestamp the guard needs already exists in the filesystem. + +Watches the directory rather than the file, because a writer that +replaces the file swaps the inode and leaves a file-level watch pointed +at nothing." +``` + +--- + +### Task 2: The frame field and the square + +**Files:** +- Modify: `apps/desktop/src/pet-frame.ts` +- Modify: `apps/desktop/src/renderer/pet.html` +- Modify: `apps/desktop/src/renderer/pet.ts` +- Modify: `apps/desktop/src/renderer/pet.css` +- Create: `tests/main/frame-region.spec.ts` +- Modify: `tests/renderer/discipline.spec.ts` + +**Interfaces:** +- Consumes: `CLAUDE_STATES`, `ClaudeState` from Task 1. +- Produces: + - `PetFrame.claudeState: ClaudeState` — a required field, so every existing frame construction site must set it (there is exactly one, in Task 3). + - `frameNeedsCellRegion(frame: Pick): boolean` + +- [ ] **Step 1: Write the failing tests** + +Create `tests/main/frame-region.spec.ts`: + +```ts +import { describe, it, expect } from 'vitest' +import { + petFrameSchema, + frameNeedsCellRegion, + type PetFrame, +} from '../../apps/desktop/src/pet-frame.js' + +function frame(overrides: Partial = {}): PetFrame { + return { + animation: 'idle', + animationNonce: 0, + facing: 'right', + sprite: { x: 0, y: 0 }, + bubbleSide: 'above', + scale: 1, + bubble: null, + quickActions: [], + overlay: 'none', + claudeState: 'none', + ...overrides, + } +} + +describe('claudeState on the frame', () => { + it.each(['none', 'waiting', 'running', 'idle'] as const)('round-trips %s', (state) => { + const parsed = petFrameSchema.safeParse(frame({ claudeState: state })) + expect(parsed.success).toBe(true) + expect(parsed.success && parsed.data.claudeState).toBe(state) + }) + + it('rejects a state the renderer has no colour for', () => { + expect(petFrameSchema.safeParse(frame({ claudeState: 'busy' as never })).success).toBe(false) + }) + + it('is required, so no frame can reach the renderer without one', () => { + const { claudeState: _dropped, ...without } = frame() + expect(petFrameSchema.safeParse(without).success).toBe(false) + }) +}) + +describe('frameNeedsCellRegion', () => { + // Electron's setShape decides where the system permits *drawing*, not just where clicks land. + // Anything outside the region is never painted. The cap sits over the hair, which is + // transparent in the alpha mask, so without this it would be invisible on Linux — and the + // screenshot harness would not catch it, because capturePage() ignores the window shape. + it('is false for a plain frame', () => { + expect(frameNeedsCellRegion(frame())).toBe(false) + }) + + it('is true while the sleep Z-s are up', () => { + expect(frameNeedsCellRegion(frame({ overlay: 'sleep-z' }))).toBe(true) + }) + + it.each(['waiting', 'running', 'idle'] as const)('is true while the cap is %s', (state) => { + expect(frameNeedsCellRegion(frame({ claudeState: state }))).toBe(true) + }) + + it('is true when both are up at once', () => { + // A sleeping pet still wears the cap. This is why claudeState is its own field rather than + // another value on `overlay`. + expect(frameNeedsCellRegion(frame({ overlay: 'sleep-z', claudeState: 'waiting' }))).toBe(true) + }) +}) +``` + +Then add to `tests/renderer/discipline.spec.ts`, inside the existing +`describe('hand-written CSS carries no generated geometry', ...)` block, after the +`anchors the bubble to the character` test: + +```ts + it('anchors the status cap to the character through the same custom properties', () => { + // Two halves in two files again: the renderer publishes the state, the CSS paints it. Either + // half being dropped leaves a cap that is silently never shown, which looks exactly like + // "Claude is not running" and so would not be noticed. + const pet = read(join(RENDERER_DIR, 'pet.ts')) + expect(pet).toContain('claudeState') + + const css = read(join(RENDERER_DIR, 'pet.css')) + expect(css).toMatch(/#claude-cap/) + expect(css).toMatch(/\[data-claude-state='waiting'\]/) + expect(css).toMatch(/\[data-claude-state='running'\]/) + expect(css).toMatch(/\[data-claude-state='idle'\]/) + // The cap tracks the head, not the window corner. + expect(css).toMatch(/#claude-cap[\s\S]*?var\(--body-cx/) + }) +``` + +- [ ] **Step 2: Run the tests and watch them fail** + +```bash +pnpm test -- tests/main/frame-region.spec.ts tests/renderer/discipline.spec.ts +``` + +Expected: `frame-region.spec.ts` fails to import `frameNeedsCellRegion`; the discipline test fails on `expect(pet).toContain('claudeState')`. + +- [ ] **Step 3: Add the field and the predicate** + +In `apps/desktop/src/pet-frame.ts`, inside `petFrameSchema`, directly after the `overlay` field: + +```ts + /** + * Claude Code's state, painted as a coloured cap on the pet's head. + * + * Its own field rather than another value on `overlay`, because the two are independent axes: + * `overlay` is single-valued and already owned by the sleep Z's, and a sleeping pet must still + * be able to wear the cap. Folding them together would make "asleep and waiting" + * unrepresentable. + */ + claudeState: z.enum(CLAUDE_STATES), +``` + +Then, at the end of the file, after the `IPC` declaration: + +```ts +/** + * Does this frame paint anything outside the character's own mask but inside the sprite cell? + * + * `setShape` determines the area where the system permits *drawing* — outside it, no pixels are + * drawn at all. The sleep Z's sit above the hair and the status cap sits on it, both in mask + * cells that are transparent, so both need the region widened to the whole cell or they are + * silently invisible on Linux. See the long note in `sprite/alpha-mask.ts`. + * + * A function here rather than an expression at the call site so it can be tested without a + * window: `pet-window.ts` is Electron all the way down. + */ +export function frameNeedsCellRegion( + frame: Pick, +): boolean { + return frame.overlay !== 'none' || frame.claudeState !== 'none' +} +``` + +- [ ] **Step 4: Add the element** + +In `apps/desktop/src/renderer/pet.html`, directly after the `#zzz` div: + +```html + + +``` + +- [ ] **Step 5: Publish the state from the renderer** + +In `apps/desktop/src/renderer/pet.ts`, in `applyFrame`, directly after the existing +`root.dataset.overlay = frame.overlay` line: + +```ts + root.dataset.claudeState = frame.claudeState +``` + +One attribute assignment and no branch, which is the only shape of change this file accepts. + +- [ ] **Step 6: Paint the square** + +Append to `apps/desktop/src/renderer/pet.css`: + +```css +/* + Claude Code status cap. + + A plain square standing in for cap art, positioned exactly where the art will go so the + anchoring proven here is the anchoring the art inherits. `--body-cx` and `--body-top` are + published per animation state and already multiplied by the scale, so this tracks the head + through every pose and every pet size without any arithmetic of its own. +*/ +#claude-cap { + position: absolute; + left: var(--body-cx, 50%); + top: calc(var(--body-top, 0px) - 3px * var(--pet-scale, 1)); + width: calc(26px * var(--pet-scale, 1)); + height: calc(13px * var(--pet-scale, 1)); + transform: translateX(-50%); + display: none; + pointer-events: none; + border-radius: 3px; + /* A dark keyline so the square reads against light wallpaper as well as dark. */ + box-shadow: + 0 0 0 1px rgba(0, 0, 0, 0.5), + 0 1px 3px rgba(0, 0, 0, 0.35); +} + +html[data-claude-state='waiting'] #claude-cap { + display: block; + background: #e5484d; +} + +html[data-claude-state='running'] #claude-cap { + display: block; + background: #f5a524; +} + +html[data-claude-state='idle'] #claude-cap { + display: block; + background: #30a46c; +} +``` + +- [ ] **Step 7: Run the tests** + +```bash +pnpm test -- tests/main/frame-region.spec.ts tests/renderer/discipline.spec.ts +``` + +Expected: PASS. If `stays small enough to read in one sitting` fails, `pet.ts` has crossed 150 code lines — it was at 137 and this adds one, so a failure means something else grew. + +- [ ] **Step 8: Commit** + +```bash +git add apps/desktop/src/pet-frame.ts apps/desktop/src/renderer/pet.html apps/desktop/src/renderer/pet.ts apps/desktop/src/renderer/pet.css tests/main/frame-region.spec.ts tests/renderer/discipline.spec.ts +git commit -m "feat: carry Claude Code's state across the frame seam + +Adds PetFrame.claudeState and a coloured square anchored to the pet's +head through --body-cx / --body-top, the same properties the sleep Z's +use, so it tracks the head through every pose and every pet size. + +A separate field from overlay because the two are independent axes: a +sleeping pet must still be able to wear the cap. + +frameNeedsCellRegion() exists as a function rather than an expression in +pet-window so it can be tested without Electron. It matters because +setShape governs painting, not just hit-testing, and the cap sits in +transparent mask cells." +``` + +--- + +### Task 3: Feed the state into the frame + +**Files:** +- Modify: `apps/desktop/src/main/pet-controller.ts` +- Modify: `apps/desktop/src/main/pet-window.ts` + +**Interfaces:** +- Consumes: `ClaudeState` and `frameNeedsCellRegion` from Task 2. +- Produces: `PetControllerOptions.getClaudeState?: () => ClaudeState`, defaulting to `() => 'none'`. + +- [ ] **Step 1: Add the controller option** + +In `apps/desktop/src/main/pet-controller.ts`, change the frame-type import to bring in the state type: + +```ts +import type { ClaudeState, PetFrame, Tone } from '../pet-frame.js' +``` + +Add to `PetControllerOptions`, after `getMovementEnabled`: + +```ts + /** + * Claude Code's state, for the status cap. + * + * Injected as a getter, like `getMovementEnabled`, so the controller stays ignorant of where + * the state comes from and the tests need no filesystem. + */ + getClaudeState?: () => ClaudeState +``` + +- [ ] **Step 2: Default it and read it** + +In `createPetController`, beside the other option defaults (next to `const now = options.now ?? Date.now`): + +```ts + const getClaudeState = options.getClaudeState ?? ((): ClaudeState => 'none') +``` + +In `buildFrame()`, after the `overlay:` line: + +```ts + claudeState: getClaudeState(), +``` + +- [ ] **Step 3: Widen the shape region for the cap** + +In `apps/desktop/src/main/pet-window.ts`, add to the existing frame-module import: + +```ts +import { frameNeedsCellRegion } from '../pet-frame.js' +``` + +(If `pet-window.ts` already imports named values from `../pet-frame.js`, add `frameNeedsCellRegion` to that import rather than writing a second one.) + +Replace the comment on the `lastOverlayVisible` declaration near line 186: + +```ts + /** + * Whether the last frame painted inside the sprite cell but outside the character mask — the + * sleep Z's, or the Claude status cap. Drives the shape region, which on Linux governs what is + * painted at all. + */ +``` + +And replace the assignment near line 338: + +```ts + lastOverlayVisible = frameNeedsCellRegion(parsed.data) +``` + +- [ ] **Step 4: Typecheck** + +```bash +pnpm typecheck +``` + +Expected: clean. A `claudeState` missing from an object literal here means a second frame construction site exists that this plan did not account for — set it to `'none'` and note it. + +- [ ] **Step 5: Run the whole suite** + +```bash +pnpm test +``` + +Expected: PASS, including everything that existed before. + +- [ ] **Step 6: Commit** + +```bash +git add apps/desktop/src/main/pet-controller.ts apps/desktop/src/main/pet-window.ts +git commit -m "feat: put the Claude status cap on the frame and in the shape region + +getClaudeState is injected like getMovementEnabled, so the controller +stays ignorant of where the state came from. + +The shape region now follows the cap as well as the sleep overlay. On +Linux that region governs painting, not just hit-testing, and the cap +sits over the hair in mask cells that are transparent - so without this +it would be invisible there, and the screenshot harness would not catch +it because capturePage() never consults the window shape." +``` + +--- + +### Task 4: Wire it into the app + +**Files:** +- Modify: `apps/desktop/src/main/app-shell.ts` + +**Interfaces:** +- Consumes: `createClaudeStateSource` from Task 1, `getClaudeState` from Task 3. +- Produces: nothing further. + +- [ ] **Step 1: Import the source** + +In `apps/desktop/src/main/app-shell.ts`, beside the other main-process imports (near the `createPetController` import at line 27): + +```ts +import { createClaudeStateSource } from '../claude/claude-state-source.js' +``` + +- [ ] **Step 2: Start it before the controller** + +Immediately before the `controller = createPetController({` call (around line 353): + +```ts + // Claude Code's state, for the cap. `tickNow` rather than waiting for the next tick: a colour + // that lags the terminal by a tick is not worth having, and `tickNow` is the existing seam for + // exactly this — it runs the tick body out of phase without resetting the interval. + const claudeState = createClaudeStateSource({ + log, + onChange() { + controller?.tickNow() + }, + }) + claudeState.start() +``` + +- [ ] **Step 3: Hand it to the controller** + +In the `createPetController({ ... })` options object, after `getMovementEnabled`: + +```ts + getClaudeState: () => claudeState.current(), +``` + +- [ ] **Step 4: Stop it on dispose** + +In `dispose()`, beside `controller?.stop()` (around line 1018): + +```ts + claudeState.stop() +``` + +- [ ] **Step 5: Typecheck and run the suite** + +```bash +pnpm typecheck && pnpm test +``` + +Expected: both clean. + +- [ ] **Step 6: Commit** + +```bash +git add apps/desktop/src/main/app-shell.ts +git commit -m "feat: start the Claude state source with the app + +A state change calls tickNow() rather than waiting for the next tick, so +the cap changes colour when the terminal does. tickNow is the existing +seam for out-of-phase updates and does not reset the interval." +``` + +--- + +### Task 5: The hooks, and proving it works + +**Files:** +- Create: `docs/CLAUDE-CODE.md` +- Modify: `README.md` + +**Interfaces:** +- Consumes: everything above. +- Produces: nothing in code. + +- [ ] **Step 1: Write the documentation** + +Create `docs/CLAUDE-CODE.md`: + +````markdown +# Claude Code status cap + +The pet wears a coloured square that follows what Claude Code is doing. + +| Colour | Meaning | +|---|---| +| 🔴 red | Claude Code is waiting for you to confirm something | +| 🟡 amber | Claude Code is working | +| 🟢 green | the task finished; ready for a new one | +| *no cap* | no Claude Code session, or the last signal is over 15 minutes old | + +This is a spike: a square, not cap art, and a single session. Two sessions at once will fight +over the colour. + +## How it works + +Claude Code hooks write one word to `~/.argos/claude-state`. Argos watches that file. That is +the whole mechanism — no port, no daemon, no dependency in either direction. If Argos is not +running, the hooks write a file nothing reads, and nothing breaks. + +## Setup + +Add this to `~/.claude/settings.json`. If the file already has a `hooks` key, merge into it +rather than replacing it. + +```json +{ + "hooks": { + "Notification": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo waiting > ~/.argos/claude-state" + } + ] + } + ], + "UserPromptSubmit": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + } + ] + } + ], + "PreToolUse": [ + { + "matcher": "*", + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + } + ] + } + ], + "PostToolUse": [ + { + "matcher": "*", + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + } + ] + } + ], + "Stop": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo idle > ~/.argos/claude-state" + } + ] + } + ], + "SessionEnd": [ + { + "hooks": [{ "type": "command", "command": "rm -f ~/.argos/claude-state" }] + } + ] + } +} +``` + +`PreToolUse` is what returns the cap to amber after you approve a prompt — answering a +permission request does not fire `Notification` again. + +## Testing it without Claude + +With Argos running: + +```bash +mkdir -p ~/.argos +echo waiting > ~/.argos/claude-state # red +echo running > ~/.argos/claude-state # amber +echo idle > ~/.argos/claude-state # green +rm ~/.argos/claude-state # gone +``` + +The colour changes within a second. This is the integration test worth running first: if these +work and the hooks do not, the hooks are the only remaining variable. + +Point Argos at a different file with `ARGOS_CLAUDE_STATE_FILE`. + +## Limits + +- **One session.** The last hook to fire wins, whichever session it came from. +- **Stale state.** A session killed with `Ctrl+C` never fires `SessionEnd`. Its file lingers, and + the cap stays until the file is 15 minutes old. +- **macOS only, so far.** The Linux shape-region handling is written but unverified. +```` + +- [ ] **Step 2: Link it from the README** + +In `README.md`, add a row to the feature table or a line in the docs list pointing at +`docs/CLAUDE-CODE.md`: + +```markdown +**It watches Claude Code.** Wire up a few hooks and the pet wears a coloured cap: red when Claude +Code needs a confirmation, amber while it works, green when it is done. See +[docs/CLAUDE-CODE.md](docs/CLAUDE-CODE.md). +``` + +- [ ] **Step 3: Build and run** + +```bash +pnpm build && pnpm dev +``` + +Expected: the pet appears with no cap. + +- [ ] **Step 4: Prove the integration by hand** + +In a second terminal, with the pet on screen: + +```bash +mkdir -p ~/.argos +echo waiting > ~/.argos/claude-state +``` + +Expected: a red square appears on the pet's head within a second. Then: + +```bash +echo running > ~/.argos/claude-state # turns amber +echo idle > ~/.argos/claude-state # turns green +rm ~/.argos/claude-state # disappears +``` + +Check the cap stays on the head while the pet **walks**, **jumps** and **sleeps** (leave it +alone, or turn movement off). A cap that detaches during a pose means `--body-top` is not being +tracked per state. + +Check it at all three sizes — right-click → Size. The square should scale with the pet. + +- [ ] **Step 5: Prove the hooks** + +Add the hooks from Step 1 to `~/.claude/settings.json`, start a Claude Code session, and give it +a task that needs a permission prompt. Expected: amber while it works, red at the prompt, amber +again once approved, green when it stops. + +- [ ] **Step 6: Full verification, then commit** + +```bash +pnpm typecheck && pnpm test && pnpm build +``` + +Expected: all three clean. + +```bash +git add docs/CLAUDE-CODE.md README.md +git commit -m "docs: how to wire Claude Code's state to the pet + +Includes the settings.json hook block and, more usefully, how to drive +the cap with echo so the transport can be proven before the hooks are +the variable under test." +``` + +--- + +## Done when + +- `pnpm typecheck`, `pnpm test` and `pnpm build` are all clean. +- `echo waiting > ~/.argos/claude-state` turns the square red on a running pet, and `rm` removes it. +- The square stays on the head while the pet walks, jumps and sleeps, at all three sizes. +- A real Claude Code session drives the colour through amber → red → amber → green. +- Nothing is pushed. The work sits on the local `claude-integration` branch. From c798d6b9aa5b7b591d1aa3515bcafe1988336a4b Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:30:02 +0530 Subject: [PATCH 03/12] feat: read Claude Code's state from a file One word in ~/.argos/claude-state, written by Claude Code hooks. The hook is 'echo running > file' so it cannot fail in an interesting way. The file's mtime is the staleness guard, which is why the payload is a bare word: a session killed with Ctrl+C never fires SessionEnd, and the timestamp the guard needs already exists in the filesystem. Watches the directory rather than the file, because a writer that replaces the file swaps the inode and leaves a file-level watch pointed at nothing. Co-Authored-By: Claude Opus 5 (1M context) --- .../desktop/src/claude/claude-state-source.ts | 131 ++++++++++++++++++ apps/desktop/src/pet-frame.ts | 11 ++ tests/claude/claude-state-source.spec.ts | 118 ++++++++++++++++ 3 files changed, 260 insertions(+) create mode 100644 apps/desktop/src/claude/claude-state-source.ts create mode 100644 tests/claude/claude-state-source.spec.ts diff --git a/apps/desktop/src/claude/claude-state-source.ts b/apps/desktop/src/claude/claude-state-source.ts new file mode 100644 index 0000000..b67d10d --- /dev/null +++ b/apps/desktop/src/claude/claude-state-source.ts @@ -0,0 +1,131 @@ +/** + * Claude Code's state, read off a file that Claude Code's hooks write. + * + * The transport is a file holding one word, because a hook that is `echo running > file` cannot + * fail in an interesting way: no JSON to parse, no port to bind, no dependency on either side. + * + * No Electron import. This module is the one place that knows how the state arrives, so it is + * also the only file that changes when multi-session support lands — at which point it reads a + * directory of per-session files and aggregates them instead. + */ + +import { mkdirSync, readFileSync, statSync, watch, type FSWatcher } from 'node:fs' +import { homedir } from 'node:os' +import { dirname, join } from 'node:path' +import { CLAUDE_STATES, type ClaudeState } from '../pet-frame.js' + +/** + * How old a state file may be before it is disbelieved. + * + * A session killed with Ctrl+C may never fire its `SessionEnd` hook, leaving a file that would + * otherwise pin the cap on for the rest of the day. The mtime is the guard, which is why the + * file holds only a word: the timestamp already exists in the filesystem, and putting a second + * one in the payload would be a second source of truth for the same fact. + */ +export const CLAUDE_STATE_STALE_MS = 15 * 60_000 + +/** How often to re-read regardless of the watch. See `start()`. */ +const DEFAULT_POLL_MS = 5_000 + +export function defaultClaudeStateFile(): string { + return process.env.ARGOS_CLAUDE_STATE_FILE ?? join(homedir(), '.argos', 'claude-state') +} + +export interface ClaudeStateSourceOptions { + /** Defaults to `defaultClaudeStateFile()`. */ + file?: string + /** Injected so tests can drive staleness without waiting a quarter of an hour. */ + now?: () => number + pollMs?: number + onChange?: (state: ClaudeState) => void + log?: (message: string, meta?: unknown) => void +} + +export interface ClaudeStateSource { + start(): void + stop(): void + /** The last state read. Cheap: no disk access. */ + current(): ClaudeState + /** Re-read now and report a change if there is one. Returns the new state. */ + refresh(): ClaudeState +} + +const KNOWN = new Set(CLAUDE_STATES) + +function readState(file: string, nowMs: number): ClaudeState { + let raw: string + let mtimeMs: number + try { + mtimeMs = statSync(file).mtimeMs + raw = readFileSync(file, 'utf8') + } catch { + // Missing, unreadable, a directory, a permission error — all the same answer. + return 'none' + } + if (nowMs - mtimeMs > CLAUDE_STATE_STALE_MS) return 'none' + const word = raw.trim().toLowerCase() + return KNOWN.has(word) ? (word as ClaudeState) : 'none' +} + +export function createClaudeStateSource( + options: ClaudeStateSourceOptions = {}, +): ClaudeStateSource { + const file = options.file ?? defaultClaudeStateFile() + const now = options.now ?? Date.now + const pollMs = options.pollMs ?? DEFAULT_POLL_MS + const onChange = options.onChange ?? ((): void => {}) + const log = options.log ?? ((): void => {}) + + let state: ClaudeState = 'none' + let watcher: FSWatcher | null = null + let timer: NodeJS.Timeout | null = null + + const refresh = (): ClaudeState => { + const next = readState(file, now()) + if (next !== state) { + state = next + onChange(state) + } + return state + } + + return { + current: () => state, + refresh, + + start(): void { + // Make the directory ourselves so the watch has a target from the first launch, rather + // than silently doing nothing until the first hook happens to create it. + try { + mkdirSync(dirname(file), { recursive: true }) + } catch (error) { + log('claude-state: could not create the state directory', error) + } + + refresh() + + // Watch the *directory*, not the file: a writer that replaces the file swaps the inode, + // and a file-level watch is then pointed at something nothing will ever touch again. + try { + watcher = watch(dirname(file), { persistent: false }, () => { + refresh() + }) + } catch (error) { + log('claude-state: directory watch unavailable, polling only', error) + } + + // Backstop. fs.watch misses events on some platforms and filesystems, and a missed event + // here means a cap stuck on the wrong colour — the one failure the whole feature is + // supposed to prevent. + timer = setInterval(refresh, pollMs) + timer.unref?.() + }, + + stop(): void { + watcher?.close() + watcher = null + if (timer) clearInterval(timer) + timer = null + }, + } +} diff --git a/apps/desktop/src/pet-frame.ts b/apps/desktop/src/pet-frame.ts index 200ca6a..0453f88 100644 --- a/apps/desktop/src/pet-frame.ts +++ b/apps/desktop/src/pet-frame.ts @@ -18,6 +18,17 @@ import { ANIMATION_STATES } from './pet-animations.generated.js' export const TONES = ['info', 'success', 'warning', 'error'] as const export type Tone = (typeof TONES)[number] +/** + * Claude Code's state, as the pet displays it. + * + * `none` is the absence of a signal — no state file, an unreadable one, or one too old to + * believe — and paints no cap at all. Every failure resolves here, because a status indicator + * that lies is worse than one that is absent: an absent cap is visibly absent, a wrong cap is + * silently wrong. + */ +export const CLAUDE_STATES = ['none', 'waiting', 'running', 'idle'] as const +export type ClaudeState = (typeof CLAUDE_STATES)[number] + /** Bubble text is clamped in main before it ever reaches here. */ export const BUBBLE_TEXT_MAX = 200 diff --git a/tests/claude/claude-state-source.spec.ts b/tests/claude/claude-state-source.spec.ts new file mode 100644 index 0000000..223bf06 --- /dev/null +++ b/tests/claude/claude-state-source.spec.ts @@ -0,0 +1,118 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtempSync, rmSync, writeFileSync, utimesSync, existsSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { + createClaudeStateSource, + CLAUDE_STATE_STALE_MS, +} from '../../apps/desktop/src/claude/claude-state-source.js' + +let dir: string +let file: string + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), 'argos-claude-')) + file = join(dir, 'claude-state') +}) + +afterEach(() => { + rmSync(dir, { recursive: true, force: true }) +}) + +/** `refresh()` rather than the poll, so no test depends on a timer firing. */ +function sourceFor(onChange?: (s: string) => void) { + return createClaudeStateSource({ file, onChange }) +} + +describe('claude state source', () => { + it('reports none when the file does not exist', () => { + expect(sourceFor().refresh()).toBe('none') + }) + + it('reports none when the whole directory is missing', () => { + const source = createClaudeStateSource({ file: join(dir, 'nope', 'claude-state') }) + expect(source.refresh()).toBe('none') + }) + + it.each(['waiting', 'running', 'idle'])('reads %s', (word) => { + writeFileSync(file, `${word}\n`) + expect(sourceFor().refresh()).toBe(word) + }) + + it('ignores surrounding whitespace and case', () => { + writeFileSync(file, ' WAITING \n') + expect(sourceFor().refresh()).toBe('waiting') + }) + + it('treats an unknown word as none', () => { + writeFileSync(file, 'thinking') + expect(sourceFor().refresh()).toBe('none') + }) + + it('treats an empty file as none', () => { + writeFileSync(file, '') + expect(sourceFor().refresh()).toBe('none') + }) + + it('treats a stale file as none, however good its contents', () => { + // A session killed with Ctrl+C never fires SessionEnd, so the file outlives the session. + writeFileSync(file, 'waiting') + const old = new Date(Date.now() - CLAUDE_STATE_STALE_MS - 60_000) + utimesSync(file, old, old) + expect(sourceFor().refresh()).toBe('none') + }) + + it('picks up a change on the next refresh', () => { + writeFileSync(file, 'running') + const source = sourceFor() + expect(source.refresh()).toBe('running') + writeFileSync(file, 'waiting') + expect(source.refresh()).toBe('waiting') + }) + + it('reports a deletion as none', () => { + writeFileSync(file, 'running') + const source = sourceFor() + expect(source.refresh()).toBe('running') + rmSync(file) + expect(source.refresh()).toBe('none') + }) + + it('fires onChange once per distinct state, not once per read', () => { + const seen: string[] = [] + const source = sourceFor((s) => seen.push(s)) + writeFileSync(file, 'running') + source.refresh() + source.refresh() + writeFileSync(file, 'running\n') + source.refresh() + writeFileSync(file, 'waiting') + source.refresh() + expect(seen).toEqual(['running', 'waiting']) + }) + + it('exposes the last read through current() without touching the disk', () => { + writeFileSync(file, 'idle') + const source = sourceFor() + source.refresh() + rmSync(file) + expect(source.current()).toBe('idle') + }) + + it('creates the directory on start so the watch has something to watch', () => { + // Without this the watch silently does nothing until the first hook happens to create the + // directory, which looks exactly like the feature not working. + const nested = join(dir, 'made-by-start', 'claude-state') + const source = createClaudeStateSource({ file: nested }) + source.start() + source.stop() + expect(existsSync(join(dir, 'made-by-start'))).toBe(true) + }) + + it('start() then stop() leaves no live handles', () => { + const source = sourceFor() + source.start() + expect(() => source.stop()).not.toThrow() + expect(() => source.stop()).not.toThrow() + }) +}) From 44ae32b8c8e913d884c4a009ccaa2e5c172a1ebb Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:31:44 +0530 Subject: [PATCH 04/12] feat: carry Claude Code's state across the frame seam and onto the pet Adds PetFrame.claudeState and a coloured square anchored to the pet's head through --body-cx / --body-top, the same properties the sleep Z's use, so it tracks the head through every pose and every pet size. A separate field from overlay because the two are independent axes: a sleeping pet must still be able to wear the cap. The shape region now follows the cap as well as the sleep overlay, through frameNeedsCellRegion(). That is a function rather than an expression in pet-window so it can be tested without Electron, and it matters because setShape governs painting and not just hit-testing -- the cap sits over the hair, in mask cells that are transparent, so without it the cap would be invisible on Linux and the screenshot harness would not catch it, capturePage() never consulting the shape. getClaudeState is injected like getMovementEnabled, keeping the controller ignorant of where the state came from. Combines what the plan listed as tasks 2 and 3: the required frame field leaves pet-controller failing to typecheck until its call site is updated, so splitting them would have committed a broken tree. Co-Authored-By: Claude Opus 5 (1M context) --- apps/desktop/src/main/pet-controller.ts | 11 ++++- apps/desktop/src/main/pet-window.ts | 10 ++-- apps/desktop/src/pet-frame.ts | 27 +++++++++++ apps/desktop/src/renderer/pet.css | 39 +++++++++++++++ apps/desktop/src/renderer/pet.html | 2 + apps/desktop/src/renderer/pet.ts | 1 + tests/main/frame-region.spec.ts | 63 +++++++++++++++++++++++++ tests/renderer/discipline.spec.ts | 16 +++++++ 8 files changed, 165 insertions(+), 4 deletions(-) create mode 100644 tests/main/frame-region.spec.ts diff --git a/apps/desktop/src/main/pet-controller.ts b/apps/desktop/src/main/pet-controller.ts index 982dfa9..58f8ab1 100644 --- a/apps/desktop/src/main/pet-controller.ts +++ b/apps/desktop/src/main/pet-controller.ts @@ -21,7 +21,7 @@ import { advance, initialState } from '../motion/motion-engine.js' import { DEFAULT_MOTION_CONFIG, type MotionConfig } from '../motion/motion-config.js' import type { MotionState, MotionTrigger } from '../motion/types.js' import { ANIMATIONS, resolveTrigger, type Trigger, type AnimationState } from '../pet-animations.generated.js' -import type { PetFrame, Tone } from '../pet-frame.js' +import type { ClaudeState, PetFrame, Tone } from '../pet-frame.js' import { DRINK_LOOP_GAP_MS } from '../config/constants.js' import { floorForWorkArea, @@ -48,6 +48,13 @@ export interface PetControllerOptions { pet: PetWindow displays: DisplayManager getMovementEnabled: () => boolean + /** + * Claude Code's state, for the status cap. + * + * Injected as a getter, like `getMovementEnabled`, so the controller stays ignorant of where + * the state comes from and the tests need no filesystem. + */ + getClaudeState?: () => ClaudeState /** `feetY` is null when the pet is floor-locked, meaning "re-derive it on launch". */ onPositionChanged: (displayKey: string, petCentreX: number, feetY: number | null) => void /** Fired after a tick when the pose changed, so the hover chip can return after electrocute. */ @@ -114,6 +121,7 @@ export interface PetController { export function createPetController(options: PetControllerOptions): PetController { const config = options.config ?? DEFAULT_MOTION_CONFIG const now = options.now ?? Date.now + const getClaudeState = options.getClaudeState ?? ((): ClaudeState => 'none') const log = options.log ?? (() => {}) const { pet, displays } = options @@ -165,6 +173,7 @@ export function createPetController(options: PetControllerOptions): PetControlle : null, quickActions: callout ? [] : [...quickActions], overlay: animation === config.sleepAnimation ? 'sleep-z' : 'none', + claudeState: getClaudeState(), } } diff --git a/apps/desktop/src/main/pet-window.ts b/apps/desktop/src/main/pet-window.ts index 7d3d569..c34d03c 100644 --- a/apps/desktop/src/main/pet-window.ts +++ b/apps/desktop/src/main/pet-window.ts @@ -27,7 +27,7 @@ import { spriteScreenRect, type BubbleSide, } from '../sprite/alpha-mask.js' -import { IPC, petFrameSchema, type PetFrame } from '../pet-frame.js' +import { IPC, frameNeedsCellRegion, petFrameSchema, type PetFrame } from '../pet-frame.js' import { rendererFile, paths } from './paths.js' import { emit } from './harness-handshake.js' import type { DisplaySnapshot, Floor } from './display-manager.js' @@ -183,7 +183,11 @@ export async function createPetWindow(options: { let lastAnimation: string | null = null /** Whether the last frame carried a bubble. Drives the shape region and the callout raise. */ let lastBubbleVisible = false - /** Whether the last frame carried a CSS overlay — the sleep Z's. Drives the shape region. */ + /** + * Whether the last frame painted inside the sprite cell but outside the character mask — the + * sleep Z's, or the Claude status cap. Drives the shape region, which on Linux governs what is + * painted at all. + */ let lastOverlayVisible = false /** Whether the hover quick-action menu is up. Drives the shape region on Linux. */ let lastQuickMenuVisible = false @@ -335,7 +339,7 @@ export async function createPetWindow(options: { const previous = { lastAnimation, lastBubbleVisible, lastOverlayVisible, lastQuickMenuVisible } lastAnimation = parsed.data.animation lastBubbleVisible = parsed.data.bubble !== null - lastOverlayVisible = parsed.data.overlay !== 'none' + lastOverlayVisible = frameNeedsCellRegion(parsed.data) lastQuickMenuVisible = parsed.data.quickActions.length > 0 win.webContents.send(IPC.frame, parsed.data) forwarding.setForceInteractive( diff --git a/apps/desktop/src/pet-frame.ts b/apps/desktop/src/pet-frame.ts index 0453f88..c9d7ed6 100644 --- a/apps/desktop/src/pet-frame.ts +++ b/apps/desktop/src/pet-frame.ts @@ -114,6 +114,16 @@ export const petFrameSchema = z.strictObject({ /** Pure-CSS overlays. `sleep-z` is what lets `sleep` ship with no new art. */ overlay: z.enum(['none', 'sleep-z']), + + /** + * Claude Code's state, painted as a coloured cap on the pet's head. + * + * Its own field rather than another value on `overlay`, because the two are independent axes: + * `overlay` is single-valued and already owned by the sleep Z's, and a sleeping pet must still + * be able to wear the cap. Folding them together would make "asleep and waiting" + * unrepresentable. + */ + claudeState: z.enum(CLAUDE_STATES), }) export type PetFrame = z.infer @@ -140,3 +150,20 @@ export const IPC = { bubbleAction: 'keycode-pet:bubble-action', quickAction: 'keycode-pet:quick-action', } as const + +/** + * Does this frame paint anything outside the character's own mask but inside the sprite cell? + * + * `setShape` determines the area where the system permits *drawing* — outside it, no pixels are + * drawn at all. The sleep Z's sit above the hair and the status cap sits on it, both in mask + * cells that are transparent, so both need the region widened to the whole cell or they are + * silently invisible on Linux. See the long note in `sprite/alpha-mask.ts`. + * + * A function here rather than an expression at the call site so it can be tested without a + * window: `pet-window.ts` is Electron all the way down. + */ +export function frameNeedsCellRegion( + frame: Pick, +): boolean { + return frame.overlay !== 'none' || frame.claudeState !== 'none' +} diff --git a/apps/desktop/src/renderer/pet.css b/apps/desktop/src/renderer/pet.css index d27680c..623b185 100644 --- a/apps/desktop/src/renderer/pet.css +++ b/apps/desktop/src/renderer/pet.css @@ -462,3 +462,42 @@ html[data-overlay='sleep-z'] #zzz { transform: translate(16px, -26px) rotate(10deg); } } + +/* + Claude Code status cap. + + A plain square standing in for cap art, positioned exactly where the art will go so the + anchoring proven here is the anchoring the art inherits. `--body-cx` and `--body-top` are + published per animation state and already multiplied by the scale, so this tracks the head + through every pose and every pet size without any arithmetic of its own. +*/ +#claude-cap { + position: absolute; + left: var(--body-cx, 50%); + top: calc(var(--body-top, 0px) - 3px * var(--pet-scale, 1)); + width: calc(26px * var(--pet-scale, 1)); + height: calc(13px * var(--pet-scale, 1)); + transform: translateX(-50%); + display: none; + pointer-events: none; + border-radius: 3px; + /* A dark keyline so the square reads against light wallpaper as well as dark. */ + box-shadow: + 0 0 0 1px rgba(0, 0, 0, 0.5), + 0 1px 3px rgba(0, 0, 0, 0.35); +} + +html[data-claude-state='waiting'] #claude-cap { + display: block; + background: #e5484d; +} + +html[data-claude-state='running'] #claude-cap { + display: block; + background: #f5a524; +} + +html[data-claude-state='idle'] #claude-cap { + display: block; + background: #30a46c; +} diff --git a/apps/desktop/src/renderer/pet.html b/apps/desktop/src/renderer/pet.html index bf51253..5423b32 100644 --- a/apps/desktop/src/renderer/pet.html +++ b/apps/desktop/src/renderer/pet.html @@ -40,6 +40,8 @@ + + diff --git a/apps/desktop/src/renderer/pet.ts b/apps/desktop/src/renderer/pet.ts index e9aa8f2..dd7bed5 100644 --- a/apps/desktop/src/renderer/pet.ts +++ b/apps/desktop/src/renderer/pet.ts @@ -70,6 +70,7 @@ function applyFrame(frame: PetFrame): void { sprite.dataset.facing = frame.facing root.dataset.overlay = frame.overlay + root.dataset.claudeState = frame.claudeState bubble.dataset.side = frame.bubbleSide quickMenu.dataset.actions = frame.quickActions.join(' ') quickMenu.hidden = frame.quickActions.length === 0 diff --git a/tests/main/frame-region.spec.ts b/tests/main/frame-region.spec.ts new file mode 100644 index 0000000..b86d050 --- /dev/null +++ b/tests/main/frame-region.spec.ts @@ -0,0 +1,63 @@ +import { describe, it, expect } from 'vitest' +import { + petFrameSchema, + frameNeedsCellRegion, + type PetFrame, +} from '../../apps/desktop/src/pet-frame.js' + +function frame(overrides: Partial = {}): PetFrame { + return { + animation: 'idle', + animationNonce: 0, + facing: 'right', + sprite: { x: 0, y: 0 }, + bubbleSide: 'above', + scale: 1, + bubble: null, + quickActions: [], + overlay: 'none', + claudeState: 'none', + ...overrides, + } +} + +describe('claudeState on the frame', () => { + it.each(['none', 'waiting', 'running', 'idle'] as const)('round-trips %s', (state) => { + const parsed = petFrameSchema.safeParse(frame({ claudeState: state })) + expect(parsed.success).toBe(true) + expect(parsed.success && parsed.data.claudeState).toBe(state) + }) + + it('rejects a state the renderer has no colour for', () => { + expect(petFrameSchema.safeParse(frame({ claudeState: 'busy' as never })).success).toBe(false) + }) + + it('is required, so no frame can reach the renderer without one', () => { + const { claudeState: _dropped, ...without } = frame() + expect(petFrameSchema.safeParse(without).success).toBe(false) + }) +}) + +describe('frameNeedsCellRegion', () => { + // Electron's setShape decides where the system permits *drawing*, not just where clicks land. + // Anything outside the region is never painted. The cap sits over the hair, which is + // transparent in the alpha mask, so without this it would be invisible on Linux — and the + // screenshot harness would not catch it, because capturePage() ignores the window shape. + it('is false for a plain frame', () => { + expect(frameNeedsCellRegion(frame())).toBe(false) + }) + + it('is true while the sleep Z-s are up', () => { + expect(frameNeedsCellRegion(frame({ overlay: 'sleep-z' }))).toBe(true) + }) + + it.each(['waiting', 'running', 'idle'] as const)('is true while the cap is %s', (state) => { + expect(frameNeedsCellRegion(frame({ claudeState: state }))).toBe(true) + }) + + it('is true when both are up at once', () => { + // A sleeping pet still wears the cap. This is why claudeState is its own field rather than + // another value on `overlay`. + expect(frameNeedsCellRegion(frame({ overlay: 'sleep-z', claudeState: 'waiting' }))).toBe(true) + }) +}) diff --git a/tests/renderer/discipline.spec.ts b/tests/renderer/discipline.spec.ts index 55cdaeb..4ceddd5 100644 --- a/tests/renderer/discipline.spec.ts +++ b/tests/renderer/discipline.spec.ts @@ -137,6 +137,22 @@ describe('hand-written CSS carries no generated geometry', () => { expect(css).toMatch(/var\(--body-top/) }) + it('anchors the status cap to the character through the same custom properties', () => { + // Two halves in two files again: the renderer publishes the state, the CSS paints it. Either + // half being dropped leaves a cap that is silently never shown, which looks exactly like + // "Claude is not running" and so would not be noticed. + const pet = read(join(RENDERER_DIR, 'pet.ts')) + expect(pet).toContain('claudeState') + + const css = read(join(RENDERER_DIR, 'pet.css')) + expect(css).toMatch(/#claude-cap/) + expect(css).toMatch(/\[data-claude-state='waiting'\]/) + expect(css).toMatch(/\[data-claude-state='running'\]/) + expect(css).toMatch(/\[data-claude-state='idle'\]/) + // The cap tracks the head, not the window corner. + expect(css).toMatch(/#claude-cap[\s\S]*?var\(--body-cx/) + }) + it('scales the sprite by transform, and publishes the scale', () => { // The generated keyframes step `background-position` in absolute pixels off the unscaled sheet. // Resizing the element or its background-size to change the pet's size would invalidate every one From 4aa39065f2a39a0431311db241653a27908d8f2f Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:32:04 +0530 Subject: [PATCH 05/12] feat: start the Claude state source with the app A state change calls tickNow() rather than waiting for the next tick, so the cap changes colour when the terminal does. tickNow is the existing seam for out-of-phase updates and does not reset the interval. Co-Authored-By: Claude Opus 5 (1M context) --- apps/desktop/src/main/app-shell.ts | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/apps/desktop/src/main/app-shell.ts b/apps/desktop/src/main/app-shell.ts index e62db95..07bcde9 100644 --- a/apps/desktop/src/main/app-shell.ts +++ b/apps/desktop/src/main/app-shell.ts @@ -25,6 +25,7 @@ import { SettingsStore } from './settings-store.js' import { createTray, type TrayController } from './tray.js' import { createPetWindow, type PetWindow } from './pet-window.js' import { createPetController, type PetController } from './pet-controller.js' +import { createClaudeStateSource } from '../claude/claude-state-source.js' import { createMenuController, type MenuController } from './menu.js' import { createActions } from './actions.js' import type { MenuViewModel, UpdateState } from './menu-template.js' @@ -350,10 +351,22 @@ export async function startApp(): Promise { }, }) + // Claude Code's state, for the cap. `tickNow` rather than waiting for the next tick: a colour + // that lags the terminal by a tick is not worth having, and `tickNow` is the existing seam for + // exactly this — it runs the tick body out of phase without resetting the interval. + const claudeState = createClaudeStateSource({ + log, + onChange() { + controller?.tickNow() + }, + }) + claudeState.start() + controller = createPetController({ pet, displays, getMovementEnabled: () => settings.get().movementEnabled, + getClaudeState: () => claudeState.current(), onPositionChanged(displayKey, petCentreX, feetY) { settings.patch({ position: { displayKey, x: petCentreX, feetY } }) }, @@ -1016,6 +1029,7 @@ export async function startApp(): Promise { callouts.dispose() toasts.destroyAll() controller?.stop() + claudeState.stop() // Flush before tearing anything down — an unflushed position or reminder deadline is // exactly the state that must survive a quit. await settings.flush() From 40537d3da28085b2b16b2e5612d342801469fd3a Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:34:33 +0530 Subject: [PATCH 06/12] docs: how to wire Claude Code's state to the pet Includes the settings.json hook block and, more usefully, how to drive the cap with echo so the transport can be proven before the hooks are the variable under test. Records a limit found while verifying with the screenshot harness: the cap hangs off --body-cx, which is the centre of the character's bounding box rather than of its head, so it sits visibly left of the head in the jumping pose. The alpha mask publishes headTopByState but no matching head centre; generating one is the fix, and is worth doing when the real cap art lands rather than before. Co-Authored-By: Claude Opus 5 (1M context) --- README.md | 1 + docs/CLAUDE-CODE.md | 122 +++++++++++++++++++++++++++++++ docs/demo/claude-cap-waiting.png | Bin 0 -> 54856 bytes 3 files changed, 123 insertions(+) create mode 100644 docs/CLAUDE-CODE.md create mode 100644 docs/demo/claude-cap-waiting.png diff --git a/README.md b/README.md index 04ff2e4..4458c8d 100644 --- a/README.md +++ b/README.md @@ -261,6 +261,7 @@ made every install think a phantom `0.6.0` was available. | [docs/VERIFICATION.md](docs/VERIFICATION.md) | The screenshot loop, and **what is not verified** | | [DECISIONS.md](DECISIONS.md) | Every deviation from the brief, the issue, or openpets — with reasons | | [docs/ASSETS.md](docs/ASSETS.md) | Swapping the art with no code changes | +| [docs/CLAUDE-CODE.md](docs/CLAUDE-CODE.md) | Wiring Claude Code's state to a coloured cap on the pet | | [docs/PROMPT.md](docs/PROMPT.md) | The implementation brief this was built from, errors corrected in place | | [SECURITY.md](SECURITY.md) | Reporting a vulnerability | | [THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md) | openpets (MIT), Noto Color Emoji (OFL 1.1 / Apache-2.0) | diff --git a/docs/CLAUDE-CODE.md b/docs/CLAUDE-CODE.md new file mode 100644 index 0000000..fcd148d --- /dev/null +++ b/docs/CLAUDE-CODE.md @@ -0,0 +1,122 @@ +# Claude Code status cap + +The pet wears a coloured square that follows what Claude Code is doing. + +| Colour | Meaning | +|---|---| +| 🔴 red | Claude Code is waiting for you to confirm something | +| 🟡 amber | Claude Code is working | +| 🟢 green | the task finished; ready for a new one | +| *no cap* | no Claude Code session, or the last signal is over 15 minutes old | + +This is a spike: a square, not cap art, and a single session. Two sessions at once will fight +over the colour. + +![The pet wearing a red status square, with a speech bubble above it](demo/claude-cap-waiting.png) + +## How it works + +Claude Code hooks write one word to `~/.argos/claude-state`. Argos watches that file. That is +the whole mechanism — no port, no daemon, no dependency in either direction. If Argos is not +running, the hooks write a file nothing reads, and nothing breaks. + +## Setup + +Add this to `~/.claude/settings.json`. If the file already has a `hooks` key, merge into it +rather than replacing it. + +```json +{ + "hooks": { + "Notification": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo waiting > ~/.argos/claude-state" + } + ] + } + ], + "UserPromptSubmit": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + } + ] + } + ], + "PreToolUse": [ + { + "matcher": "*", + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + } + ] + } + ], + "PostToolUse": [ + { + "matcher": "*", + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + } + ] + } + ], + "Stop": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos && echo idle > ~/.argos/claude-state" + } + ] + } + ], + "SessionEnd": [ + { + "hooks": [{ "type": "command", "command": "rm -f ~/.argos/claude-state" }] + } + ] + } +} +``` + +`PreToolUse` is what returns the cap to amber after you approve a prompt — answering a +permission request does not fire `Notification` again. + +## Testing it without Claude + +With Argos running: + +```bash +mkdir -p ~/.argos +echo waiting > ~/.argos/claude-state # red +echo running > ~/.argos/claude-state # amber +echo idle > ~/.argos/claude-state # green +rm ~/.argos/claude-state # gone +``` + +The colour changes within a second. This is the integration test worth running first: if these +work and the hooks do not, the hooks are the only remaining variable. + +Point Argos at a different file with `ARGOS_CLAUDE_STATE_FILE`. + +## Limits + +- **One session.** The last hook to fire wins, whichever session it came from. +- **Stale state.** A session killed with `Ctrl+C` never fires `SessionEnd`. Its file lingers, and + the cap stays until the file is 15 minutes old. +- **The cap drifts sideways in some poses.** It hangs off `--body-cx`, which is the centre of the + character's *bounding box*, not the centre of its head. In `idle` and `running` the two agree + closely enough; in `jumping` the pet leans and the cap is visibly left of the head. The alpha + mask publishes `headTopByState` but no matching head centre, so fixing this properly means + generating one — worth doing before the real cap art lands, pointless before then. +- **macOS only, so far.** The Linux shape-region handling is written but unverified. diff --git a/docs/demo/claude-cap-waiting.png b/docs/demo/claude-cap-waiting.png new file mode 100644 index 0000000000000000000000000000000000000000..7c1f734df70b419c189787ee6b41e149dff83827 GIT binary patch literal 54856 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ⅅ0?H#NEci>Su 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 literal 0 HcmV?d00001 From cb5fbb7f3e9a90e1ef88e1c01e3128adb165d52b Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:39:45 +0530 Subject: [PATCH 07/12] docs: correct the hook block to the form actually installed PreToolUse and PostToolUse carry no matcher rather than "*". An omitted matcher matches every tool and is the shape the settings schema guarantees; "*" is only a convention. Verified live: with these hooks installed, the state file went to "running" on the next tool call, with no restart -- the settings watcher reloads the file on its own. Co-Authored-By: Claude Opus 5 (1M context) --- docs/CLAUDE-CODE.md | 34 ++++++++++++++++++++++++---------- 1 file changed, 24 insertions(+), 10 deletions(-) diff --git a/docs/CLAUDE-CODE.md b/docs/CLAUDE-CODE.md index fcd148d..74c6559 100644 --- a/docs/CLAUDE-CODE.md +++ b/docs/CLAUDE-CODE.md @@ -28,44 +28,46 @@ rather than replacing it. ```json { "hooks": { - "Notification": [ + "UserPromptSubmit": [ { "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo waiting > ~/.argos/claude-state" + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state", + "timeout": 5 } ] } ], - "UserPromptSubmit": [ + "Notification": [ { "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + "command": "mkdir -p ~/.argos && echo waiting > ~/.argos/claude-state", + "timeout": 5 } ] } ], "PreToolUse": [ { - "matcher": "*", "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state", + "timeout": 5 } ] } ], "PostToolUse": [ { - "matcher": "*", "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state" + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state", + "timeout": 5 } ] } @@ -75,14 +77,21 @@ rather than replacing it. "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo idle > ~/.argos/claude-state" + "command": "mkdir -p ~/.argos && echo idle > ~/.argos/claude-state", + "timeout": 5 } ] } ], "SessionEnd": [ { - "hooks": [{ "type": "command", "command": "rm -f ~/.argos/claude-state" }] + "hooks": [ + { + "type": "command", + "command": "rm -f ~/.argos/claude-state", + "timeout": 5 + } + ] } ] } @@ -92,6 +101,11 @@ rather than replacing it. `PreToolUse` is what returns the cap to amber after you approve a prompt — answering a permission request does not fire `Notification` again. +`PreToolUse` and `PostToolUse` carry no `matcher`, which matches every tool. `"*"` is +commonly written for this, but an omitted matcher is the form the settings schema guarantees. + +Claude Code picks the hooks up without a restart — its settings watcher reloads the file. + ## Testing it without Claude With Argos running: From 1516c35da1816bcd3299b7978915ba5274dd85d1 Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:47:45 +0530 Subject: [PATCH 08/12] fix: make the status cap bob with the pet The cap sat still while the pet breathed. Root cause: it was anchored to --body-top, and the pet's bounce is entirely background-position stepping, so the sprite element never moves and nothing anchored to a per-state constant can follow it. --body-top comes from headTopByState, which is the minimum across a state's frames. That is deliberate -- mask.mjs says so in as many words, because a speech bubble that bobs with the pet's breathing is worse than one that hangs still. Correct for a bubble, exactly wrong for a hat: the cap parked at the highest point the head ever reaches and never came down. Measured from the art: idle's two frames sit 7px apart, so on the second frame the cap floated a gap wider than half its own 13px height. The cap now runs its own generated animation on the sprite's clock, one step-end stop per frame holding that frame's real head anchor. step-end rather than a two-endpoint ramp because the head tops are not a ramp -- jumping runs 44,42,42,42,50 -- so interpolating would miss on most frames. Per-frame anchors carry a head centre as well as a top, which also fixes the sideways drift documented earlier: --body-cx was the body's bounding box centre, and the head swings 9px against it in jumping. Verified by capturing both idle frames: cap top moved 289->303 and pet top moved 287->301, both 14px, in lockstep. Co-Authored-By: Claude Opus 5 (1M context) --- apps/desktop/src/renderer/pet.css | 21 +- apps/desktop/src/renderer/pet.generated.css | 688 ++++++++++++++++++++ apps/desktop/src/renderer/pet.ts | 5 + docs/CLAUDE-CODE.md | 5 - docs/demo/claude-cap-waiting.png | Bin 54856 -> 30509 bytes scripts/generate-sprite-css.mjs | 70 +- scripts/lib/mask.mjs | 73 +++ tests/renderer/discipline.spec.ts | 24 +- tests/sprite/cap-anchor.spec.ts | 103 +++ 9 files changed, 972 insertions(+), 17 deletions(-) create mode 100644 tests/sprite/cap-anchor.spec.ts diff --git a/apps/desktop/src/renderer/pet.css b/apps/desktop/src/renderer/pet.css index 623b185..a7e0ff5 100644 --- a/apps/desktop/src/renderer/pet.css +++ b/apps/desktop/src/renderer/pet.css @@ -467,17 +467,26 @@ html[data-overlay='sleep-z'] #zzz { Claude Code status cap. A plain square standing in for cap art, positioned exactly where the art will go so the - anchoring proven here is the anchoring the art inherits. `--body-cx` and `--body-top` are - published per animation state and already multiplied by the scale, so this tracks the head - through every pose and every pet size without any arithmetic of its own. + anchoring proven here is the anchoring the art inherits. + + Placement is split in two: this rule sizes the cap and parks it on the sprite cell's corner, + and `pet.generated.css` animates the `translate` property through one stop per animation frame, + holding each frame's real head anchor. That split is why the geometry stays generated — the + per-frame head positions come out of the art, and nothing here hardcodes one. */ #claude-cap { position: absolute; - left: var(--body-cx, 50%); - top: calc(var(--body-top, 0px) - 3px * var(--pet-scale, 1)); + /* The cell's corner is the origin; the generated per-frame keyframes translate from here. + Anchoring to --body-top instead would pin the cap to a per-state constant, and the pet's + bounce is background-position stepping — the sprite element never moves, so the cap would + hang in the air while the character bobs underneath it. */ + left: var(--sprite-x, 0px); + top: var(--sprite-y, 0px); width: calc(26px * var(--pet-scale, 1)); height: calc(13px * var(--pet-scale, 1)); - transform: translateX(-50%); + /* Composes with the `translate` property the keyframes animate: that puts the anchor on the + head, this centres the cap on it and drops it far enough to sit on the hair. */ + transform: translate(-50%, -20%); display: none; pointer-events: none; border-radius: 3px; diff --git a/apps/desktop/src/renderer/pet.generated.css b/apps/desktop/src/renderer/pet.generated.css index 34744ab..02dfdac 100644 --- a/apps/desktop/src/renderer/pet.generated.css +++ b/apps/desktop/src/renderer/pet.generated.css @@ -299,3 +299,691 @@ .pet-sprite[data-state="waving"][data-nonce="1"] { animation: kp-waving-1 2700ms steps(18, jump-none) 1 forwards; } + +/* The status cap rides the same clock as the sprite; see buildCapCss. */ +#claude-cap { + animation-timing-function: step-end; +} + +@keyframes kp-cap-drink-0 { + 0% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 9.0909% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 18.1818% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 27.2727% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 36.3636% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 45.4545% { translate: calc(90px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 54.5455% { translate: calc(90px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 63.6364% { translate: calc(96px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 72.7273% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 81.8182% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 90.9091% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-drink-1 { + 0% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 9.0909% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 18.1818% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 27.2727% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 36.3636% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 45.4545% { translate: calc(90px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 54.5455% { translate: calc(90px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 63.6364% { translate: calc(96px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 72.7273% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 81.8182% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 90.9091% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +html[data-pet-state="drink"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-drink-0 2200ms step-end 2 forwards; +} +html[data-pet-state="drink"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-drink-1 2200ms step-end 2 forwards; +} + +@keyframes kp-cap-electrocute-0 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 4.7619% { translate: calc(98px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 9.5238% { translate: calc(85px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(85px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 19.0476% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 23.8095% { translate: calc(100px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(93px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(93px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 38.0952% { translate: calc(93px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(78px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 47.619% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 52.381% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 61.9048% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(86px * var(--pet-scale, 1)) calc(54px * var(--pet-scale, 1)); } + 76.1905% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 80.9524% { translate: calc(105px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 90.4762% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 95.2381% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-electrocute-1 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 4.7619% { translate: calc(98px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 9.5238% { translate: calc(85px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(85px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 19.0476% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 23.8095% { translate: calc(100px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(93px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(93px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 38.0952% { translate: calc(93px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(78px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 47.619% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 52.381% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 61.9048% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(86px * var(--pet-scale, 1)) calc(54px * var(--pet-scale, 1)); } + 76.1905% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 80.9524% { translate: calc(105px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 90.4762% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 95.2381% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } +} +html[data-pet-state="electrocute"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-electrocute-0 2100ms step-end 1 forwards; +} +html[data-pet-state="electrocute"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-electrocute-1 2100ms step-end 1 forwards; +} + +@keyframes kp-cap-failed-0 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-failed-1 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +html[data-pet-state="failed"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-failed-0 1220ms step-end 2 forwards; +} +html[data-pet-state="failed"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-failed-1 1220ms step-end 2 forwards; +} + +@keyframes kp-cap-idle-0 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-idle-1 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +html[data-pet-state="idle"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-idle-0 2000ms step-end infinite forwards; +} +html[data-pet-state="idle"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-idle-1 2000ms step-end infinite forwards; +} + +@keyframes kp-cap-idle-left-0 { + 0% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 50% { translate: calc(84px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-idle-left-1 { + 0% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 50% { translate: calc(84px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +html[data-pet-state="idle-left"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-idle-left-0 2000ms step-end infinite forwards; +} +html[data-pet-state="idle-left"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-idle-left-1 2000ms step-end infinite forwards; +} + +@keyframes kp-cap-jumping-0 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(101px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(99px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(102px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(101px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(107px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(105px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(105px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(106px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(105px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-jumping-1 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(101px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(99px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(102px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(101px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(107px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(105px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(105px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(106px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(105px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +html[data-pet-state="jumping"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-jumping-0 4800ms step-end 1 forwards; +} +html[data-pet-state="jumping"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-jumping-1 4800ms step-end 1 forwards; +} + +@keyframes kp-cap-jumping-left-0 { + 0% { translate: calc(85px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(93px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(91px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(92px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(87px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(87px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(86px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(85px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(87px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(87px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(85px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(85px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(86px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(87px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-jumping-left-1 { + 0% { translate: calc(85px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(93px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(91px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(92px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(87px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(87px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(86px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(85px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(87px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(87px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(85px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(85px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(86px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(87px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +html[data-pet-state="jumping-left"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-jumping-left-0 4800ms step-end 1 forwards; +} +html[data-pet-state="jumping-left"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-jumping-left-1 4800ms step-end 1 forwards; +} + +@keyframes kp-cap-jumping-right-0 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(101px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(99px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(102px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(101px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(107px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(105px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(105px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(106px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(105px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-jumping-right-1 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(101px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(99px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(102px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(101px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(107px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(105px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(105px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(106px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(105px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +html[data-pet-state="jumping-right"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-jumping-right-0 4800ms step-end 1 forwards; +} +html[data-pet-state="jumping-right"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-jumping-right-1 4800ms step-end 1 forwards; +} + +@keyframes kp-cap-panic-0 { + 0% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 5% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 10% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 15% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 20% { translate: calc(91px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 25% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 30% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 35% { translate: calc(111px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 40% { translate: calc(108px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 45% { translate: calc(87px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 55% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 60% { translate: calc(91px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 65% { translate: calc(81px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 70% { translate: calc(84px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 75% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 80% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 85% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 90% { translate: calc(97px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 95% { translate: calc(100px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-panic-1 { + 0% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 5% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 10% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 15% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 20% { translate: calc(91px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 25% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 30% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 35% { translate: calc(111px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 40% { translate: calc(108px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 45% { translate: calc(87px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 55% { translate: calc(112px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 60% { translate: calc(91px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 65% { translate: calc(81px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 70% { translate: calc(84px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 75% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 80% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 85% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 90% { translate: calc(97px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 95% { translate: calc(100px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +html[data-pet-state="panic"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-panic-0 2400ms step-end infinite forwards; +} +html[data-pet-state="panic"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-panic-1 2400ms step-end infinite forwards; +} + +@keyframes kp-cap-review-0 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 4.7619% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 9.5238% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 19.0476% { translate: calc(103px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 23.8095% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 38.0952% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 47.619% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 52.381% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 61.9048% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 76.1905% { translate: calc(98px * var(--pet-scale, 1)) calc(34px * var(--pet-scale, 1)); } + 80.9524% { translate: calc(103px * var(--pet-scale, 1)) calc(39px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(107px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 90.4762% { translate: calc(107px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 95.2381% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-review-1 { + 0% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 4.7619% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 9.5238% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 19.0476% { translate: calc(103px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 23.8095% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 38.0952% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 47.619% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 52.381% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 61.9048% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(100px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(101px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 76.1905% { translate: calc(98px * var(--pet-scale, 1)) calc(34px * var(--pet-scale, 1)); } + 80.9524% { translate: calc(103px * var(--pet-scale, 1)) calc(39px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(107px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 90.4762% { translate: calc(107px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 95.2381% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } +} +html[data-pet-state="review"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-review-0 4200ms step-end infinite forwards; +} +html[data-pet-state="review"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-review-1 4200ms step-end infinite forwards; +} + +@keyframes kp-cap-review-left-0 { + 0% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 4.7619% { translate: calc(84px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 9.5238% { translate: calc(83px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 19.0476% { translate: calc(89px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 23.8095% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 38.0952% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 47.619% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 52.381% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 61.9048% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 76.1905% { translate: calc(95px * var(--pet-scale, 1)) calc(34px * var(--pet-scale, 1)); } + 80.9524% { translate: calc(90px * var(--pet-scale, 1)) calc(39px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(85px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 90.4762% { translate: calc(85px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 95.2381% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-review-left-1 { + 0% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 4.7619% { translate: calc(84px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 9.5238% { translate: calc(83px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 19.0476% { translate: calc(89px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 23.8095% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 38.0952% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 47.619% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 52.381% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 61.9048% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(92px * var(--pet-scale, 1)) calc(31px * var(--pet-scale, 1)); } + 76.1905% { translate: calc(95px * var(--pet-scale, 1)) calc(34px * var(--pet-scale, 1)); } + 80.9524% { translate: calc(90px * var(--pet-scale, 1)) calc(39px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(85px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 90.4762% { translate: calc(85px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } + 95.2381% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } +} +html[data-pet-state="review-left"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-review-left-0 4200ms step-end infinite forwards; +} +html[data-pet-state="review-left"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-review-left-1 4200ms step-end infinite forwards; +} + +@keyframes kp-cap-running-0 { + 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(108px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-running-1 { + 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(108px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +html[data-pet-state="running"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-running-0 1400ms step-end infinite forwards; +} +html[data-pet-state="running"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-running-1 1400ms step-end infinite forwards; +} + +@keyframes kp-cap-running-left-0 { + 0% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(82px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(83px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-running-left-1 { + 0% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(82px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(83px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +html[data-pet-state="running-left"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-running-left-0 1400ms step-end infinite forwards; +} +html[data-pet-state="running-left"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-running-left-1 1400ms step-end infinite forwards; +} + +@keyframes kp-cap-running-right-0 { + 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(108px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-running-right-1 { + 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 50% { translate: calc(108px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +html[data-pet-state="running-right"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-running-right-0 1400ms step-end infinite forwards; +} +html[data-pet-state="running-right"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-running-right-1 1400ms step-end infinite forwards; +} + +@keyframes kp-cap-sleep-0 { + 0% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 10% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 20% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 30% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 40% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 50% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 60% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 70% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 80% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 90% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-sleep-1 { + 0% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 10% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 20% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 30% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 40% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 50% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 60% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 70% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 80% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 90% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } +} +html[data-pet-state="sleep"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-sleep-0 4000ms step-end infinite forwards; +} +html[data-pet-state="sleep"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-sleep-1 4000ms step-end infinite forwards; +} + +@keyframes kp-cap-sleep-enter-0 { + 0% { translate: calc(108px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 12.5% { translate: calc(96px * var(--pet-scale, 1)) calc(57px * var(--pet-scale, 1)); } + 25% { translate: calc(108px * var(--pet-scale, 1)) calc(87px * var(--pet-scale, 1)); } + 37.5% { translate: calc(123px * var(--pet-scale, 1)) calc(112px * var(--pet-scale, 1)); } + 50% { translate: calc(124px * var(--pet-scale, 1)) calc(123px * var(--pet-scale, 1)); } + 62.5% { translate: calc(126px * var(--pet-scale, 1)) calc(123px * var(--pet-scale, 1)); } + 75% { translate: calc(121px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } + 87.5% { translate: calc(120px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-sleep-enter-1 { + 0% { translate: calc(108px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 12.5% { translate: calc(96px * var(--pet-scale, 1)) calc(57px * var(--pet-scale, 1)); } + 25% { translate: calc(108px * var(--pet-scale, 1)) calc(87px * var(--pet-scale, 1)); } + 37.5% { translate: calc(123px * var(--pet-scale, 1)) calc(112px * var(--pet-scale, 1)); } + 50% { translate: calc(124px * var(--pet-scale, 1)) calc(123px * var(--pet-scale, 1)); } + 62.5% { translate: calc(126px * var(--pet-scale, 1)) calc(123px * var(--pet-scale, 1)); } + 75% { translate: calc(121px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } + 87.5% { translate: calc(120px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } +} +html[data-pet-state="sleep-enter"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-sleep-enter-0 3200ms step-end 1 forwards; +} +html[data-pet-state="sleep-enter"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-sleep-enter-1 3200ms step-end 1 forwards; +} + +@keyframes kp-cap-sleep-exit-0 { + 0% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(120px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(119px * var(--pet-scale, 1)) calc(100px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-sleep-exit-1 { + 0% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 14.2857% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 28.5714% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 42.8571% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } + 57.1429% { translate: calc(120px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } + 71.4286% { translate: calc(119px * var(--pet-scale, 1)) calc(100px * var(--pet-scale, 1)); } + 85.7143% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } +} +html[data-pet-state="sleep-exit"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-sleep-exit-0 2800ms step-end 1 forwards; +} +html[data-pet-state="sleep-exit"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-sleep-exit-1 2800ms step-end 1 forwards; +} + +@keyframes kp-cap-stretch-0 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(101px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(99px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(102px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(101px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(107px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(105px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(105px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(106px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(105px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-stretch-1 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 15.7895% { translate: calc(101px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 21.0526% { translate: calc(99px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 26.3158% { translate: calc(102px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } + 31.5789% { translate: calc(101px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 36.8421% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 42.1053% { translate: calc(105px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 47.3684% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } + 52.6316% { translate: calc(107px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 57.8947% { translate: calc(105px * var(--pet-scale, 1)) calc(50px * var(--pet-scale, 1)); } + 63.1579% { translate: calc(105px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } + 68.4211% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 73.6842% { translate: calc(107px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 78.9474% { translate: calc(106px * var(--pet-scale, 1)) calc(51px * var(--pet-scale, 1)); } + 84.2105% { translate: calc(105px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } + 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } + 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } +} +html[data-pet-state="stretch"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-stretch-0 5600ms step-end 1 forwards; +} +html[data-pet-state="stretch"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-stretch-1 5600ms step-end 1 forwards; +} + +@keyframes kp-cap-waving-0 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 5.5556% { translate: calc(108px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 11.1111% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 22.2222% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 27.7778% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 38.8889% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 44.4444% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 50% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 55.5556% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 61.1111% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 72.2222% { translate: calc(108px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 77.7778% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 88.8889% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 94.4444% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +@keyframes kp-cap-waving-1 { + 0% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 5.5556% { translate: calc(108px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 11.1111% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 16.6667% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 22.2222% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 27.7778% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 33.3333% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 38.8889% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 44.4444% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 50% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 55.5556% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 61.1111% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 72.2222% { translate: calc(108px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } + 77.7778% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 83.3333% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } + 88.8889% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } + 94.4444% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } +} +html[data-pet-state="waving"][data-pet-nonce="0"] #claude-cap { + animation: kp-cap-waving-0 2700ms step-end 1 forwards; +} +html[data-pet-state="waving"][data-pet-nonce="1"] #claude-cap { + animation: kp-cap-waving-1 2700ms step-end 1 forwards; +} diff --git a/apps/desktop/src/renderer/pet.ts b/apps/desktop/src/renderer/pet.ts index dd7bed5..59c1a4a 100644 --- a/apps/desktop/src/renderer/pet.ts +++ b/apps/desktop/src/renderer/pet.ts @@ -71,6 +71,11 @@ function applyFrame(frame: PetFrame): void { root.dataset.overlay = frame.overlay root.dataset.claudeState = frame.claudeState + // Also on the root, because the cap is a sibling of #sprite and CSS cannot reach across to + // read an attribute off it. The nonce comes too: the cap restarts with the sprite or it + // drifts out of phase and lands on the wrong head position for the whole loop. + root.dataset.petState = frame.animation + root.dataset.petNonce = String(frame.animationNonce) bubble.dataset.side = frame.bubbleSide quickMenu.dataset.actions = frame.quickActions.join(' ') quickMenu.hidden = frame.quickActions.length === 0 diff --git a/docs/CLAUDE-CODE.md b/docs/CLAUDE-CODE.md index 74c6559..5d77536 100644 --- a/docs/CLAUDE-CODE.md +++ b/docs/CLAUDE-CODE.md @@ -128,9 +128,4 @@ Point Argos at a different file with `ARGOS_CLAUDE_STATE_FILE`. - **One session.** The last hook to fire wins, whichever session it came from. - **Stale state.** A session killed with `Ctrl+C` never fires `SessionEnd`. Its file lingers, and the cap stays until the file is 15 minutes old. -- **The cap drifts sideways in some poses.** It hangs off `--body-cx`, which is the centre of the - character's *bounding box*, not the centre of its head. In `idle` and `running` the two agree - closely enough; in `jumping` the pet leans and the cap is visibly left of the head. The alpha - mask publishes `headTopByState` but no matching head centre, so fixing this properly means - generating one — worth doing before the real cap art lands, pointless before then. - **macOS only, so far.** The Linux shape-region handling is written but unverified. diff --git a/docs/demo/claude-cap-waiting.png b/docs/demo/claude-cap-waiting.png index 7c1f734df70b419c189787ee6b41e149dff83827..bfb4b1b86b74427c702eca34a176e1dc7226590e 100644 GIT binary patch literal 30509 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 oEiael($1f-U5A^0Wvj6}9 literal 54856 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ⅅ0?H#NEci>Su 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 diff --git a/scripts/generate-sprite-css.mjs b/scripts/generate-sprite-css.mjs index bc7567a..1c1a4be 100644 --- a/scripts/generate-sprite-css.mjs +++ b/scripts/generate-sprite-css.mjs @@ -53,7 +53,10 @@ */ import { join } from 'node:path' -import { loadSpritesheet, ROOT } from './lib/spritesheet.mjs' +import { readFileSync } from 'node:fs' +import { loadSpritesheet, ROOT, SPRITESHEET_PNG } from './lib/spritesheet.mjs' +import { headAnchorsByFrame } from './lib/mask.mjs' +import { decodePng } from './lib/png.mjs' import { emitOrCheck, reportResults, cssBanner, tsBanner } from './lib/generated-file.mjs' const CSS_OUT = join(ROOT, 'apps', 'desktop', 'src', 'renderer', 'pet.generated.css') @@ -66,7 +69,58 @@ function keyframesName(state, nonce) { return `kp-${state}-${nonce}` } -function buildCss(sheet, states, holdStrategy) { +/** + * The status cap's keyframes. + * + * The pet's bounce is `background-position` stepping, so the sprite element itself never moves + * and nothing can be made to follow it by parenting. The cap is therefore given its own + * animation, on the same clock, with one stop per frame holding that frame's real head anchor. + * + * `step-end` rather than a two-endpoint ramp: the head tops are not a ramp (jumping runs + * 44,42,42,42,50,...), so interpolating between the first and last would put the cap in the + * wrong place on most frames. One stop per frame, each held until the next, lands it exactly. + * + * Offsets are emitted in unscaled cell space and multiplied by `--pet-scale` here, so the cap + * tracks the head at every pet size without the renderer computing anything. + */ +function buildCapCss(sheet, states, anchors) { + const lines = [] + + for (const state of states) { + const frames = anchors[state.name] + const iterations = state.iterations === 'infinite' ? 'infinite' : String(state.iterations) + + for (const nonce of NONCES) { + lines.push(`@keyframes ${capKeyframesName(state.name, nonce)} {`) + frames.forEach((anchor, index) => { + // Stop i opens the window in which the sprite is showing frame i, matching the + // `steps(n, jump-none)` the sprite runs on. + const pct = ((index / frames.length) * 100).toFixed(4).replace(/\.?0+$/, '') + lines.push( + ` ${pct}% { translate: calc(${anchor.cx}px * var(--pet-scale, 1)) calc(${anchor.top}px * var(--pet-scale, 1)); }`, + ) + }) + lines.push('}') + } + + for (const nonce of NONCES) { + lines.push( + `html[data-pet-state="${state.name}"][data-pet-nonce="${nonce}"] #claude-cap {`, + ` animation: ${capKeyframesName(state.name, nonce)} ${state.durationMs}ms step-end ${iterations} forwards;`, + '}', + ) + } + lines.push('') + } + + return lines +} + +function capKeyframesName(state, nonce) { + return `kp-cap-${state}-${nonce}` +} + +function buildCss(sheet, states, holdStrategy, anchors) { const lines = [cssBanner()] lines.push( @@ -121,6 +175,15 @@ function buildCss(sheet, states, holdStrategy) { lines.push('') } + lines.push( + '/* The status cap rides the same clock as the sprite; see buildCapCss. */', + '#claude-cap {', + ' animation-timing-function: step-end;', + '}', + '', + ...buildCapCss(sheet, states, anchors), + ) + return `${lines.join('\n').trimEnd()}\n` } @@ -230,9 +293,10 @@ function main() { } const { sheet, states, aliases, reactionMap } = loadSpritesheet() + const anchors = headAnchorsByFrame(decodePng(readFileSync(SPRITESHEET_PNG)), sheet, states) const results = [ - emitOrCheck(CSS_OUT, buildCss(sheet, states, holdStrategy), { check }), + emitOrCheck(CSS_OUT, buildCss(sheet, states, holdStrategy, anchors), { check }), emitOrCheck(TS_OUT, buildTs(sheet, states, aliases, reactionMap), { check }), ] diff --git a/scripts/lib/mask.mjs b/scripts/lib/mask.mjs index 2dc4090..3bdcfc7 100644 --- a/scripts/lib/mask.mjs +++ b/scripts/lib/mask.mjs @@ -10,6 +10,14 @@ /** Alpha above this counts as opaque. Low enough to keep antialiased edges, high enough to drop dust. */ export const ALPHA_THRESHOLD = 8 +/** + * Rows below the top of the head used to find its horizontal centre. + * + * Deep enough to span the skull and shallow enough to exclude the shoulders, which on this + * art are much wider and would drag the centre towards the body. + */ +export const HEAD_BAND = 12 + /** Mask resolution. 4px keeps the mask tiny (312 bytes) while staying finer than any limb. */ export const GRANULARITY = 4 @@ -70,6 +78,71 @@ export function buildUnion(png, sheet, states) { return { union, perFrameOpaque, footInsetByState, headTopByState } } +/** + * Per-frame head anchor for every state: where the top of the head is, and where it is centred. + * + * This is the deliberate opposite of `headTopByState`. That one collapses a state's frames to + * their minimum so the speech bubble does not jitter with the pet's breathing — correct for a + * bubble, wrong for anything worn *on* the head. The pet's bounce is entirely + * `background-position` stepping, so the sprite element never moves and a hat pinned to a + * per-state constant floats while the character bobs underneath it. + * + * `cx` is the centre of the head specifically, not of the whole body: measured across the top + * `HEAD_BAND` rows of the frame, because the body's bounding-box centre barely moves while the + * head swings several pixels in a leaning pose. + * + * @param {{width:number,height:number,data:Uint8Array}} png + * @param {{frameWidth:number,frameHeight:number}} sheet + * @param {Array<{row:number,frames:number,name:string,startColumn?:number}>} states + * @returns {Record>} + */ +export function headAnchorsByFrame(png, sheet, states) { + const { frameWidth: fw, frameHeight: fh } = sheet + const alpha = (x, y) => { + if (x < 0 || y < 0 || x >= png.width || y >= png.height) return 0 + return png.data[(y * png.width + x) * 4 + 3] + } + + const out = {} + for (const state of states) { + const frames = [] + for (let frame = 0; frame < state.frames; frame += 1) { + const originX = ((state.startColumn ?? 0) + frame) * fw + const originY = state.row * fh + + let top = fh + for (let y = 0; y < fh && top === fh; y += 1) { + for (let x = 0; x < fw; x += 1) { + if (alpha(originX + x, originY + y) > ALPHA_THRESHOLD) { + top = y + break + } + } + } + + // A fully transparent cell (art in progress, or a short row) has no head to anchor to. + // Fall back to the cell centre rather than emitting NaN into a stylesheet. + if (top === fh) { + frames.push({ top: 0, cx: Math.round(fw / 2) }) + continue + } + + let minX = fw + let maxX = -1 + for (let y = top; y < Math.min(fh, top + HEAD_BAND); y += 1) { + for (let x = 0; x < fw; x += 1) { + if (alpha(originX + x, originY + y) <= ALPHA_THRESHOLD) continue + if (x < minX) minX = x + if (x > maxX) maxX = x + } + } + frames.push({ top, cx: Math.round((minX + maxX) / 2) }) + } + out[state.name] = frames + } + return out +} + /** Tight bounding box of the set pixels. */ export function boundingBox(union, width, height) { let minX = width diff --git a/tests/renderer/discipline.spec.ts b/tests/renderer/discipline.spec.ts index 4ceddd5..0cae107 100644 --- a/tests/renderer/discipline.spec.ts +++ b/tests/renderer/discipline.spec.ts @@ -137,7 +137,7 @@ describe('hand-written CSS carries no generated geometry', () => { expect(css).toMatch(/var\(--body-top/) }) - it('anchors the status cap to the character through the same custom properties', () => { + it('paints the status cap from state the renderer publishes', () => { // Two halves in two files again: the renderer publishes the state, the CSS paints it. Either // half being dropped leaves a cap that is silently never shown, which looks exactly like // "Claude is not running" and so would not be noticed. @@ -149,8 +149,26 @@ describe('hand-written CSS carries no generated geometry', () => { expect(css).toMatch(/\[data-claude-state='waiting'\]/) expect(css).toMatch(/\[data-claude-state='running'\]/) expect(css).toMatch(/\[data-claude-state='idle'\]/) - // The cap tracks the head, not the window corner. - expect(css).toMatch(/#claude-cap[\s\S]*?var\(--body-cx/) + }) + + it('leaves the cap\'s per-frame geometry to the generator', () => { + // The cap has to bob with the pet, and the pet's bounce is background-position stepping -- + // the sprite element never moves. So the cap cannot hang off --body-top, which is a + // per-state constant chosen precisely so the speech bubble does NOT bob. It rides generated + // per-frame keyframes instead, and the hand-written rule may only park it on the cell. + const css = read(join(RENDERER_DIR, 'pet.css')) + const rule = css.slice(css.indexOf('#claude-cap {')) + const decl = rule.slice(0, rule.indexOf('}')) + expect(decl, 'cap is pinned to the non-bobbing bubble anchor').not.toMatch(/var\(--body-top/) + expect(decl).toMatch(/var\(--sprite-x/) + expect(decl).toMatch(/var\(--sprite-y/) + + // The renderer must publish the sprite's state and nonce on the root: the cap is a sibling + // of #sprite, so CSS cannot read them off it, and without the nonce the cap does not restart + // with the sprite and drifts a frame out of phase for the whole loop. + const pet = read(join(RENDERER_DIR, 'pet.ts')) + expect(pet).toContain('petState') + expect(pet).toContain('petNonce') }) it('scales the sprite by transform, and publishes the scale', () => { diff --git a/tests/sprite/cap-anchor.spec.ts b/tests/sprite/cap-anchor.spec.ts new file mode 100644 index 0000000..0314607 --- /dev/null +++ b/tests/sprite/cap-anchor.spec.ts @@ -0,0 +1,103 @@ +import { describe, it, expect } from 'vitest' +import { readFileSync } from 'node:fs' +import { resolve } from 'node:path' +// @ts-expect-error — untyped .mjs helpers shared with the generators +import { loadSpritesheet } from '../../scripts/lib/spritesheet.mjs' +// @ts-expect-error — untyped .mjs helpers shared with the generators +import { headAnchorsByFrame } from '../../scripts/lib/mask.mjs' +// @ts-expect-error — untyped .mjs helpers shared with the generators +import { decodePng } from '../../scripts/lib/png.mjs' + +const REPO = resolve(import.meta.dirname, '..', '..') +const CSS = readFileSync(resolve(REPO, 'apps/desktop/src/renderer/pet.generated.css'), 'utf8') + +/** + * The status cap has to bob with the pet. + * + * The pet's bounce is entirely `background-position` stepping — the sprite element never moves — + * so anything anchored to a per-state constant stays put while the character bobs underneath it. + * `headTopByState` is deliberately such a constant (it is the minimum across the state's frames, + * so the speech bubble does not jitter with the pet's breathing), which makes it exactly the + * wrong anchor for a hat. + */ +describe('per-frame head anchors', () => { + const { sheet, states } = loadSpritesheet() as { + sheet: { frameWidth: number; frameHeight: number } + states: Array<{ name: string; row: number; frames: number; startColumn?: number }> + } + const png = decodePng(readFileSync(resolve(REPO, 'pet/spritesheet.png'))) + const anchors = headAnchorsByFrame(png, sheet, states) as Record< + string, + Array<{ top: number; cx: number }> + > + + it('produces one anchor per frame of every state', () => { + for (const state of states) { + expect(anchors[state.name], state.name).toHaveLength(state.frames) + } + }) + + it('sees the idle bob the bubble is deliberately blind to', () => { + // Measured from the art: idle's two frames sit 7px apart vertically. A cap pinned to the + // per-state minimum floats a gap wider than half its own height on the second frame, which + // is the bug this exists to prevent regressing. + const tops = anchors['idle'].map((a) => a.top) + expect(Math.max(...tops) - Math.min(...tops)).toBeGreaterThanOrEqual(5) + }) + + it('tracks the head sideways too, which a body-bbox centre cannot', () => { + // jumping leans: the head centre swings while the body's bounding box barely moves. + const cxs = anchors['jumping'].map((a) => a.cx) + expect(Math.max(...cxs) - Math.min(...cxs)).toBeGreaterThanOrEqual(5) + }) + + it('keeps every anchor inside the cell', () => { + for (const [name, frames] of Object.entries(anchors)) { + for (const { top, cx } of frames) { + expect(top, `${name} top`).toBeGreaterThanOrEqual(0) + expect(top, `${name} top`).toBeLessThan(sheet.frameHeight) + expect(cx, `${name} cx`).toBeGreaterThanOrEqual(0) + expect(cx, `${name} cx`).toBeLessThan(sheet.frameWidth) + } + } + }) +}) + +describe('generated cap keyframes', () => { + const { states } = loadSpritesheet() as { + states: Array<{ name: string; frames: number; durationMs: number; iterations?: unknown }> + } + + it('emits a cap keyframe rule per state per nonce', () => { + for (const state of states) { + for (const nonce of [0, 1]) { + expect(CSS, `${state.name}/${nonce}`).toContain(`@keyframes kp-cap-${state.name}-${nonce}`) + } + } + }) + + it('gives multi-frame states one stop per frame', () => { + // One stop per frame is what makes the cap land on the real head position rather than on a + // linear interpolation between the first and last — the head tops are not a ramp. + const block = CSS.slice(CSS.indexOf('@keyframes kp-cap-jumping-0')) + const body = block.slice(0, block.indexOf('}\n@') + 1) + const stops = body.match(/^\s+[\d.]+% \{/gm) ?? [] + const jumping = states.find((s) => s.name === 'jumping')! + expect(stops).toHaveLength(jumping.frames) + }) + + it('steps rather than interpolates, and scales with the pet', () => { + expect(CSS).toMatch(/#claude-cap[\s\S]*?animation-timing-function:\s*step-end/) + expect(CSS).toMatch(/@keyframes kp-cap-idle-0[\s\S]*?var\(--pet-scale/) + }) + + it('runs the cap on the same clock as the sprite', () => { + // Out of phase by even one frame and the cap lands on the wrong head position all the way + // through the loop. Same duration, same iteration count, restarted by the same nonce flip. + for (const state of states) { + const rule = CSS.slice(CSS.indexOf(`[data-pet-state="${state.name}"][data-pet-nonce="0"] #claude-cap`)) + const decl = rule.slice(0, rule.indexOf('}')) + expect(decl, state.name).toContain(`${state.durationMs}ms`) + } + }) +}) From bc899443bca30c946d6648823a84184e6cf31029 Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 10:59:14 +0530 Subject: [PATCH 09/12] feat: wear a pixel crown instead of a coloured square Red, gold and green crowns for waiting, running and idle, floating just above the head rather than seated on it. The art is generated, not hand-placed. pet/crowns-source/ holds the full-size PNGs and `pnpm generate` box-downsamples them to the 28x22 they are worn at. Resampling once here rather than letting CSS shrink the big PNG matters: the browser would otherwise resample by a non-integer factor against image-rendering: pixelated, and the result is mush at exactly the sizes the pet is usually shown at. The filter averages premultiplied alpha. Averaging straight RGBA pulls the transparent pixels' colour into the edges, which on this art is black, and the crown comes out with a dark fringe all the way round. Size, art and the 4px gap live in scripts/lib/crowns.mjs and reach the stylesheet through the generator, so pet.css carries no crown geometry -- only the cell anchoring, which is the one thing that file knows about. The per-frame head-tracking from the previous commit is unchanged, so the crown still bobs with the pet. Renamed cap -> crown throughout, the earlier name having become wrong. Also teaches the smoke harness about it. A crown floats in the ring A2 requires to be transparent, so A2 was failing on an assertion it is not the subject of -- it asks whether the *window* is see-through, and the crown is app-painted content. Main now reports crownVisible and A2 skips with a printed reason when one is worn. Skipped rather than narrowed because the crown's exact band is per animation frame and lives in the generated stylesheet, so main cannot report a bound worth trusting. Ordinary runs still check the full ring. Co-Authored-By: Claude Opus 5 (1M context) --- apps/desktop/src/main/app-shell.ts | 1 + apps/desktop/src/main/harness-control.ts | 6 + apps/desktop/src/main/harness-handshake.ts | 9 + apps/desktop/src/main/pet-window.ts | 14 + apps/desktop/src/renderer/pet.css | 47 +--- apps/desktop/src/renderer/pet.generated.css | 254 ++++++++++-------- apps/desktop/src/renderer/pet.html | 4 +- docs/CLAUDE-CODE.md | 32 ++- docs/demo/claude-cap-waiting.png | Bin 30509 -> 0 bytes docs/demo/crown-idle.png | Bin 0 -> 31475 bytes docs/demo/crown-running.png | Bin 0 -> 31195 bytes docs/demo/crown-waiting.png | Bin 0 -> 31396 bytes .../plans/2026-09-04-claude-state-cap.md | 14 +- .../2026-09-04-claude-state-cap-design.md | 4 +- package.json | 4 +- pet/crown-idle.png | Bin 0 -> 1339 bytes pet/crown-running.png | Bin 0 -> 971 bytes pet/crown-waiting.png | Bin 0 -> 1173 bytes pet/crowns-source/idle.png | Bin 0 -> 91291 bytes pet/crowns-source/running.png | Bin 0 -> 32840 bytes pet/crowns-source/waiting.png | Bin 0 -> 90981 bytes scripts/copy-static.mjs | 8 +- scripts/generate-crowns.mjs | 127 +++++++++ scripts/generate-sprite-css.mjs | 37 ++- scripts/lib/crowns.mjs | 33 +++ scripts/smoke.mjs | 53 ++-- tests/renderer/discipline.spec.ts | 31 ++- ...ap-anchor.spec.ts => crown-anchor.spec.ts} | 20 +- 28 files changed, 465 insertions(+), 233 deletions(-) delete mode 100644 docs/demo/claude-cap-waiting.png create mode 100644 docs/demo/crown-idle.png create mode 100644 docs/demo/crown-running.png create mode 100644 docs/demo/crown-waiting.png create mode 100644 pet/crown-idle.png create mode 100644 pet/crown-running.png create mode 100644 pet/crown-waiting.png create mode 100644 pet/crowns-source/idle.png create mode 100644 pet/crowns-source/running.png create mode 100644 pet/crowns-source/waiting.png create mode 100644 scripts/generate-crowns.mjs create mode 100644 scripts/lib/crowns.mjs rename tests/sprite/{cap-anchor.spec.ts => crown-anchor.spec.ts} (85%) diff --git a/apps/desktop/src/main/app-shell.ts b/apps/desktop/src/main/app-shell.ts index 07bcde9..4a08b4c 100644 --- a/apps/desktop/src/main/app-shell.ts +++ b/apps/desktop/src/main/app-shell.ts @@ -928,6 +928,7 @@ export async function startApp(): Promise { backdrop: () => backdrop, spriteRect: () => pet.spriteRect(), bubbleBand: () => pet.bubbleBand(), + crownVisible: () => pet.crownVisible(), setMovement: (enabled) => { // The same three steps `toggleMovement` takes — durable setting, immediate trigger, out-of-phase // tick — so freezing the pet for a screenshot goes through the real path rather than a back door diff --git a/apps/desktop/src/main/harness-control.ts b/apps/desktop/src/main/harness-control.ts index 7df2ac9..e827164 100644 --- a/apps/desktop/src/main/harness-control.ts +++ b/apps/desktop/src/main/harness-control.ts @@ -85,6 +85,8 @@ export interface HarnessTargets { /** The line the speech bubble cannot cross, and which side of the pet it is on. See * PetWindow.bubbleBand. */ bubbleBand?: () => { y: number; side: 'above' | 'below'; visible: boolean } + /** Whether the pet is wearing a status crown. See PetWindow.crownVisible. */ + crownVisible?: () => boolean /** Whether the pet is floor-locked, so the harness knows if feet-on-floor is assertable. */ floorLocked?: () => boolean /** Place the pet at an absolute position, as a drop would. */ @@ -125,6 +127,7 @@ export function installHarnessControl(targets: HarnessTargets): () => void { const isPet = command.window === 'pet' const rect = isPet ? targets.spriteRect?.() : undefined const bubble = isPet ? targets.bubbleBand?.() : undefined + const crownVisible = isPet ? targets.crownVisible?.() : undefined const floorLocked = isPet ? targets.floorLocked?.() : undefined const petScale = isPet ? targets.petScale?.() : undefined emit({ @@ -138,6 +141,7 @@ export function installHarnessControl(targets: HarnessTargets): () => void { ...(bubble === undefined ? {} : { bubbleEdgeY: bubble.y, bubbleSide: bubble.side, bubbleVisible: bubble.visible }), + ...(crownVisible === undefined ? {} : { crownVisible }), ...(floorLocked === undefined ? {} : { floorLocked }), ...(petScale === undefined ? {} : { petScale }), }) @@ -209,6 +213,7 @@ export function installHarnessControl(targets: HarnessTargets): () => void { return } const bubble = targets.bubbleBand?.() + const crownVisible = targets.crownVisible?.() emit({ ev: 'geometry', bounds: win.getContentBounds(), @@ -218,6 +223,7 @@ export function installHarnessControl(targets: HarnessTargets): () => void { ...(bubble === undefined ? {} : { bubbleEdgeY: bubble.y, bubbleSide: bubble.side, bubbleVisible: bubble.visible }), + ...(crownVisible === undefined ? {} : { crownVisible }), }) return } diff --git a/apps/desktop/src/main/harness-handshake.ts b/apps/desktop/src/main/harness-handshake.ts index efb10a5..bbb0586 100644 --- a/apps/desktop/src/main/harness-handshake.ts +++ b/apps/desktop/src/main/harness-handshake.ts @@ -66,6 +66,14 @@ export type HandshakeEvent = bubbleSide?: 'above' | 'below' /** Whether a bubble was actually on screen for this capture. Pet window only. */ bubbleVisible?: boolean + /** + * Whether the pet was wearing a status crown for this capture. Pet window only. + * + * The crown floats above the head, so it paints in the ring A2 requires to be + * transparent. A2 is about the *window* being see-through; app-painted content there is + * not the bug it is looking for. + */ + crownVisible?: boolean /** * Whether the pet is sitting on the floor. False means it has been freely placed, in which * case asserting feet-on-floor would fail on correct behaviour. @@ -91,6 +99,7 @@ export type HandshakeEvent = bubbleEdgeY?: number bubbleSide?: 'above' | 'below' bubbleVisible?: boolean + crownVisible?: boolean } | { ev: 'error'; where: string; message: string } diff --git a/apps/desktop/src/main/pet-window.ts b/apps/desktop/src/main/pet-window.ts index c34d03c..34e7371 100644 --- a/apps/desktop/src/main/pet-window.ts +++ b/apps/desktop/src/main/pet-window.ts @@ -72,6 +72,13 @@ export interface PetWindow { * assertion would then measure the bubble and report a transparency failure. */ bubbleBand(): { y: number; side: BubbleSide; visible: boolean } + /** + * Whether a status crown is on the pet's head right now. + * + * The harness needs it because the crown legitimately paints outside the character, in the + * ring A2 otherwise requires to be fully transparent. + */ + crownVisible(): boolean /** * Change the pet's size. * @@ -191,6 +198,8 @@ export async function createPetWindow(options: { let lastOverlayVisible = false /** Whether the hover quick-action menu is up. Drives the shape region on Linux. */ let lastQuickMenuVisible = false + /** The crown on the last frame, for the harness. 'none' means bare-headed. */ + let lastClaudeState: PetFrame['claudeState'] = 'none' /** * The Linux input-and-drawing region for what is currently on screen. @@ -340,6 +349,7 @@ export async function createPetWindow(options: { lastAnimation = parsed.data.animation lastBubbleVisible = parsed.data.bubble !== null lastOverlayVisible = frameNeedsCellRegion(parsed.data) + lastClaudeState = parsed.data.claudeState lastQuickMenuVisible = parsed.data.quickActions.length > 0 win.webContents.send(IPC.frame, parsed.data) forwarding.setForceInteractive( @@ -373,6 +383,10 @@ export async function createPetWindow(options: { return spriteScreenRect(ALPHA_MASK, bounds, placement.spriteOrigin, placement.scale) as Rectangle }, + crownVisible(): boolean { + return lastClaudeState !== 'none' + }, + bubbleBand(): { y: number; side: BubbleSide; visible: boolean } { const bounds = win.isDestroyed() ? { x, y } : win.getBounds() const band = bubbleBandRect( diff --git a/apps/desktop/src/renderer/pet.css b/apps/desktop/src/renderer/pet.css index a7e0ff5..28cf04c 100644 --- a/apps/desktop/src/renderer/pet.css +++ b/apps/desktop/src/renderer/pet.css @@ -464,49 +464,22 @@ html[data-overlay='sleep-z'] #zzz { } /* - Claude Code status cap. + Claude Code status crown. - A plain square standing in for cap art, positioned exactly where the art will go so the - anchoring proven here is the anchoring the art inherits. + Placement is split in three, and each part lives where its facts live. Here: the crown is + parked on the sprite cell's corner, because only this file knows the cell exists. In + `pet.generated.css`: its size, its art and the gap above the head, because those come out of + `scripts/lib/crowns.mjs` and the art itself. Also generated: one keyframe stop per animation + frame, holding that frame's real head anchor. - Placement is split in two: this rule sizes the cap and parks it on the sprite cell's corner, - and `pet.generated.css` animates the `translate` property through one stop per animation frame, - holding each frame's real head anchor. That split is why the geometry stays generated — the - per-frame head positions come out of the art, and nothing here hardcodes one. + Anchoring to --body-top instead would pin the crown to a per-state constant, and the pet's + bounce is background-position stepping -- the sprite element never moves, so the crown would + hang in the air while the character bobs underneath it. */ -#claude-cap { +#claude-crown { position: absolute; - /* The cell's corner is the origin; the generated per-frame keyframes translate from here. - Anchoring to --body-top instead would pin the cap to a per-state constant, and the pet's - bounce is background-position stepping — the sprite element never moves, so the cap would - hang in the air while the character bobs underneath it. */ left: var(--sprite-x, 0px); top: var(--sprite-y, 0px); - width: calc(26px * var(--pet-scale, 1)); - height: calc(13px * var(--pet-scale, 1)); - /* Composes with the `translate` property the keyframes animate: that puts the anchor on the - head, this centres the cap on it and drops it far enough to sit on the hair. */ - transform: translate(-50%, -20%); display: none; pointer-events: none; - border-radius: 3px; - /* A dark keyline so the square reads against light wallpaper as well as dark. */ - box-shadow: - 0 0 0 1px rgba(0, 0, 0, 0.5), - 0 1px 3px rgba(0, 0, 0, 0.35); -} - -html[data-claude-state='waiting'] #claude-cap { - display: block; - background: #e5484d; -} - -html[data-claude-state='running'] #claude-cap { - display: block; - background: #f5a524; -} - -html[data-claude-state='idle'] #claude-cap { - display: block; - background: #30a46c; } diff --git a/apps/desktop/src/renderer/pet.generated.css b/apps/desktop/src/renderer/pet.generated.css index 02dfdac..4458fc1 100644 --- a/apps/desktop/src/renderer/pet.generated.css +++ b/apps/desktop/src/renderer/pet.generated.css @@ -300,12 +300,34 @@ animation: kp-waving-1 2700ms steps(18, jump-none) 1 forwards; } -/* The status cap rides the same clock as the sprite; see buildCapCss. */ -#claude-cap { +/* The status crown. Size, art and clock are all generated; see buildCrownCss. */ +#claude-crown { + width: calc(28px * var(--pet-scale, 1)); + height: calc(22px * var(--pet-scale, 1)); + background-repeat: no-repeat; + background-size: 100% 100%; + /* Same reason as the sprite: without it the browser smooths the pixel art into mush. */ + image-rendering: pixelated; + /* Composes with the `translate` the keyframes animate. That puts the anchor on the head; + this centres the crown on it and lifts it clear by 4px of daylight. */ + transform: translate(-50%, calc(-100% - 4px * var(--pet-scale, 1))); animation-timing-function: step-end; } -@keyframes kp-cap-drink-0 { +html[data-claude-state="waiting"] #claude-crown { + display: block; + background-image: url('./crown-waiting.png'); +} +html[data-claude-state="running"] #claude-crown { + display: block; + background-image: url('./crown-running.png'); +} +html[data-claude-state="idle"] #claude-crown { + display: block; + background-image: url('./crown-idle.png'); +} + +@keyframes kp-crown-drink-0 { 0% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 9.0909% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 18.1818% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } @@ -318,7 +340,7 @@ 81.8182% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 90.9091% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -@keyframes kp-cap-drink-1 { +@keyframes kp-crown-drink-1 { 0% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 9.0909% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 18.1818% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } @@ -331,14 +353,14 @@ 81.8182% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 90.9091% { translate: calc(104px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -html[data-pet-state="drink"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-drink-0 2200ms step-end 2 forwards; +html[data-pet-state="drink"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-drink-0 2200ms step-end 2 forwards; } -html[data-pet-state="drink"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-drink-1 2200ms step-end 2 forwards; +html[data-pet-state="drink"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-drink-1 2200ms step-end 2 forwards; } -@keyframes kp-cap-electrocute-0 { +@keyframes kp-crown-electrocute-0 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 4.7619% { translate: calc(98px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } 9.5238% { translate: calc(85px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } @@ -361,7 +383,7 @@ html[data-pet-state="drink"][data-pet-nonce="1"] #claude-cap { 90.4762% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 95.2381% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } } -@keyframes kp-cap-electrocute-1 { +@keyframes kp-crown-electrocute-1 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 4.7619% { translate: calc(98px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } 9.5238% { translate: calc(85px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } @@ -384,59 +406,59 @@ html[data-pet-state="drink"][data-pet-nonce="1"] #claude-cap { 90.4762% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 95.2381% { translate: calc(110px * var(--pet-scale, 1)) calc(48px * var(--pet-scale, 1)); } } -html[data-pet-state="electrocute"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-electrocute-0 2100ms step-end 1 forwards; +html[data-pet-state="electrocute"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-electrocute-0 2100ms step-end 1 forwards; } -html[data-pet-state="electrocute"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-electrocute-1 2100ms step-end 1 forwards; +html[data-pet-state="electrocute"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-electrocute-1 2100ms step-end 1 forwards; } -@keyframes kp-cap-failed-0 { +@keyframes kp-crown-failed-0 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -@keyframes kp-cap-failed-1 { +@keyframes kp-crown-failed-1 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -html[data-pet-state="failed"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-failed-0 1220ms step-end 2 forwards; +html[data-pet-state="failed"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-failed-0 1220ms step-end 2 forwards; } -html[data-pet-state="failed"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-failed-1 1220ms step-end 2 forwards; +html[data-pet-state="failed"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-failed-1 1220ms step-end 2 forwards; } -@keyframes kp-cap-idle-0 { +@keyframes kp-crown-idle-0 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -@keyframes kp-cap-idle-1 { +@keyframes kp-crown-idle-1 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 50% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -html[data-pet-state="idle"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-idle-0 2000ms step-end infinite forwards; +html[data-pet-state="idle"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-idle-0 2000ms step-end infinite forwards; } -html[data-pet-state="idle"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-idle-1 2000ms step-end infinite forwards; +html[data-pet-state="idle"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-idle-1 2000ms step-end infinite forwards; } -@keyframes kp-cap-idle-left-0 { +@keyframes kp-crown-idle-left-0 { 0% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 50% { translate: calc(84px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -@keyframes kp-cap-idle-left-1 { +@keyframes kp-crown-idle-left-1 { 0% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 50% { translate: calc(84px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -html[data-pet-state="idle-left"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-idle-left-0 2000ms step-end infinite forwards; +html[data-pet-state="idle-left"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-idle-left-0 2000ms step-end infinite forwards; } -html[data-pet-state="idle-left"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-idle-left-1 2000ms step-end infinite forwards; +html[data-pet-state="idle-left"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-idle-left-1 2000ms step-end infinite forwards; } -@keyframes kp-cap-jumping-0 { +@keyframes kp-crown-jumping-0 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -457,7 +479,7 @@ html[data-pet-state="idle-left"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -@keyframes kp-cap-jumping-1 { +@keyframes kp-crown-jumping-1 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -478,14 +500,14 @@ html[data-pet-state="idle-left"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -html[data-pet-state="jumping"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-jumping-0 4800ms step-end 1 forwards; +html[data-pet-state="jumping"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-jumping-0 4800ms step-end 1 forwards; } -html[data-pet-state="jumping"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-jumping-1 4800ms step-end 1 forwards; +html[data-pet-state="jumping"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-jumping-1 4800ms step-end 1 forwards; } -@keyframes kp-cap-jumping-left-0 { +@keyframes kp-crown-jumping-left-0 { 0% { translate: calc(85px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -506,7 +528,7 @@ html[data-pet-state="jumping"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -@keyframes kp-cap-jumping-left-1 { +@keyframes kp-crown-jumping-left-1 { 0% { translate: calc(85px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(92px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -527,14 +549,14 @@ html[data-pet-state="jumping"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(86px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -html[data-pet-state="jumping-left"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-jumping-left-0 4800ms step-end 1 forwards; +html[data-pet-state="jumping-left"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-jumping-left-0 4800ms step-end 1 forwards; } -html[data-pet-state="jumping-left"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-jumping-left-1 4800ms step-end 1 forwards; +html[data-pet-state="jumping-left"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-jumping-left-1 4800ms step-end 1 forwards; } -@keyframes kp-cap-jumping-right-0 { +@keyframes kp-crown-jumping-right-0 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -555,7 +577,7 @@ html[data-pet-state="jumping-left"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -@keyframes kp-cap-jumping-right-1 { +@keyframes kp-crown-jumping-right-1 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -576,14 +598,14 @@ html[data-pet-state="jumping-left"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -html[data-pet-state="jumping-right"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-jumping-right-0 4800ms step-end 1 forwards; +html[data-pet-state="jumping-right"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-jumping-right-0 4800ms step-end 1 forwards; } -html[data-pet-state="jumping-right"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-jumping-right-1 4800ms step-end 1 forwards; +html[data-pet-state="jumping-right"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-jumping-right-1 4800ms step-end 1 forwards; } -@keyframes kp-cap-panic-0 { +@keyframes kp-crown-panic-0 { 0% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } 5% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } 10% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } @@ -605,7 +627,7 @@ html[data-pet-state="jumping-right"][data-pet-nonce="1"] #claude-cap { 90% { translate: calc(97px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } 95% { translate: calc(100px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -@keyframes kp-cap-panic-1 { +@keyframes kp-crown-panic-1 { 0% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } 5% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } 10% { translate: calc(97px * var(--pet-scale, 1)) calc(47px * var(--pet-scale, 1)); } @@ -627,14 +649,14 @@ html[data-pet-state="jumping-right"][data-pet-nonce="1"] #claude-cap { 90% { translate: calc(97px * var(--pet-scale, 1)) calc(46px * var(--pet-scale, 1)); } 95% { translate: calc(100px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -html[data-pet-state="panic"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-panic-0 2400ms step-end infinite forwards; +html[data-pet-state="panic"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-panic-0 2400ms step-end infinite forwards; } -html[data-pet-state="panic"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-panic-1 2400ms step-end infinite forwards; +html[data-pet-state="panic"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-panic-1 2400ms step-end infinite forwards; } -@keyframes kp-cap-review-0 { +@keyframes kp-crown-review-0 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 4.7619% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 9.5238% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } @@ -657,7 +679,7 @@ html[data-pet-state="panic"][data-pet-nonce="1"] #claude-cap { 90.4762% { translate: calc(107px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 95.2381% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } } -@keyframes kp-cap-review-1 { +@keyframes kp-crown-review-1 { 0% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 4.7619% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 9.5238% { translate: calc(109px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } @@ -680,14 +702,14 @@ html[data-pet-state="panic"][data-pet-nonce="1"] #claude-cap { 90.4762% { translate: calc(107px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 95.2381% { translate: calc(106px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } } -html[data-pet-state="review"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-review-0 4200ms step-end infinite forwards; +html[data-pet-state="review"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-review-0 4200ms step-end infinite forwards; } -html[data-pet-state="review"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-review-1 4200ms step-end infinite forwards; +html[data-pet-state="review"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-review-1 4200ms step-end infinite forwards; } -@keyframes kp-cap-review-left-0 { +@keyframes kp-crown-review-left-0 { 0% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 4.7619% { translate: calc(84px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 9.5238% { translate: calc(83px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } @@ -710,7 +732,7 @@ html[data-pet-state="review"][data-pet-nonce="1"] #claude-cap { 90.4762% { translate: calc(85px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 95.2381% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } } -@keyframes kp-cap-review-left-1 { +@keyframes kp-crown-review-left-1 { 0% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 4.7619% { translate: calc(84px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 9.5238% { translate: calc(83px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } @@ -733,14 +755,14 @@ html[data-pet-state="review"][data-pet-nonce="1"] #claude-cap { 90.4762% { translate: calc(85px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } 95.2381% { translate: calc(86px * var(--pet-scale, 1)) calc(41px * var(--pet-scale, 1)); } } -html[data-pet-state="review-left"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-review-left-0 4200ms step-end infinite forwards; +html[data-pet-state="review-left"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-review-left-0 4200ms step-end infinite forwards; } -html[data-pet-state="review-left"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-review-left-1 4200ms step-end infinite forwards; +html[data-pet-state="review-left"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-review-left-1 4200ms step-end infinite forwards; } -@keyframes kp-cap-running-0 { +@keyframes kp-crown-running-0 { 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } @@ -748,7 +770,7 @@ html[data-pet-state="review-left"][data-pet-nonce="1"] #claude-cap { 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -@keyframes kp-cap-running-1 { +@keyframes kp-crown-running-1 { 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } @@ -756,14 +778,14 @@ html[data-pet-state="review-left"][data-pet-nonce="1"] #claude-cap { 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -html[data-pet-state="running"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-running-0 1400ms step-end infinite forwards; +html[data-pet-state="running"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-running-0 1400ms step-end infinite forwards; } -html[data-pet-state="running"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-running-1 1400ms step-end infinite forwards; +html[data-pet-state="running"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-running-1 1400ms step-end infinite forwards; } -@keyframes kp-cap-running-left-0 { +@keyframes kp-crown-running-left-0 { 0% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 16.6667% { translate: calc(82px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 33.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } @@ -771,7 +793,7 @@ html[data-pet-state="running"][data-pet-nonce="1"] #claude-cap { 66.6667% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 83.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -@keyframes kp-cap-running-left-1 { +@keyframes kp-crown-running-left-1 { 0% { translate: calc(82px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 16.6667% { translate: calc(82px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 33.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } @@ -779,14 +801,14 @@ html[data-pet-state="running"][data-pet-nonce="1"] #claude-cap { 66.6667% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 83.3333% { translate: calc(83px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -html[data-pet-state="running-left"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-running-left-0 1400ms step-end infinite forwards; +html[data-pet-state="running-left"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-running-left-0 1400ms step-end infinite forwards; } -html[data-pet-state="running-left"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-running-left-1 1400ms step-end infinite forwards; +html[data-pet-state="running-left"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-running-left-1 1400ms step-end infinite forwards; } -@keyframes kp-cap-running-right-0 { +@keyframes kp-crown-running-right-0 { 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } @@ -794,7 +816,7 @@ html[data-pet-state="running-left"][data-pet-nonce="1"] #claude-cap { 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -@keyframes kp-cap-running-right-1 { +@keyframes kp-crown-running-right-1 { 0% { translate: calc(109px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 16.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(45px * var(--pet-scale, 1)); } 33.3333% { translate: calc(109px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } @@ -802,14 +824,14 @@ html[data-pet-state="running-left"][data-pet-nonce="1"] #claude-cap { 66.6667% { translate: calc(109px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 83.3333% { translate: calc(108px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -html[data-pet-state="running-right"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-running-right-0 1400ms step-end infinite forwards; +html[data-pet-state="running-right"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-running-right-0 1400ms step-end infinite forwards; } -html[data-pet-state="running-right"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-running-right-1 1400ms step-end infinite forwards; +html[data-pet-state="running-right"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-running-right-1 1400ms step-end infinite forwards; } -@keyframes kp-cap-sleep-0 { +@keyframes kp-crown-sleep-0 { 0% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } 10% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } 20% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } @@ -821,7 +843,7 @@ html[data-pet-state="running-right"][data-pet-nonce="1"] #claude-cap { 80% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } 90% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } } -@keyframes kp-cap-sleep-1 { +@keyframes kp-crown-sleep-1 { 0% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } 10% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } 20% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } @@ -833,14 +855,14 @@ html[data-pet-state="running-right"][data-pet-nonce="1"] #claude-cap { 80% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } 90% { translate: calc(121px * var(--pet-scale, 1)) calc(128px * var(--pet-scale, 1)); } } -html[data-pet-state="sleep"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-sleep-0 4000ms step-end infinite forwards; +html[data-pet-state="sleep"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-sleep-0 4000ms step-end infinite forwards; } -html[data-pet-state="sleep"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-sleep-1 4000ms step-end infinite forwards; +html[data-pet-state="sleep"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-sleep-1 4000ms step-end infinite forwards; } -@keyframes kp-cap-sleep-enter-0 { +@keyframes kp-crown-sleep-enter-0 { 0% { translate: calc(108px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } 12.5% { translate: calc(96px * var(--pet-scale, 1)) calc(57px * var(--pet-scale, 1)); } 25% { translate: calc(108px * var(--pet-scale, 1)) calc(87px * var(--pet-scale, 1)); } @@ -850,7 +872,7 @@ html[data-pet-state="sleep"][data-pet-nonce="1"] #claude-cap { 75% { translate: calc(121px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } 87.5% { translate: calc(120px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } } -@keyframes kp-cap-sleep-enter-1 { +@keyframes kp-crown-sleep-enter-1 { 0% { translate: calc(108px * var(--pet-scale, 1)) calc(43px * var(--pet-scale, 1)); } 12.5% { translate: calc(96px * var(--pet-scale, 1)) calc(57px * var(--pet-scale, 1)); } 25% { translate: calc(108px * var(--pet-scale, 1)) calc(87px * var(--pet-scale, 1)); } @@ -860,14 +882,14 @@ html[data-pet-state="sleep"][data-pet-nonce="1"] #claude-cap { 75% { translate: calc(121px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } 87.5% { translate: calc(120px * var(--pet-scale, 1)) calc(127px * var(--pet-scale, 1)); } } -html[data-pet-state="sleep-enter"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-sleep-enter-0 3200ms step-end 1 forwards; +html[data-pet-state="sleep-enter"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-sleep-enter-0 3200ms step-end 1 forwards; } -html[data-pet-state="sleep-enter"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-sleep-enter-1 3200ms step-end 1 forwards; +html[data-pet-state="sleep-enter"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-sleep-enter-1 3200ms step-end 1 forwards; } -@keyframes kp-cap-sleep-exit-0 { +@keyframes kp-crown-sleep-exit-0 { 0% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } 14.2857% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } 28.5714% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } @@ -876,7 +898,7 @@ html[data-pet-state="sleep-enter"][data-pet-nonce="1"] #claude-cap { 71.4286% { translate: calc(119px * var(--pet-scale, 1)) calc(100px * var(--pet-scale, 1)); } 85.7143% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -@keyframes kp-cap-sleep-exit-1 { +@keyframes kp-crown-sleep-exit-1 { 0% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } 14.2857% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } 28.5714% { translate: calc(121px * var(--pet-scale, 1)) calc(129px * var(--pet-scale, 1)); } @@ -885,14 +907,14 @@ html[data-pet-state="sleep-enter"][data-pet-nonce="1"] #claude-cap { 71.4286% { translate: calc(119px * var(--pet-scale, 1)) calc(100px * var(--pet-scale, 1)); } 85.7143% { translate: calc(105px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } } -html[data-pet-state="sleep-exit"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-sleep-exit-0 2800ms step-end 1 forwards; +html[data-pet-state="sleep-exit"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-sleep-exit-0 2800ms step-end 1 forwards; } -html[data-pet-state="sleep-exit"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-sleep-exit-1 2800ms step-end 1 forwards; +html[data-pet-state="sleep-exit"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-sleep-exit-1 2800ms step-end 1 forwards; } -@keyframes kp-cap-stretch-0 { +@keyframes kp-crown-stretch-0 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -913,7 +935,7 @@ html[data-pet-state="sleep-exit"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -@keyframes kp-cap-stretch-1 { +@keyframes kp-crown-stretch-1 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(44px * var(--pet-scale, 1)); } 5.2632% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 10.5263% { translate: calc(100px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } @@ -934,14 +956,14 @@ html[data-pet-state="sleep-exit"][data-pet-nonce="1"] #claude-cap { 89.4737% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } 94.7368% { translate: calc(106px * var(--pet-scale, 1)) calc(42px * var(--pet-scale, 1)); } } -html[data-pet-state="stretch"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-stretch-0 5600ms step-end 1 forwards; +html[data-pet-state="stretch"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-stretch-0 5600ms step-end 1 forwards; } -html[data-pet-state="stretch"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-stretch-1 5600ms step-end 1 forwards; +html[data-pet-state="stretch"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-stretch-1 5600ms step-end 1 forwards; } -@keyframes kp-cap-waving-0 { +@keyframes kp-crown-waving-0 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 5.5556% { translate: calc(108px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 11.1111% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } @@ -961,7 +983,7 @@ html[data-pet-state="stretch"][data-pet-nonce="1"] #claude-cap { 88.8889% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 94.4444% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -@keyframes kp-cap-waving-1 { +@keyframes kp-crown-waving-1 { 0% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 5.5556% { translate: calc(108px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 11.1111% { translate: calc(110px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } @@ -981,9 +1003,9 @@ html[data-pet-state="stretch"][data-pet-nonce="1"] #claude-cap { 88.8889% { translate: calc(109px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } 94.4444% { translate: calc(107px * var(--pet-scale, 1)) calc(49px * var(--pet-scale, 1)); } } -html[data-pet-state="waving"][data-pet-nonce="0"] #claude-cap { - animation: kp-cap-waving-0 2700ms step-end 1 forwards; +html[data-pet-state="waving"][data-pet-nonce="0"] #claude-crown { + animation: kp-crown-waving-0 2700ms step-end 1 forwards; } -html[data-pet-state="waving"][data-pet-nonce="1"] #claude-cap { - animation: kp-cap-waving-1 2700ms step-end 1 forwards; +html[data-pet-state="waving"][data-pet-nonce="1"] #claude-crown { + animation: kp-crown-waving-1 2700ms step-end 1 forwards; } diff --git a/apps/desktop/src/renderer/pet.html b/apps/desktop/src/renderer/pet.html index 5423b32..fc69aa5 100644 --- a/apps/desktop/src/renderer/pet.html +++ b/apps/desktop/src/renderer/pet.html @@ -40,8 +40,8 @@ - - + + diff --git a/docs/CLAUDE-CODE.md b/docs/CLAUDE-CODE.md index 5d77536..d851ad6 100644 --- a/docs/CLAUDE-CODE.md +++ b/docs/CLAUDE-CODE.md @@ -1,6 +1,6 @@ -# Claude Code status cap +# Claude Code status crown -The pet wears a coloured square that follows what Claude Code is doing. +The pet wears a crown that follows what Claude Code is doing. | Colour | Meaning | |---|---| @@ -9,10 +9,11 @@ The pet wears a coloured square that follows what Claude Code is doing. | 🟢 green | the task finished; ready for a new one | | *no cap* | no Claude Code session, or the last signal is over 15 minutes old | -This is a spike: a square, not cap art, and a single session. Two sessions at once will fight -over the colour. +Single session for now: two at once will fight over the colour. -![The pet wearing a red status square, with a speech bubble above it](demo/claude-cap-waiting.png) +| 🔴 waiting | 🟡 running | 🟢 idle | +|---|---|---| +| ![red crown](demo/crown-waiting.png) | ![gold crown](demo/crown-running.png) | ![green crown](demo/crown-idle.png) | ## How it works @@ -98,7 +99,7 @@ rather than replacing it. } ``` -`PreToolUse` is what returns the cap to amber after you approve a prompt — answering a +`PreToolUse` is what returns the crown to amber after you approve a prompt — answering a permission request does not fire `Notification` again. `PreToolUse` and `PostToolUse` carry no `matcher`, which matches every tool. `"*"` is @@ -112,10 +113,10 @@ With Argos running: ```bash mkdir -p ~/.argos -echo waiting > ~/.argos/claude-state # red -echo running > ~/.argos/claude-state # amber -echo idle > ~/.argos/claude-state # green -rm ~/.argos/claude-state # gone +echo waiting > ~/.argos/claude-state # red crown +echo running > ~/.argos/claude-state # gold crown +echo idle > ~/.argos/claude-state # green crown +rm ~/.argos/claude-state # bare-headed ``` The colour changes within a second. This is the integration test worth running first: if these @@ -127,5 +128,14 @@ Point Argos at a different file with `ARGOS_CLAUDE_STATE_FILE`. - **One session.** The last hook to fire wins, whichever session it came from. - **Stale state.** A session killed with `Ctrl+C` never fires `SessionEnd`. Its file lingers, and - the cap stays until the file is 15 minutes old. + the crown stays until the file is 15 minutes old. - **macOS only, so far.** The Linux shape-region handling is written but unverified. + +## The art + +`pet/crowns-source/` holds the full-size crowns; `pnpm generate` downsamples them to the size +they are worn at and writes `pet/crown-*.png`. Nothing hand-places them: the size, the gap above +the head and the per-animation-frame position all come out of `scripts/lib/crowns.mjs` and the +sprite art, into `pet.generated.css`. + +To change a crown, replace its source PNG and run `pnpm generate`. diff --git a/docs/demo/claude-cap-waiting.png b/docs/demo/claude-cap-waiting.png deleted file mode 100644 index bfb4b1b86b74427c702eca34a176e1dc7226590e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 30509 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 oEiael($1f-U5A^0Wvj6}9 diff --git a/docs/demo/crown-idle.png b/docs/demo/crown-idle.png new file mode 100644 index 0000000000000000000000000000000000000000..4a884ca153039dc49ede1e5835487530ed50e689 GIT binary patch literal 31475 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
i#ne$hit`)T%w8Y0lv{iQ1-bRkR&kzCM`!N&Ga# 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 AfdBvi literal 0 HcmV?d00001 diff --git a/docs/demo/crown-waiting.png b/docs/demo/crown-waiting.png new file mode 100644 index 0000000000000000000000000000000000000000..48506513e6c75c14e2493e17252e9e3533344013 GIT binary patch literal 31396 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 literal 0 HcmV?d00001 diff --git a/docs/superpowers/plans/2026-09-04-claude-state-cap.md b/docs/superpowers/plans/2026-09-04-claude-state-cap.md index 09f74da..c983de9 100644 --- a/docs/superpowers/plans/2026-09-04-claude-state-cap.md +++ b/docs/superpowers/plans/2026-09-04-claude-state-cap.md @@ -487,12 +487,12 @@ Then add to `tests/renderer/discipline.spec.ts`, inside the existing expect(pet).toContain('claudeState') const css = read(join(RENDERER_DIR, 'pet.css')) - expect(css).toMatch(/#claude-cap/) + expect(css).toMatch(/#claude-crown/) expect(css).toMatch(/\[data-claude-state='waiting'\]/) expect(css).toMatch(/\[data-claude-state='running'\]/) expect(css).toMatch(/\[data-claude-state='idle'\]/) // The cap tracks the head, not the window corner. - expect(css).toMatch(/#claude-cap[\s\S]*?var\(--body-cx/) + expect(css).toMatch(/#claude-crown[\s\S]*?var\(--body-cx/) }) ``` @@ -547,7 +547,7 @@ In `apps/desktop/src/renderer/pet.html`, directly after the `#zzz` div: ```html -

+ ``` - [ ] **Step 5: Publish the state from the renderer** @@ -574,7 +574,7 @@ Append to `apps/desktop/src/renderer/pet.css`: published per animation state and already multiplied by the scale, so this tracks the head through every pose and every pet size without any arithmetic of its own. */ -#claude-cap { +#claude-crown { position: absolute; left: var(--body-cx, 50%); top: calc(var(--body-top, 0px) - 3px * var(--pet-scale, 1)); @@ -590,17 +590,17 @@ Append to `apps/desktop/src/renderer/pet.css`: 0 1px 3px rgba(0, 0, 0, 0.35); } -html[data-claude-state='waiting'] #claude-cap { +html[data-claude-state='waiting'] #claude-crown { display: block; background: #e5484d; } -html[data-claude-state='running'] #claude-cap { +html[data-claude-state='running'] #claude-crown { display: block; background: #f5a524; } -html[data-claude-state='idle'] #claude-cap { +html[data-claude-state='idle'] #claude-crown { display: block; background: #30a46c; } diff --git a/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md b/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md index 1fd2efa..e4b5c6c 100644 --- a/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md +++ b/docs/superpowers/specs/2026-09-04-claude-state-cap-design.md @@ -55,7 +55,7 @@ Claude Code hook ──writes word──▶ ~/.argos/claude-state pet.ts (one attribute set) │ html[data-claude-state] ▼ - pet.css (#claude-cap square) + pet.css (#claude-crown square) ``` Each arrow is one-directional and each box has one job. The renderer stays dumb, which @@ -138,7 +138,7 @@ renderer-discipline test. **`apps/desktop/src/renderer/pet.css`** (changed) -`#claude-cap`, built on the `#zzz` pattern: absolutely positioned from `--body-cx` and +`#claude-crown`, built on the `#zzz` pattern: absolutely positioned from `--body-cx` and `--body-top`, offset by a scaled amount. Those custom properties are already per-animation-state and scale-aware, so the square tracks the head through every pose and every pet size without any new arithmetic. diff --git a/package.json b/package.json index 531cd2e..01e274c 100644 --- a/package.json +++ b/package.json @@ -16,8 +16,8 @@ }, "scripts": { "postinstall": "install-electron", - "generate": "node scripts/generate-sprite-css.mjs && node scripts/generate-alpha-mask.mjs", - "generate:check": "node scripts/generate-sprite-css.mjs --check && node scripts/generate-alpha-mask.mjs --check", + "generate": "node scripts/generate-crowns.mjs && node scripts/generate-sprite-css.mjs && node scripts/generate-alpha-mask.mjs", + "generate:check": "node scripts/generate-crowns.mjs --check && node scripts/generate-sprite-css.mjs --check && node scripts/generate-alpha-mask.mjs --check", "build": "pnpm generate:check && pnpm -F @keycode/desktop build", "dev": "pnpm -F @keycode/desktop dev", "typecheck": "pnpm -F @keycode/desktop typecheck", diff --git a/pet/crown-idle.png b/pet/crown-idle.png new file mode 100644 index 0000000000000000000000000000000000000000..31b093225113ca11f757b30865b5f58343a08095 GIT binary patch literal 1339 zcmV-B1;qM^P)Nl@;Q1r6Ec-U!oG|LsT294E3bY~Rnji>= z7>?ssl|cpR^Cnv2Enr#p?o)OuvkZgeYi$^*CNWY;!hEY848y?h_r*7RhvT^KTDM3j z){;mZ2$Ho|DKJ2Q=bi;@l3CUU<|`>GS7G7BDLALx9pv1wP3S(eCMu8(PlmMd}fn1TT0~V?c zKyEdV3(yFMmwGXH*+NrLL`$&ws3?j_B1vufwpnX}HKidt-$Cm)Qn7)>Y8u910`XLA zQ53}#neU6VyxOWu$exW+7};R_<$B;?fJQjH+>7DcT{IHECDBNUqT>pz=?JW;2(t5W z3UZ?>)(rgg_f33pbJm+5%K1>JBXfe9&M*E z3M4hGIl!8M(VB@nf8D_Me_X?29`JD$Z>;P^v0~UxcG5}enDBtC1N_VdcGJaa&8F?BEEhPfHP*0Z1D8Eu z4U;Roy>U8+W+GL8)7U^`&cd!ceHdQsM#ckbwq_g=mzL{+22CjiuGzpND|;x!O?kmF zPW(xrX-Bx&<)zP@(rmN1;Elkl;iU8i9z0&6nydrba$Tx|_=T8eLD{bSs=pb-_OA@| zUq~Z)q8**bi9$}>j-;dRSsl5H3FOKNWXlQqe17=@%>Qy07w(=x>FN+oJ5g>vf$W!Y zY@5}g?@=G{Jb%T#Ne+{nK^^uZG!Z~>zl`9R47DUf-6tbRRI>Zp=$OAwGD73)Y8#gk zB<+N);HV6;wjc=axcA<5WkC6@ z6BxW=YiOYppa1+3F0IVr(!Dv1U*CZt(oe?{82UPafpal*><=V%L8SmY>4HW=d?y^M%-C&79z4uvkuIYv5MgwiF6}S5QM|BDVNn9Dq`d9 z&`WJl`+W!!4fyD@tybC>83`b^KZw|v>S^Njy?EuwIMvpd5?;SvTAvfn2EO5W{;>OV xLjFYk!?Nrnr)>~dFRreo;u^L28s49%{{Vr(bGM|TBq{&^002ovPDHLkV1lr+ltTaj literal 0 HcmV?d00001 diff --git a/pet/crown-running.png b/pet/crown-running.png new file mode 100644 index 0000000000000000000000000000000000000000..9a50f085992de187525674ff90b85a8be628f08c GIT binary patch literal 971 zcmV;+12p`JP)d)IWau-_c|W0) z<_0%ul*UbLdQ^fj_ES)DTiY5%2*KO0TPWq2&xeOCcwNZv(AP7-JwQdWlIa!P5k(+1|bxj^PP2zov;Om zo6&I3nN^`jF~_kk;^mNRU14pdl;YH}+HM4F>3<>AjY76WczM!7tW_e?YVXrpN0rvm z=xTL*!y^iAMgg*nAQ@}L!n-%) zC`_xB3m-%?p*y>=K~@nm#{L&V^Ir(RURKCCpYd+=qdjr^a(2IkKe85PzgM{ZfyC|6 zVDiT$=FZp1pO={ZFE2e3Fx^T%-*6ZC2C;CH} zI%oxQt;|&2_tM{uu{I`C4jAL!zdKNQXPwyH8M<=zkj9_iY0REc_-oWd;LfOA#Qdnl z+~*3nE{ZC1mn8Dn-^ARF!#??+AIGgrwfUI~5@%0pqz77VaL&I7Jj2ovv55LJEc{@i zIL)fK(;S7uINW=u7Pz?q#T-R3w=iEl!(qEw(U^f08j6O)b;nU!rf7k{bQ0-(FZrbQw$;W5YrK$jycVOc@;ceY tIrkc!d9UFqH$6@Hr=eH+Jjf^t>+w=Z9-jsYF$n5c~6%HP+*LXz{%FOd+}qB3gKY2(ygg zZbo2?UD#r$DaH)E=p|6B&7qjB!)vJ&48uS&ncP|J9U?lvTL>&?vN)DVsI?b0uq^`8 ztpc+sW^=a$+$98x3g~$of!{E~Ak0_Yub%iDU`*t}pSB zZKEOKJ!9L}o@l;hSyHXh>^R>)?Rxq|;=siSxaj+s^`+i5=e(n|Q^wv-GKQ)3P5rJS z%w&UOt<7P%HU||2W9;K-KIeQtGZ@bL5-YVitxdqM8N-4vF)P!XfQ+$s5{zMz5$3`j zmw?%-z!qj06~J;17a!L^(!lRz8g)ddx2zW&$H}{nldtFE>@LnRNrbt`G$m!RSNdr1 z{jVI`-l^WX-FBYM3lkIROljUowHzwob(z*jw~t6isx-zqrigTemt#QXJ{953-skYq zlWnE>Ew-)4%A2a&5TPy$4U`fKGL7l=eC=a|3?m%j9ODYOz6qsLgqa|J3i#jQ9{kaL z2(Ryb5cyOJEtZXyOs+Jq(liTY(?}hq0zOQHJBUIM3l#@uL(^n6aBXA|tHVdpd|N$Q zZM$r&Os;xad>b8U2%IF2FNv36(_uRo)nUw~CE&;)ZZtLFMmB(~#ByD=EFxeW5cQ`w zM3^nXG_b!1YsZGPRtkj*QRvx~+2<03~Ls z0H3QiU22agKz^Ks(%F`2?|$rL6S z;gbrTS0cg%*Toen@uwfj$6sx&nD2ZF^BwKDvSWw-{;HqW?ImC0T#b)j*Sjb2p7>%x>Gmi=J z%W=-}Q>q5P*3{s0B1{m+1Q9;deZr?&96z{j5Sc9NZxvxjJLWsvaV?+6RbS$oOlw_| zX`GW1J&D9+#fsgfK@P8{)0heKHdCSL(4|qqD=kGX9UannEH)Oxu{td0>Vvl8YSS*A z4a?#mKW-Y*{h5k74BQ!LDN~D^ecf0c4hp|`XJg4M%hC0h4ostgLh!!(P4le|BJ?{B z`fUfQ-$|s~s2@G6-^?SfhXL0MTF1rUT}>FeXOGr^lpDqd!nrN3dxmq~7yL2eyo)hb n+)A{~7*SbU%`;6gs9664Sj}NZIa%TY00000NkvXXu0mjf%t0mh literal 0 HcmV?d00001 diff --git a/pet/crowns-source/idle.png b/pet/crowns-source/idle.png new file mode 100644 index 0000000000000000000000000000000000000000..b67e9e8e5f3fc6e98ffa453ecb055530f1b28314 GIT binary patch literal 91291 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
SVvagL$y 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 z�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 literal 0 HcmV?d00001 diff --git a/pet/crowns-source/running.png b/pet/crowns-source/running.png new file mode 100644 index 0000000000000000000000000000000000000000..bd5eddb0634c197144113e49a48e12bd567f473f GIT binary patch literal 32840 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 iT?PODtb!WRtiW># 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 literal 0 HcmV?d00001 diff --git a/scripts/copy-static.mjs b/scripts/copy-static.mjs index 39e6281..d73db24 100644 --- a/scripts/copy-static.mjs +++ b/scripts/copy-static.mjs @@ -7,9 +7,9 @@ * 1. **The preload.** It is `.cjs` on purpose — a sandboxed preload cannot be an ES module — so * tsc (which is compiling ESM TypeScript) does not emit it, and Vite does not own it either. * - * 2. **The spritesheet.** The generated CSS refers to it by literal filename, so it must not be - * fingerprinted by the bundler; and it cannot be copied at runtime because in a packaged app - * `dist/` lives inside a read-only asar archive. + * 2. **The spritesheet and the status crowns.** The generated CSS refers to them by literal + * filename, so they must not be fingerprinted by the bundler; and they cannot be copied at + * runtime because in a packaged app `dist/` lives inside a read-only asar archive. * * Runs after `vite build`, which empties `dist/renderer`. */ @@ -18,6 +18,7 @@ import { copyFile, mkdir } from 'node:fs/promises' import { existsSync } from 'node:fs' import { join, dirname, resolve } from 'node:path' import { fileURLToPath } from 'node:url' +import { CROWNS } from './lib/crowns.mjs' const HERE = dirname(fileURLToPath(import.meta.url)) const ROOT = resolve(HERE, '..') @@ -29,6 +30,7 @@ const COPIES = [ ['apps/desktop/src/preload/pet-preload.cjs', 'preload/pet-preload.cjs'], ['apps/desktop/src/preload/toast-preload.cjs', 'preload/toast-preload.cjs'], ['pet/spritesheet.png', 'renderer/spritesheet.png'], + ...CROWNS.map((crown) => [`pet/${crown.file}`, `renderer/${crown.file}`]), ] async function main() { diff --git a/scripts/generate-crowns.mjs b/scripts/generate-crowns.mjs new file mode 100644 index 0000000..8438458 --- /dev/null +++ b/scripts/generate-crowns.mjs @@ -0,0 +1,127 @@ +#!/usr/bin/env node +/** + * Downsample the status crown art to the size it is actually worn at. + * + * node scripts/generate-crowns.mjs [--check] + * + * The source art is ~340x264 with soft shading, and the pet is drawn at 192x208 per cell. Letting + * CSS shrink the big PNG instead would fight `image-rendering: pixelated`: the browser would be + * resampling by a non-integer factor every frame, and the result is mush at exactly the sizes the + * pet is usually shown at. Resampling once, here, means the renderer only ever paints 1:1 (at + * full size) or by a clean half/three-quarter step. + * + * The filter is a box average over premultiplied alpha. Averaging straight RGBA instead pulls the + * fully transparent pixels' colour into the edge pixels, which on this art is black — the crown + * would come out with a dark fringe all the way round. + */ + +import { readFileSync, writeFileSync, existsSync } from 'node:fs' +import { join } from 'node:path' +import { decodePng, encodePng } from './lib/png.mjs' +import { ROOT } from './lib/spritesheet.mjs' +import { CROWNS, CROWN_WIDTH, CROWN_HEIGHT } from './lib/crowns.mjs' + +const SOURCE_DIR = join(ROOT, 'pet', 'crowns-source') +const OUT_DIR = join(ROOT, 'pet') + +/** Tight bounding box of everything not fully transparent. */ +function opaqueBounds(png) { + let x0 = png.width + let y0 = png.height + let x1 = -1 + let y1 = -1 + for (let y = 0; y < png.height; y += 1) { + for (let x = 0; x < png.width; x += 1) { + if (png.data[(y * png.width + x) * 4 + 3] < 8) continue + if (x < x0) x0 = x + if (x > x1) x1 = x + if (y < y0) y0 = y + if (y > y1) y1 = y + } + } + if (x1 < 0) throw new Error('crown source is entirely transparent') + return { x0, y0, width: x1 - x0 + 1, height: y1 - y0 + 1 } +} + +/** Box-average `src` (cropped to `box`) down to `outW` x `outH`, premultiplied. */ +function downsample(png, box, outW, outH) { + const out = Buffer.alloc(outW * outH * 4) + for (let oy = 0; oy < outH; oy += 1) { + for (let ox = 0; ox < outW; ox += 1) { + const sx0 = box.x0 + Math.floor((ox * box.width) / outW) + const sx1 = box.x0 + Math.floor(((ox + 1) * box.width) / outW) + const sy0 = box.y0 + Math.floor((oy * box.height) / outH) + const sy1 = box.y0 + Math.floor(((oy + 1) * box.height) / outH) + + let r = 0 + let g = 0 + let b = 0 + let a = 0 + let n = 0 + for (let sy = sy0; sy < Math.max(sy1, sy0 + 1); sy += 1) { + for (let sx = sx0; sx < Math.max(sx1, sx0 + 1); sx += 1) { + const i = (sy * png.width + sx) * 4 + const alpha = png.data[i + 3] / 255 + r += png.data[i] * alpha + g += png.data[i + 1] * alpha + b += png.data[i + 2] * alpha + a += png.data[i + 3] + n += 1 + } + } + + const meanAlpha = a / n + const o = (oy * outW + ox) * 4 + if (meanAlpha < 1) { + out[o] = 0 + out[o + 1] = 0 + out[o + 2] = 0 + out[o + 3] = 0 + continue + } + // Un-premultiply back to straight alpha for storage. + const scale = 255 / meanAlpha / n + out[o] = Math.min(255, Math.round(r * scale)) + out[o + 1] = Math.min(255, Math.round(g * scale)) + out[o + 2] = Math.min(255, Math.round(b * scale)) + out[o + 3] = Math.round(meanAlpha) + } + } + return out +} + +function main() { + const check = process.argv.slice(2).includes('--check') + const stale = [] + + for (const crown of CROWNS) { + const sourcePath = join(SOURCE_DIR, crown.source) + if (!existsSync(sourcePath)) { + console.error(`generate-crowns: missing source pet/crowns-source/${crown.source}`) + process.exit(1) + } + const png = decodePng(readFileSync(sourcePath)) + const box = opaqueBounds(png) + const rgba = downsample(png, box, CROWN_WIDTH, CROWN_HEIGHT) + const encoded = encodePng(CROWN_WIDTH, CROWN_HEIGHT, rgba) + + const outPath = join(OUT_DIR, crown.file) + const current = existsSync(outPath) ? readFileSync(outPath) : null + if (current && current.equals(encoded)) continue + if (check) { + stale.push(crown.file) + continue + } + writeFileSync(outPath, encoded) + } + + if (check && stale.length > 0) { + console.error(`crowns are stale: ${stale.join(', ')} — run \`pnpm generate\``) + process.exit(1) + } + console.log( + `✓ crowns (${CROWNS.length} at ${CROWN_WIDTH}x${CROWN_HEIGHT})${check ? ': up to date' : ''}`, + ) +} + +main() diff --git a/scripts/generate-sprite-css.mjs b/scripts/generate-sprite-css.mjs index 1c1a4be..e1e58dd 100644 --- a/scripts/generate-sprite-css.mjs +++ b/scripts/generate-sprite-css.mjs @@ -56,6 +56,7 @@ import { join } from 'node:path' import { readFileSync } from 'node:fs' import { loadSpritesheet, ROOT, SPRITESHEET_PNG } from './lib/spritesheet.mjs' import { headAnchorsByFrame } from './lib/mask.mjs' +import { CROWNS, CROWN_WIDTH, CROWN_HEIGHT, CROWN_GAP } from './lib/crowns.mjs' import { decodePng } from './lib/png.mjs' import { emitOrCheck, reportResults, cssBanner, tsBanner } from './lib/generated-file.mjs' @@ -83,7 +84,7 @@ function keyframesName(state, nonce) { * Offsets are emitted in unscaled cell space and multiplied by `--pet-scale` here, so the cap * tracks the head at every pet size without the renderer computing anything. */ -function buildCapCss(sheet, states, anchors) { +function buildCrownCss(sheet, states, anchors) { const lines = [] for (const state of states) { @@ -91,7 +92,7 @@ function buildCapCss(sheet, states, anchors) { const iterations = state.iterations === 'infinite' ? 'infinite' : String(state.iterations) for (const nonce of NONCES) { - lines.push(`@keyframes ${capKeyframesName(state.name, nonce)} {`) + lines.push(`@keyframes ${crownKeyframesName(state.name, nonce)} {`) frames.forEach((anchor, index) => { // Stop i opens the window in which the sprite is showing frame i, matching the // `steps(n, jump-none)` the sprite runs on. @@ -105,8 +106,8 @@ function buildCapCss(sheet, states, anchors) { for (const nonce of NONCES) { lines.push( - `html[data-pet-state="${state.name}"][data-pet-nonce="${nonce}"] #claude-cap {`, - ` animation: ${capKeyframesName(state.name, nonce)} ${state.durationMs}ms step-end ${iterations} forwards;`, + `html[data-pet-state="${state.name}"][data-pet-nonce="${nonce}"] #claude-crown {`, + ` animation: ${crownKeyframesName(state.name, nonce)} ${state.durationMs}ms step-end ${iterations} forwards;`, '}', ) } @@ -116,8 +117,8 @@ function buildCapCss(sheet, states, anchors) { return lines } -function capKeyframesName(state, nonce) { - return `kp-cap-${state}-${nonce}` +function crownKeyframesName(state, nonce) { + return `kp-crown-${state}-${nonce}` } function buildCss(sheet, states, holdStrategy, anchors) { @@ -176,14 +177,32 @@ function buildCss(sheet, states, holdStrategy, anchors) { } lines.push( - '/* The status cap rides the same clock as the sprite; see buildCapCss. */', - '#claude-cap {', + '/* The status crown. Size, art and clock are all generated; see buildCrownCss. */', + '#claude-crown {', + ` width: calc(${CROWN_WIDTH}px * var(--pet-scale, 1));`, + ` height: calc(${CROWN_HEIGHT}px * var(--pet-scale, 1));`, + ' background-repeat: no-repeat;', + ' background-size: 100% 100%;', + ' /* Same reason as the sprite: without it the browser smooths the pixel art into mush. */', + ' image-rendering: pixelated;', + ' /* Composes with the `translate` the keyframes animate. That puts the anchor on the head;', + ` this centres the crown on it and lifts it clear by ${CROWN_GAP}px of daylight. */`, + ` transform: translate(-50%, calc(-100% - ${CROWN_GAP}px * var(--pet-scale, 1)));`, ' animation-timing-function: step-end;', '}', '', - ...buildCapCss(sheet, states, anchors), ) + for (const crown of CROWNS) { + lines.push( + `html[data-claude-state="${crown.state}"] #claude-crown {`, + ' display: block;', + ` background-image: url('./${crown.file}');`, + '}', + ) + } + lines.push('', ...buildCrownCss(sheet, states, anchors)) + return `${lines.join('\n').trimEnd()}\n` } diff --git a/scripts/lib/crowns.mjs b/scripts/lib/crowns.mjs new file mode 100644 index 0000000..980eed7 --- /dev/null +++ b/scripts/lib/crowns.mjs @@ -0,0 +1,33 @@ +/** + * The status crowns: which art belongs to which Claude Code state, and how big it is worn. + * + * Shared by the asset generator (which produces the small PNGs) and the CSS generator (which + * sizes and places them), so the crown's dimensions have exactly one definition. Hand-written + * CSS is asserted to contain no such geometry. + */ + +/** Claude Code state -> source art. Order is the order they are emitted in. */ +export const CROWNS = [ + { state: 'waiting', source: 'waiting.png', file: 'crown-waiting.png' }, + { state: 'running', source: 'running.png', file: 'crown-running.png' }, + { state: 'idle', source: 'idle.png', file: 'crown-idle.png' }, +] + +/** + * Worn size, in unscaled sprite-cell pixels. + * + * The pet's head is ~40px of visible skull in a 192px cell, so a crown much wider than this + * stops reading as worn and starts reading as a banner floating overhead. The height follows + * the source art's 340x264 aspect ratio; changing the width without the height would squash it. + */ +export const CROWN_WIDTH = 28 +export const CROWN_HEIGHT = 22 + +/** + * Gap between the crown's bottom edge and the top of the head, in unscaled cell pixels. + * + * Deliberate daylight rather than a seated hat: it keeps the crown clear of the horn, which + * reaches as high as the hair does, and reads as "status floating above the pet" rather than as + * a costume change. + */ +export const CROWN_GAP = 4 diff --git a/scripts/smoke.mjs b/scripts/smoke.mjs index 0f52927..44122e4 100644 --- a/scripts/smoke.mjs +++ b/scripts/smoke.mjs @@ -889,20 +889,27 @@ async function assertPass(session, opts, name) { } const colours = assertNotBlank(png, region, 'A3 not-blank') const fill = assertSpritePainted(png, region, 'A1 sprite-painted') - const ring = assertWindowTransparentAround( - png, - region, - 'A2 window-transparent', - Math.max(8, Math.round(24 * scale)), - // Gated on main reporting a bubble actually on screen — never on `--callout`, because a - // broadcast or a reminder raises one with no flag involved. Absent, the full ring is checked. - captured.bubbleVisible && captured.bubbleEdgeY !== undefined - ? { - edge: Math.round((captured.bubbleEdgeY - captured.bounds.y) * scale), - side: captured.bubbleSide ?? 'above', - } - : null, - ) + // A2 asks whether the *window* is see-through. A status crown floats in the gap above the + // head, which is inside the ring, so it would fail an assertion it is not the subject of. + // Skipped rather than narrowed: the crown's exact band is per animation frame and lives in + // the generated stylesheet, so main cannot report a bound tight enough to be worth trusting. + // Gated on main reporting a crown actually worn, so ordinary runs still check the full ring. + const ring = captured.crownVisible + ? null + : assertWindowTransparentAround( + png, + region, + 'A2 window-transparent', + Math.max(8, Math.round(24 * scale)), + // Gated on main reporting a bubble actually on screen — never on `--callout`, because a + // broadcast or a reminder raises one with no flag involved. Absent, the full ring is checked. + captured.bubbleVisible && captured.bubbleEdgeY !== undefined + ? { + edge: Math.round((captured.bubbleEdgeY - captured.bounds.y) * scale), + side: captured.bubbleSide ?? 'above', + } + : null, + ) // `floorLocked` is absent on builds before free placement, where floor-locked was the only mode. const floorLocked = captured.floorLocked ?? true assertFeetOnFloor(spriteRect, pet.display, 'A4 feet-on-floor', floorLocked) @@ -915,14 +922,16 @@ async function assertPass(session, opts, name) { ) console.log(` ✓ A1 sprite painted (${(fill * 100).toFixed(1)}% of the bbox has alpha)`) console.log( - ` ✓ A2 window transparent around the sprite (${(ring * 100).toFixed(1)}% of ring` + - `${ - captured.bubbleVisible - ? captured.bubbleSide === 'below' - ? ', down to the feet — a bubble is up below the pet' - : ', from the hair down — a bubble is up' - : '' - })`, + ring === null + ? ' · A2 skipped — a status crown is worn, and it paints in the ring by design' + : ` ✓ A2 window transparent around the sprite (${(ring * 100).toFixed(1)}% of ring` + + `${ + captured.bubbleVisible + ? captured.bubbleSide === 'below' + ? ', down to the feet — a bubble is up below the pet' + : ', from the hair down — a bubble is up' + : '' + })`, ) console.log(` ✓ A3 image is not blank (${colours} distinct colours)`) console.log( diff --git a/tests/renderer/discipline.spec.ts b/tests/renderer/discipline.spec.ts index 0cae107..d892a76 100644 --- a/tests/renderer/discipline.spec.ts +++ b/tests/renderer/discipline.spec.ts @@ -137,34 +137,41 @@ describe('hand-written CSS carries no generated geometry', () => { expect(css).toMatch(/var\(--body-top/) }) - it('paints the status cap from state the renderer publishes', () => { + it('paints the status crown from state the renderer publishes', () => { // Two halves in two files again: the renderer publishes the state, the CSS paints it. Either - // half being dropped leaves a cap that is silently never shown, which looks exactly like + // half being dropped leaves a crown that is silently never shown, which looks exactly like // "Claude is not running" and so would not be noticed. const pet = read(join(RENDERER_DIR, 'pet.ts')) expect(pet).toContain('claudeState') const css = read(join(RENDERER_DIR, 'pet.css')) - expect(css).toMatch(/#claude-cap/) - expect(css).toMatch(/\[data-claude-state='waiting'\]/) - expect(css).toMatch(/\[data-claude-state='running'\]/) - expect(css).toMatch(/\[data-claude-state='idle'\]/) + expect(css).toMatch(/#claude-crown/) + + // The per-state rules live in the generated stylesheet rather than in pet.css, because the + // crown filenames come out of scripts/lib/crowns.mjs and hand-copying them here is exactly + // how the art and the stylesheet drift apart. + const generated = read(join(RENDERER_DIR, 'pet.generated.css')) + for (const state of ['waiting', 'running', 'idle']) { + expect(generated, state).toMatch( + new RegExp(`\\[data-claude-state="${state}"\\] #claude-crown \\{[^}]*crown-${state}\\.png`), + ) + } }) - it('leaves the cap\'s per-frame geometry to the generator', () => { - // The cap has to bob with the pet, and the pet's bounce is background-position stepping -- - // the sprite element never moves. So the cap cannot hang off --body-top, which is a + it('leaves the crown\'s per-frame geometry to the generator', () => { + // The crown has to bob with the pet, and the pet's bounce is background-position stepping -- + // the sprite element never moves. So the crown cannot hang off --body-top, which is a // per-state constant chosen precisely so the speech bubble does NOT bob. It rides generated // per-frame keyframes instead, and the hand-written rule may only park it on the cell. const css = read(join(RENDERER_DIR, 'pet.css')) - const rule = css.slice(css.indexOf('#claude-cap {')) + const rule = css.slice(css.indexOf('#claude-crown {')) const decl = rule.slice(0, rule.indexOf('}')) - expect(decl, 'cap is pinned to the non-bobbing bubble anchor').not.toMatch(/var\(--body-top/) + expect(decl, 'crown is pinned to the non-bobbing bubble anchor').not.toMatch(/var\(--body-top/) expect(decl).toMatch(/var\(--sprite-x/) expect(decl).toMatch(/var\(--sprite-y/) // The renderer must publish the sprite's state and nonce on the root: the cap is a sibling - // of #sprite, so CSS cannot read them off it, and without the nonce the cap does not restart + // of #sprite, so CSS cannot read them off it, and without the nonce the crown does not restart // with the sprite and drifts a frame out of phase for the whole loop. const pet = read(join(RENDERER_DIR, 'pet.ts')) expect(pet).toContain('petState') diff --git a/tests/sprite/cap-anchor.spec.ts b/tests/sprite/crown-anchor.spec.ts similarity index 85% rename from tests/sprite/cap-anchor.spec.ts rename to tests/sprite/crown-anchor.spec.ts index 0314607..9e3c568 100644 --- a/tests/sprite/cap-anchor.spec.ts +++ b/tests/sprite/crown-anchor.spec.ts @@ -63,23 +63,23 @@ describe('per-frame head anchors', () => { }) }) -describe('generated cap keyframes', () => { +describe('generated crown keyframes', () => { const { states } = loadSpritesheet() as { states: Array<{ name: string; frames: number; durationMs: number; iterations?: unknown }> } - it('emits a cap keyframe rule per state per nonce', () => { + it('emits a crown keyframe rule per state per nonce', () => { for (const state of states) { for (const nonce of [0, 1]) { - expect(CSS, `${state.name}/${nonce}`).toContain(`@keyframes kp-cap-${state.name}-${nonce}`) + expect(CSS, `${state.name}/${nonce}`).toContain(`@keyframes kp-crown-${state.name}-${nonce}`) } } }) it('gives multi-frame states one stop per frame', () => { - // One stop per frame is what makes the cap land on the real head position rather than on a + // One stop per frame is what makes the crown land on the real head position rather than on a // linear interpolation between the first and last — the head tops are not a ramp. - const block = CSS.slice(CSS.indexOf('@keyframes kp-cap-jumping-0')) + const block = CSS.slice(CSS.indexOf('@keyframes kp-crown-jumping-0')) const body = block.slice(0, block.indexOf('}\n@') + 1) const stops = body.match(/^\s+[\d.]+% \{/gm) ?? [] const jumping = states.find((s) => s.name === 'jumping')! @@ -87,15 +87,15 @@ describe('generated cap keyframes', () => { }) it('steps rather than interpolates, and scales with the pet', () => { - expect(CSS).toMatch(/#claude-cap[\s\S]*?animation-timing-function:\s*step-end/) - expect(CSS).toMatch(/@keyframes kp-cap-idle-0[\s\S]*?var\(--pet-scale/) + expect(CSS).toMatch(/#claude-crown \{[\s\S]*?animation-timing-function:\s*step-end/) + expect(CSS).toMatch(/@keyframes kp-crown-idle-0[\s\S]*?var\(--pet-scale/) }) - it('runs the cap on the same clock as the sprite', () => { - // Out of phase by even one frame and the cap lands on the wrong head position all the way + it('runs the crown on the same clock as the sprite', () => { + // Out of phase by even one frame and the crown lands on the wrong head position all the way // through the loop. Same duration, same iteration count, restarted by the same nonce flip. for (const state of states) { - const rule = CSS.slice(CSS.indexOf(`[data-pet-state="${state.name}"][data-pet-nonce="0"] #claude-cap`)) + const rule = CSS.slice(CSS.indexOf(`[data-pet-state="${state.name}"][data-pet-nonce="0"] #claude-crown`)) const decl = rule.slice(0, rule.indexOf('}')) expect(decl, state.name).toContain(`${state.durationMs}ms`) } From 8e441cc756468d4a806167df3996a67bf8083993 Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 11:08:54 +0530 Subject: [PATCH 10/12] docs: design for the multi-session crown Loudest wins across one state file per session, keyed by the hook's $PPID -- verified by probe to be the session's own claude process, so the hook stays a one-liner with no jq and no JSON parsing. The pid is also a liveness handle, which fixes a real defect in the shipped version: staleness is currently a 15-minute mtime TTL, and a session sitting at a permission prompt never touches its file, so the red crown silently vanishes after 15 minutes of waiting. Co-Authored-By: Claude Opus 5 (1M context) --- .../2026-09-04-multi-session-crown-design.md | 126 ++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 docs/superpowers/specs/2026-09-04-multi-session-crown-design.md diff --git a/docs/superpowers/specs/2026-09-04-multi-session-crown-design.md b/docs/superpowers/specs/2026-09-04-multi-session-crown-design.md new file mode 100644 index 0000000..8aaf0f5 --- /dev/null +++ b/docs/superpowers/specs/2026-09-04-multi-session-crown-design.md @@ -0,0 +1,126 @@ +# Multi-session status crown — design + +**Date:** 2026-09-04 +**Branch:** `claude-integration` +**Status:** approved, not yet implemented +**Supersedes the single-session limit in:** `2026-09-04-claude-state-cap-design.md` + +## Problem + +The crown tracks one Claude Code session. Every session writes the same file, so the last hook to +fire wins and the crown reports whichever session moved most recently — not the one that needs +attention. Two sessions running at once make the crown actively misleading: the one waiting on a +permission prompt is invisible the moment the other one runs a tool. + +This is not hypothetical on the target machine — two `claude` processes were running while this +was written. + +## Solution + +One state file per session, aggregated by **loudest wins**. + +| Any session | Crown | +|---|---| +| waiting for confirmation | 🔴 red | +| else running | 🟡 gold | +| else recently finished | 🟢 green | +| else | bare-headed | + +Red answers the only question worth answering at a glance — *does anything need me?* — regardless +of which terminal it came from. + +## Identifying a session + +The hook writes to `~/.argos/sessions/$PPID`. + +A hook command's parent process is the session's own `claude` CLI process. Verified by probe: a +hook reporting `$PPID` gave a pid whose `ps -o comm=` is `claude`. So the session identity is +already in the shell, and the hook stays a one-liner with no `jq`, no JSON parsing, and no +dependency on either side — the property that made the original transport worth having. + +The alternative was parsing `session_id` out of the hook's stdin JSON, which needs either `jq` +(not guaranteed present) or a script installed at a stable path (a second thing to keep in sync). + +## Liveness, and a bug this fixes + +A pid is a liveness handle, which the previous design lacked: + +1. **`SessionEnd`** deletes the file. Covers a clean exit. +2. **`process.kill(pid, 0)`** covers everything else — `Ctrl+C`, a crash, a closed terminal. + Sending signal 0 performs the permission and existence check without delivering a signal, so + `ESRCH` means the session is gone. Exact, not a guess. +3. **A long mtime ceiling** (12h) is the only remaining backstop, against pid reuse: a dead + session's file plus a recycled pid would otherwise read as alive forever. + +**This corrects a real defect in the shipped version.** Today staleness is a 15-minute mtime TTL, +and a session sitting at a permission prompt does not touch its file while it waits. Leave a +prompt unanswered for 15 minutes and the red crown silently disappears — precisely when it is +most wanted. Pid liveness replaces the guess, so waiting and running states persist for as long +as the process does. + +## Green decay + +Green means *just finished, come look*. It expires 5 minutes after the finishing hook wrote it, +and the pet goes bare-headed while the session stays alive for red and gold purposes. + +A signal that is always on is not a signal. Without decay, any long-lived session parks a green +crown on the pet all day and the crown stops carrying information. + +Red and gold do not decay. They describe a live condition; green describes a moment that passes. + +## Architecture + +Only `claude-state-source.ts` changes, which is why the module boundary was drawn there. + +``` +Claude Code hooks ──▶ ~/.argos/sessions/ (one word each) + │ + fs.watch + poll + ▼ + claude-state-source.ts + read each file + drop dead pids (kill(pid, 0)) + drop expired green + reduce: waiting > running > idle > none + │ current(): ClaudeState + ▼ + unchanged from here on +``` + +`PetFrame.claudeState` keeps its four values, so the controller, the frame seam, the renderer, +the crown art and the shape region are all untouched. The aggregation is entirely inside the one +module that already owns "how the state arrives". + +### Pruning + +Files whose pid is dead are unlinked as they are found, so the directory does not grow by one +file per session forever. A failed unlink is ignored — the file will be skipped on every read +regardless, and a source that throws into main over a leftover file would be worse than the +leftover file. + +## Error handling + +Unchanged in principle: every failure resolves to **no crown** rather than a wrong crown. A +missing directory, an unreadable file, a filename that is not a number, an unparseable word and a +dead pid are all simply absent from the reduction. + +Injected seams for testing: `now()` (already present) and `isAlive(pid)`, so the unit tests need +no real processes and no sleeping. + +## Non-goals + +- **Showing how many sessions.** Loudest-wins reports the condition, not the queue depth. A count + needs a second element and a numeral legible at 0.5× pet scale, which is about 5px tall. +- **Showing which session.** No project name, no hover detail. +- **Changing the crown art, the frame seam, or the renderer.** Nothing outside the state source. + +## Testing + +- Reduction: every ordering of waiting/running/idle/none across several sessions. +- Liveness: a dead pid is ignored, and its file is unlinked. +- Pid reuse: a live pid with an ancient mtime is ignored. +- Green decay: green older than the window is dropped; red and gold of the same age are kept. +- The waiting-prompt regression: a `waiting` file far older than the old 15-minute TTL still + shows red while its pid lives. +- Junk: non-numeric filenames, empty files, unknown words, a missing directory. +- Manual: two terminals, one made to wait, confirm red while the other runs. From e30fe3b6b4002c57460b7b61617587493ef64d0d Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 11:11:26 +0530 Subject: [PATCH 11/12] docs: implementation plan for the multi-session crown Four tasks, only one of which touches the app: the state source reads a directory of per-session files and reduces them by loudest wins. Task 2 is recorded as an expected no-op, verified rather than assumed -- the app-shell call site passes no option this changes. Co-Authored-By: Claude Opus 5 (1M context) --- .../plans/2026-09-04-multi-session-crown.md | 820 ++++++++++++++++++ 1 file changed, 820 insertions(+) create mode 100644 docs/superpowers/plans/2026-09-04-multi-session-crown.md diff --git a/docs/superpowers/plans/2026-09-04-multi-session-crown.md b/docs/superpowers/plans/2026-09-04-multi-session-crown.md new file mode 100644 index 0000000..513ca96 --- /dev/null +++ b/docs/superpowers/plans/2026-09-04-multi-session-crown.md @@ -0,0 +1,820 @@ +# Multi-Session Crown Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Make the crown report the loudest state across every running Claude Code session instead of whichever one moved last. + +**Architecture:** Each session's hooks write `~/.argos/sessions/$PPID`. The state source reads the directory, drops sessions whose pid is dead and greens that have expired, and reduces the rest by `waiting > running > idle`. Nothing outside `claude-state-source.ts` changes. + +**Tech Stack:** TypeScript, Node builtins only, vitest. No new dependencies. + +## Global Constraints + +- **Runtime dependencies stay exactly `["zod"]`.** Asserted by `tests/renderer/discipline.spec.ts`. +- **No source file may contain the words `plugin`, `plugins`, `marketplace`, `catalog`, `lan-`, `lease` or `leases` in code.** +- **Tests are Electron-free** (`vitest.config.ts` runs the `node` environment) and must not depend on real processes, real sleeping, or the developer's own `~/.argos`. +- **`PetFrame.claudeState` keeps its four values** — `none | waiting | running | idle`. If this plan makes you change the frame schema, the aggregation has leaked out of the state source and something is wrong. +- Platform target: **macOS**. `process.kill(pid, 0)` behaves the same on Linux; Windows is unverified either way. +- Tests live at `tests/**/*.spec.ts`. Run with `pnpm test`. `pnpm` is not installed globally on the dev machine — use `corepack pnpm`, or put a shim on `PATH` with `corepack enable --install-directory pnpm`. + +## File Structure + +**Modified:** + +- `apps/desktop/src/claude/claude-state-source.ts` — the whole change. Gains a directory read, a liveness check, green expiry, the reduction, and pruning. Grows from ~130 to ~200 lines, which is still one responsibility: *how the state arrives*. +- `tests/claude/claude-state-source.spec.ts` — rewritten around a session directory. +- `docs/CLAUDE-CODE.md` — new hook block, new limits. +- `~/.claude/settings.json` — the user's hooks (Task 4, done by hand with a backup). + +**Not modified, deliberately:** `pet-frame.ts`, `pet-controller.ts`, `pet-window.ts`, `app-shell.ts`, the renderer, the crown art and the generators. The aggregation is invisible above `current()`. + +--- + +### Task 1: Read a directory of sessions and reduce it + +**Files:** +- Modify: `apps/desktop/src/claude/claude-state-source.ts` +- Modify: `tests/claude/claude-state-source.spec.ts` + +**Interfaces:** +- Consumes: `CLAUDE_STATES`, `ClaudeState` from `pet-frame.ts` (unchanged). +- Produces: + - `defaultClaudeSessionDir(): string` — replaces `defaultClaudeStateFile()`. + - `ClaudeStateSourceOptions` gains `dir?: string`, `isAlive?: (pid: number) => boolean`, `greenTtlMs?: number`; **loses** `file`. + - `GREEN_TTL_MS`, `SESSION_MAX_AGE_MS` exported for the tests. + - `ClaudeStateSource` keeps `start` / `stop` / `current` / `refresh` exactly as they are. + +- [ ] **Step 1: Replace the test file** + +The old tests are all about one file, so this replaces rather than extends. Write +`tests/claude/claude-state-source.spec.ts`: + +```ts +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtempSync, rmSync, writeFileSync, utimesSync, existsSync, mkdirSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { + createClaudeStateSource, + GREEN_TTL_MS, + SESSION_MAX_AGE_MS, +} from '../../apps/desktop/src/claude/claude-state-source.js' + +let dir: string + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), 'argos-claude-')) +}) + +afterEach(() => { + rmSync(dir, { recursive: true, force: true }) +}) + +/** Write one session's state. `ageMs` backdates it, for the expiry rules. */ +function session(pid: number, word: string, ageMs = 0): void { + const path = join(dir, String(pid)) + writeFileSync(path, `${word}\n`) + if (ageMs > 0) { + const when = new Date(Date.now() - ageMs) + utimesSync(path, when, when) + } +} + +/** Every pid alive unless the test says otherwise. No real processes are involved. */ +function sourceFor(options: { dead?: number[]; onChange?: (s: string) => void } = {}) { + const dead = new Set(options.dead ?? []) + return createClaudeStateSource({ + dir, + isAlive: (pid) => !dead.has(pid), + onChange: options.onChange, + }) +} + +describe('reducing sessions to one crown', () => { + it('is bare-headed with no sessions at all', () => { + expect(sourceFor().refresh()).toBe('none') + }) + + it('is bare-headed when the directory does not exist', () => { + const source = createClaudeStateSource({ dir: join(dir, 'nope'), isAlive: () => true }) + expect(source.refresh()).toBe('none') + }) + + it.each(['waiting', 'running', 'idle'])('reports a lone %s session', (word) => { + session(1, word) + expect(sourceFor().refresh()).toBe(word) + }) + + it('lets waiting beat running, however many are running', () => { + // The whole point: the one session that needs a human wins, whichever terminal it is in. + session(1, 'running') + session(2, 'running') + session(3, 'waiting') + expect(sourceFor().refresh()).toBe('waiting') + }) + + it('lets running beat idle', () => { + session(1, 'idle') + session(2, 'running') + expect(sourceFor().refresh()).toBe('running') + }) + + it('does not care what order the sessions are read in', () => { + session(9, 'idle') + session(2, 'waiting') + session(40, 'running') + expect(sourceFor().refresh()).toBe('waiting') + }) +}) + +describe('liveness', () => { + it('ignores a session whose process is gone', () => { + session(1, 'waiting') + session(2, 'running') + expect(sourceFor({ dead: [1] }).refresh()).toBe('running') + }) + + it('is bare-headed when every session is dead', () => { + session(1, 'waiting') + expect(sourceFor({ dead: [1] }).refresh()).toBe('none') + }) + + it('deletes the dead session file rather than reading it forever', () => { + session(1, 'waiting') + sourceFor({ dead: [1] }).refresh() + expect(existsSync(join(dir, '1'))).toBe(false) + }) + + it('keeps a live session file', () => { + session(1, 'waiting') + sourceFor().refresh() + expect(existsSync(join(dir, '1'))).toBe(true) + }) + + it('ignores an ancient file even when something now holds that pid', () => { + // A dead session's file plus a recycled pid would otherwise read as alive forever. + session(1, 'waiting', SESSION_MAX_AGE_MS + 60_000) + expect(sourceFor().refresh()).toBe('none') + }) +}) + +describe('green decay', () => { + it('drops green once it has gone stale', () => { + // Green means "just finished, come look". A signal that is always on is not a signal. + session(1, 'idle', GREEN_TTL_MS + 60_000) + expect(sourceFor().refresh()).toBe('none') + }) + + it('keeps green inside the window', () => { + session(1, 'idle', Math.floor(GREEN_TTL_MS / 2)) + expect(sourceFor().refresh()).toBe('idle') + }) + + it('does not decay waiting, however long the prompt goes unanswered', () => { + // The shipped single-session version dropped the red crown after 15 minutes, because a + // session sitting at a permission prompt never touches its file while it waits. That is + // exactly when the crown matters most. + session(1, 'waiting', GREEN_TTL_MS * 10) + expect(sourceFor().refresh()).toBe('waiting') + }) + + it('does not decay running', () => { + session(1, 'running', GREEN_TTL_MS * 10) + expect(sourceFor().refresh()).toBe('running') + }) + + it('still finds a waiting session behind a decayed green', () => { + session(1, 'idle', GREEN_TTL_MS + 60_000) + session(2, 'waiting') + expect(sourceFor().refresh()).toBe('waiting') + }) +}) + +describe('junk in the session directory', () => { + it('ignores a filename that is not a pid', () => { + writeFileSync(join(dir, 'claude-state'), 'waiting') + writeFileSync(join(dir, '.DS_Store'), 'waiting') + expect(sourceFor().refresh()).toBe('none') + }) + + it('ignores a subdirectory', () => { + mkdirSync(join(dir, '123')) + expect(sourceFor().refresh()).toBe('none') + }) + + it('ignores an empty file and an unknown word', () => { + session(1, '') + session(2, 'thinking') + expect(sourceFor().refresh()).toBe('none') + }) + + it('ignores a session claiming none', () => { + session(1, 'none') + session(2, 'running') + expect(sourceFor().refresh()).toBe('running') + }) +}) + +describe('change reporting', () => { + it('fires onChange once per distinct result, not once per read', () => { + const seen: string[] = [] + const source = sourceFor({ onChange: (s) => seen.push(s) }) + session(1, 'running') + source.refresh() + source.refresh() + session(2, 'running') + source.refresh() + session(3, 'waiting') + source.refresh() + expect(seen).toEqual(['running', 'waiting']) + }) + + it('exposes the last result through current() without touching the disk', () => { + session(1, 'running') + const source = sourceFor() + source.refresh() + rmSync(join(dir, '1')) + expect(source.current()).toBe('running') + }) + + it('start() then stop() leaves no live handles', () => { + const source = sourceFor() + source.start() + expect(() => source.stop()).not.toThrow() + expect(() => source.stop()).not.toThrow() + }) + + it('creates the session directory on start so the watch has a target', () => { + const nested = join(dir, 'made-by-start') + const source = createClaudeStateSource({ dir: nested, isAlive: () => true }) + source.start() + source.stop() + expect(existsSync(nested)).toBe(true) + }) +}) +``` + +- [ ] **Step 2: Run the tests and watch them fail** + +```bash +corepack pnpm test -- tests/claude/claude-state-source.spec.ts +``` + +Expected: the file fails to load — `GREEN_TTL_MS` and `SESSION_MAX_AGE_MS` are not exported, and +`createClaudeStateSource` has no `dir` option. + +- [ ] **Step 3: Rewrite the state source** + +Replace the whole body of `apps/desktop/src/claude/claude-state-source.ts`: + +```ts +/** + * Claude Code's state, read off the files its hooks write — one per session. + * + * Each session writes `/`, where the pid is the hook's `$PPID`: a hook command's + * parent process is that session's own `claude` CLI process. That keeps the hook a one-liner + * with no `jq` and no JSON parsing — the property that made this transport worth having — and + * hands us a liveness handle for free. + * + * The many sessions are reduced to one crown by "loudest wins", because the only question the + * pet needs to answer at a glance is whether anything needs a human, not which terminal it is in. + * + * No Electron import. This module is the one place that knows how the state arrives, which is + * why going from one session to many touches nothing else. + */ + +import { mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, watch, type FSWatcher } from 'node:fs' +import { homedir } from 'node:os' +import { join } from 'node:path' +import { CLAUDE_STATES, type ClaudeState } from '../pet-frame.js' + +/** + * How long a finished session keeps its green crown. + * + * Green means "just finished, come look", and a signal that is always on is not a signal — + * without this, any long-lived session parks a green crown on the pet all day. Red and gold + * describe a live condition and do not decay; green describes a moment, and moments pass. + */ +export const GREEN_TTL_MS = 5 * 60_000 + +/** + * The ceiling on a session file's age, whatever its pid says. + * + * Liveness is `kill(pid, 0)`, not a timeout, so this is not the staleness guard — it is the + * backstop against pid reuse. A dead session's leftover file plus a recycled pid would otherwise + * read as alive forever. Long enough that a real session is never mistaken for a recycled one. + */ +export const SESSION_MAX_AGE_MS = 12 * 60 * 60_000 + +/** How often to re-read regardless of the watch. See `start()`. */ +const DEFAULT_POLL_MS = 5_000 + +/** Loudest first. The reduction is "the first of these any session is in". */ +const BY_LOUDNESS: readonly ClaudeState[] = ['waiting', 'running', 'idle'] + +export function defaultClaudeSessionDir(): string { + return process.env.ARGOS_CLAUDE_SESSION_DIR ?? join(homedir(), '.argos', 'sessions') +} + +/** + * Is this process still running? + * + * Signal 0 runs the existence and permission checks without delivering anything. `ESRCH` means + * the process is gone; `EPERM` means it exists but belongs to someone else, which still counts + * as alive. + */ +function processIsAlive(pid: number): boolean { + try { + process.kill(pid, 0) + return true + } catch (error) { + return (error as NodeJS.ErrnoException).code === 'EPERM' + } +} + +export interface ClaudeStateSourceOptions { + /** Defaults to `defaultClaudeSessionDir()`. */ + dir?: string + /** Injected so tests can drive expiry without waiting. */ + now?: () => number + /** Injected so tests need no real processes. */ + isAlive?: (pid: number) => boolean + pollMs?: number + greenTtlMs?: number + onChange?: (state: ClaudeState) => void + log?: (message: string, meta?: unknown) => void +} + +export interface ClaudeStateSource { + start(): void + stop(): void + /** The last state read. Cheap: no disk access. */ + current(): ClaudeState + /** Re-read now and report a change if there is one. Returns the new state. */ + refresh(): ClaudeState +} + +const KNOWN = new Set(CLAUDE_STATES) + +export function createClaudeStateSource( + options: ClaudeStateSourceOptions = {}, +): ClaudeStateSource { + const dir = options.dir ?? defaultClaudeSessionDir() + const now = options.now ?? Date.now + const isAlive = options.isAlive ?? processIsAlive + const pollMs = options.pollMs ?? DEFAULT_POLL_MS + const greenTtl = options.greenTtlMs ?? GREEN_TTL_MS + const onChange = options.onChange ?? ((): void => {}) + const log = options.log ?? ((): void => {}) + + let state: ClaudeState = 'none' + let watcher: FSWatcher | null = null + let timer: NodeJS.Timeout | null = null + + /** One session's contribution, or `none` if it does not get a vote. */ + const readSession = (name: string, nowMs: number): ClaudeState => { + // A pid, or it is not ours: an editor's dotfile, a leftover from the single-session + // version, a directory. Anything unrecognised simply does not vote. + if (!/^\d+$/.test(name)) return 'none' + const pid = Number(name) + const path = join(dir, name) + + let raw: string + let mtimeMs: number + try { + const stat = statSync(path) + if (!stat.isFile()) return 'none' + mtimeMs = stat.mtimeMs + raw = readFileSync(path, 'utf8') + } catch { + return 'none' + } + + const age = nowMs - mtimeMs + if (age > SESSION_MAX_AGE_MS) return 'none' + + if (!isAlive(pid)) { + // Ctrl+C and closed terminals never fire SessionEnd. Drop the file as we find it, or the + // directory grows by one per session forever. + try { + unlinkSync(path) + } catch { + // Already gone, or not ours to remove. It reads as dead either way. + } + return 'none' + } + + const word = raw.trim().toLowerCase() + if (!KNOWN.has(word)) return 'none' + if (word === 'idle' && age > greenTtl) return 'none' + return word as ClaudeState + } + + const read = (): ClaudeState => { + let names: string[] + try { + names = readdirSync(dir) + } catch { + // No directory yet: Argos started before any session did. + return 'none' + } + + const nowMs = now() + const seen = new Set() + for (const name of names) seen.add(readSession(name, nowMs)) + return BY_LOUDNESS.find((candidate) => seen.has(candidate)) ?? 'none' + } + + const refresh = (): ClaudeState => { + const next = read() + if (next !== state) { + state = next + onChange(state) + } + return state + } + + return { + current: () => state, + refresh, + + start(): void { + // Make the directory ourselves so the watch has a target from the first launch, rather + // than silently doing nothing until the first hook happens to create it. + try { + mkdirSync(dir, { recursive: true }) + } catch (error) { + log('claude-state: could not create the session directory', error) + } + + refresh() + + try { + watcher = watch(dir, { persistent: false }, () => { + refresh() + }) + } catch (error) { + log('claude-state: session watch unavailable, polling only', error) + } + + // Backstop, and the only thing that expires a green crown or notices a process dying: + // neither writes to the directory, so neither produces a watch event. + timer = setInterval(refresh, pollMs) + timer.unref?.() + }, + + stop(): void { + watcher?.close() + watcher = null + if (timer) clearInterval(timer) + timer = null + }, + } +} +``` + +- [ ] **Step 4: Run the tests and watch them pass** + +```bash +corepack pnpm test -- tests/claude/claude-state-source.spec.ts +``` + +Expected: PASS, 26 tests. + +- [ ] **Step 5: Typecheck** + +```bash +corepack pnpm typecheck +``` + +Expected: a single error in `app-shell.ts` if it still passes `file:`. It does not — it passes +only `log` and `onChange` — so expect this to be clean. If it is not, the call site is using an +option this task removed; fix it there and note it. + +- [ ] **Step 6: Run the whole suite** + +```bash +corepack pnpm test +``` + +Expected: PASS. No test outside `tests/claude/` should even notice this change — if one does, the +aggregation has leaked past `current()`. + +- [ ] **Step 7: Commit** + +```bash +git add apps/desktop/src/claude/claude-state-source.ts tests/claude/claude-state-source.spec.ts +git commit -m "feat: aggregate every Claude Code session into one crown + +One file per session at ~/.argos/sessions/, reduced by loudest +wins: any session waiting turns the crown red whichever terminal it is +in, which is the only question the pet needs to answer at a glance. + +The pid comes from the hook's \$PPID -- a hook command's parent is that +session's own claude process -- so the hook stays a one-liner with no jq +and no JSON parsing, and we get a liveness handle for free. + +That handle fixes a real defect. Staleness was a 15-minute mtime TTL, +and a session sitting at a permission prompt never touches its file +while it waits, so the red crown silently vanished after 15 minutes of +waiting -- exactly when it mattered most. kill(pid, 0) replaces the +guess; the mtime ceiling is now only a backstop against pid reuse. + +Green expires after five minutes because it means 'just finished, come +look'. Red and gold describe a live condition and do not decay." +``` + +--- + +### Task 2: Point the app at the session directory + +**Files:** +- Modify: `apps/desktop/src/main/app-shell.ts` + +**Interfaces:** +- Consumes: `createClaudeStateSource` from Task 1. +- Produces: nothing. + +- [ ] **Step 1: Check whether anything needs changing at all** + +```bash +grep -n "createClaudeStateSource" -A 8 apps/desktop/src/main/app-shell.ts +``` + +The call passes only `log` and `onChange`, both of which survive Task 1, so the default +`dir` now resolves to the session directory with no edit. Verified while writing this plan: +`defaultClaudeStateFile` has no callers outside its own module either, so removing it breaks +nothing. **If that grep confirms it, this task +is already done — record that and move to Task 3 rather than inventing a change.** + +- [ ] **Step 2: Confirm by building** + +```bash +corepack pnpm typecheck && corepack pnpm build +``` + +Expected: both clean. + +--- + +### Task 3: New hooks and documentation + +**Files:** +- Modify: `docs/CLAUDE-CODE.md` + +**Interfaces:** +- Consumes: the session directory layout from Task 1. +- Produces: the hook block Task 4 installs. + +- [ ] **Step 1: Replace the hook block** + +The state path changes and every command gains `$PPID`. `mkdir -p` stays so the hooks work +whether or not Argos has ever run. Replace the JSON block in `docs/CLAUDE-CODE.md` with: + +```json +{ + "hooks": { + "Notification": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos/sessions && echo waiting > ~/.argos/sessions/$PPID", + "timeout": 5 + } + ] + } + ], + "UserPromptSubmit": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos/sessions && echo running > ~/.argos/sessions/$PPID", + "timeout": 5 + } + ] + } + ], + "PreToolUse": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos/sessions && echo running > ~/.argos/sessions/$PPID", + "timeout": 5 + } + ] + } + ], + "PostToolUse": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos/sessions && echo running > ~/.argos/sessions/$PPID", + "timeout": 5 + } + ] + } + ], + "Stop": [ + { + "hooks": [ + { + "type": "command", + "command": "mkdir -p ~/.argos/sessions && echo idle > ~/.argos/sessions/$PPID", + "timeout": 5 + } + ] + } + ], + "SessionEnd": [ + { + "hooks": [{ "type": "command", "command": "rm -f ~/.argos/sessions/$PPID", "timeout": 5 }] + } + ] + } +} +``` + +- [ ] **Step 2: Explain the pid, and rewrite the testing and limits sections** + +Replace the "Testing it without Claude" and "Limits" sections with: + +````markdown +`$PPID` is the session: a hook command's parent process is that session's own `claude` CLI +process. That is what keeps these one-liners — no `jq`, no JSON parsing — and it is also how +Argos knows a session has gone away without being told. + +## Testing it without Claude + +With Argos running, a made-up pid stands in for a session — any live one will do, and your own +shell is the easiest: + +```bash +mkdir -p ~/.argos/sessions +echo waiting > ~/.argos/sessions/$$ # red crown +echo running > ~/.argos/sessions/$$ # gold crown +echo idle > ~/.argos/sessions/$$ # green crown, for five minutes +rm ~/.argos/sessions/$$ # bare-headed +``` + +Two at once, to see loudest-wins: + +```bash +echo running > ~/.argos/sessions/$$ +echo waiting > ~/.argos/sessions/1 # pid 1 is always alive +# red: one session waiting outvotes one running +rm ~/.argos/sessions/1 +# back to gold +``` + +Point Argos at a different directory with `ARGOS_CLAUDE_SESSION_DIR`. + +## Limits + +- **The crown says what, not how many or which.** Three sessions waiting look like one. +- **Green lasts five minutes.** It means "just finished, come look", not "this session is idle". +- **A pid could in principle be recycled** onto a leftover file. Files older than 12 hours are + ignored for that reason; inside that window a recycled pid would show a stale crown. +- **macOS only, so far.** `process.kill(pid, 0)` behaves the same on Linux; Windows is + unverified, as is the Linux shape-region handling. +```` + +- [ ] **Step 3: Verify and commit** + +```bash +corepack pnpm test && corepack pnpm typecheck +git add docs/CLAUDE-CODE.md +git commit -m "docs: hooks for one file per session + +Every command gains \$PPID, which is the session's own claude process, so +the hooks stay one-liners with no jq. Adds a two-session recipe for +seeing loudest-wins without running a second Claude." +``` + +--- + +### Task 4: Install the new hooks and prove it end to end + +**Files:** +- Modify: `~/.claude/settings.json` (the user's, not the repo's) + +**Interfaces:** +- Consumes: the hook block from Task 3. +- Produces: nothing in the repo. + +- [ ] **Step 1: Back up first** + +```bash +cp ~/.claude/settings.json ~/.claude/settings.json.bak-$(date +%Y%m%d-%H%M%S) +``` + +- [ ] **Step 2: Replace the Argos hooks, keeping everything else** + +The file already contains unrelated hooks (`SessionStart` and a second `UserPromptSubmit` entry). +**Merge — do not overwrite the `hooks` key.** Replace only the groups whose command mentions +`.argos`: + +```bash +python3 - <<'PY' +import json, pathlib, collections + +p = pathlib.Path.home() / '.claude' / 'settings.json' +s = json.loads(p.read_text(), object_pairs_hook=collections.OrderedDict) +hooks = s.setdefault('hooks', collections.OrderedDict()) + +DIR = '~/.argos/sessions' +def cmd(word): + return f'mkdir -p {DIR} && echo {word} > {DIR}/$PPID' + +WORDS = { + 'Notification': cmd('waiting'), + 'UserPromptSubmit': cmd('running'), + 'PreToolUse': cmd('running'), + 'PostToolUse': cmd('running'), + 'Stop': cmd('idle'), + 'SessionEnd': f'rm -f {DIR}/$PPID', +} + +def is_argos(group): + return any('.argos' in h.get('command', '') for h in group.get('hooks', [])) + +for event, command in WORDS.items(): + groups = [g for g in hooks.get(event, []) if not is_argos(g)] + groups.append(collections.OrderedDict([ + ('hooks', [collections.OrderedDict([ + ('type', 'command'), ('command', command), ('timeout', 5), + ])]), + ])) + hooks[event] = groups + +p.write_text(json.dumps(s, indent=2) + '\n') +print('argos hooks replaced') +PY +``` + +- [ ] **Step 3: Verify the merge did not eat anything** + +```bash +jq -e '[.hooks[][].hooks[] | select(.command | test("caveman"))] | length' ~/.claude/settings.json +jq -r '.hooks | to_entries[] | .key as $e | .value[].hooks[] | select(.command | test("argos")) | "\($e): \(.command)"' ~/.claude/settings.json +``` + +Expected: the caveman count is unchanged from before the edit (2 at the time of writing), and +exactly six `argos` lines, one per event, all naming `$PPID`. + +- [ ] **Step 4: Retire the old single-session file** + +```bash +rm -f ~/.argos/claude-state +``` + +Nothing reads it any more — the state source only considers filenames that are entirely digits, +so it would be ignored regardless, but leaving it invites confusion later. + +- [ ] **Step 5: Restart Argos and watch it work** + +```bash +corepack pnpm build +node -e "console.log(require('electron'))" # the binary path +``` + +Launch it with that binary and `apps/desktop` as the argument. Then, in a second terminal: + +```bash +echo waiting > ~/.argos/sessions/$$ +``` + +Expected: a red crown within a second, on top of whatever this Claude session's own hooks are +already writing — which is the loudest-wins reduction working on two real sessions. + +- [ ] **Step 6: Prove the fix that motivated the liveness change** + +Backdate a waiting session well past the old 15-minute TTL and confirm the crown stays red: + +```bash +echo waiting > ~/.argos/sessions/$$ +touch -A -003000 ~/.argos/sessions/$$ # 30 minutes ago +``` + +Expected: still red. On the shipped single-session version this went bare-headed. + +- [ ] **Step 7: Clean up** + +```bash +rm -f ~/.argos/sessions/$$ +``` + +--- + +## Done when + +- `corepack pnpm test`, `corepack pnpm typecheck` and `corepack pnpm build` are all clean. +- One session waiting and two running shows red. +- Killing a waiting session with `Ctrl+C` clears its crown without a `SessionEnd`, and its file + disappears from `~/.argos/sessions/`. +- A 30-minute-old waiting session still shows red. +- A finished session's green is gone five minutes later, while the session stays alive. +- Nothing outside `claude-state-source.ts` changed in the app. From c654142b1542e74392ce7f55cdcdfa3dd2bcabf9 Mon Sep 17 00:00:00 2001 From: Yedhu Krishnan Date: Fri, 4 Sep 2026 11:18:31 +0530 Subject: [PATCH 12/12] docs: a full guide to the Claude Code status crown Rewrites docs/CLAUDE-CODE.md from a setup snippet into something someone can pick up cold: what it does, what it needs (nothing beyond a shell -- no jq, no daemon, no port), how the hook-to-file-to-crown mechanism works, how to integrate it, how to verify the transport before blaming the hooks, a troubleshooting table, and where the code lives. States the current limits plainly rather than leaving them to be discovered: one session only, a red crown that expires after 15 minutes of waiting, and green that never expires -- each linked to the spec and plan that fix it. Co-Authored-By: Claude Opus 5 (1M context) --- README.md | 2 +- docs/CLAUDE-CODE.md | 214 +++++++++++++++++++++++++++++++++++--------- 2 files changed, 172 insertions(+), 44 deletions(-) diff --git a/README.md b/README.md index 4458c8d..5c0dd18 100644 --- a/README.md +++ b/README.md @@ -261,7 +261,7 @@ made every install think a phantom `0.6.0` was available. | [docs/VERIFICATION.md](docs/VERIFICATION.md) | The screenshot loop, and **what is not verified** | | [DECISIONS.md](DECISIONS.md) | Every deviation from the brief, the issue, or openpets — with reasons | | [docs/ASSETS.md](docs/ASSETS.md) | Swapping the art with no code changes | -| [docs/CLAUDE-CODE.md](docs/CLAUDE-CODE.md) | Wiring Claude Code's state to a coloured cap on the pet | +| [docs/CLAUDE-CODE.md](docs/CLAUDE-CODE.md) | The Claude Code status crown — what it does, what you need, how to wire it up | | [docs/PROMPT.md](docs/PROMPT.md) | The implementation brief this was built from, errors corrected in place | | [SECURITY.md](SECURITY.md) | Reporting a vulnerability | | [THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md) | openpets (MIT), Noto Color Emoji (OFL 1.1 / Apache-2.0) | diff --git a/docs/CLAUDE-CODE.md b/docs/CLAUDE-CODE.md index d851ad6..4effc19 100644 --- a/docs/CLAUDE-CODE.md +++ b/docs/CLAUDE-CODE.md @@ -1,51 +1,126 @@ # Claude Code status crown -The pet wears a crown that follows what Claude Code is doing. +The pet wears a crown that tells you what Claude Code is doing, so you can stop switching to the +terminal to find out. -| Colour | Meaning | +| Crown | Meaning | |---|---| -| 🔴 red | Claude Code is waiting for you to confirm something | -| 🟡 amber | Claude Code is working | -| 🟢 green | the task finished; ready for a new one | -| *no cap* | no Claude Code session, or the last signal is over 15 minutes old | - -Single session for now: two at once will fight over the colour. +| 🔴 red | Claude Code is **waiting for you** to confirm something | +| 🟡 gold | Claude Code is **working** | +| 🟢 green | the task **finished**; ready for a new one | +| *bare-headed* | no Claude Code session, or the last signal is stale | | 🔴 waiting | 🟡 running | 🟢 idle | |---|---|---| | ![red crown](demo/crown-waiting.png) | ![gold crown](demo/crown-running.png) | ![green crown](demo/crown-idle.png) | +Red is the one that matters. The other two are ambient. + +--- + +## What you need + +| | | +|---|---| +| **Argos** | running. Any recent build. | +| **Claude Code** | any version with hooks (`~/.claude/settings.json`) | +| **A shell** | `bash` or `zsh`. The hooks are one-liners using `mkdir`, `echo` and `rm`. | +| **Extra tools** | **none.** No `jq`, no Node script, no daemon, no port. | + +macOS is verified. Linux should work — nothing in the mechanism is macOS-specific — but has not +been tested. Windows is unverified. + +--- + ## How it works -Claude Code hooks write one word to `~/.argos/claude-state`. Argos watches that file. That is -the whole mechanism — no port, no daemon, no dependency in either direction. If Argos is not -running, the hooks write a file nothing reads, and nothing breaks. +``` +Claude Code hook ──writes one word──▶ ~/.argos/claude-state + │ + watch + poll + ▼ + Argos (main) + │ one field on the pet frame + ▼ + crown painted on the pet's head +``` + +Claude Code fires a **hook** at each point in its lifecycle. Each hook writes a single word to a +file. Argos watches that file and paints the matching crown. + +That is the whole mechanism. There is no server, no port, no polling of Claude Code, and no +dependency in either direction: -## Setup +- **Argos not running?** The hooks write a file nothing reads. Nothing breaks. +- **Hooks not installed?** Argos watches a file nobody writes. The pet stays bare-headed. -Add this to `~/.claude/settings.json`. If the file already has a `hooks` key, merge into it -rather than replacing it. +The hook is `echo running > file` on purpose. A hook that cannot fail in an interesting way is +worth more than one carrying richer information — it runs on every prompt and every tool call, so +anything slow or fragile there would be felt constantly. + +### Which hook means what + +| Hook | Fires when | Writes | +|---|---|---| +| `Notification` | Claude Code needs a confirmation | `waiting` | +| `UserPromptSubmit` | you send a prompt | `running` | +| `PreToolUse` | before each tool call | `running` | +| `PostToolUse` | after each tool call | `running` | +| `Stop` | Claude Code finishes its turn | `idle` | +| `SessionEnd` | the session closes | *deletes the file* | + +`PreToolUse` is what returns the crown to gold after you approve a prompt — answering a permission +request does not fire `Notification` again. + +### Staleness + +A session killed with `Ctrl+C` never fires `SessionEnd`, so its file lingers. Argos ignores any +state file whose mtime is over 15 minutes old. That is why the file holds only a word: the +timestamp already exists in the filesystem, and putting a second one in the payload would be two +sources of truth for one fact. + +### How the crown is drawn + +Worth knowing if you touch the art or the placement: + +- The crown is a plain `
` with a background image, a sibling of the sprite — not part of the + spritesheet. Colour changes are a stylesheet rule, not a re-rendered sheet. +- It tracks the head **per animation frame**. The pet's bounce is `background-position` stepping, + so the sprite element itself never moves; anything anchored to a per-state constant would hang + still while the character bobs underneath it. The crown gets its own generated keyframes on the + sprite's clock, one `step-end` stop per frame holding that frame's real head anchor. +- Size, art and the gap above the head all come from `scripts/lib/crowns.mjs` through the + generator into `pet.generated.css`. No crown geometry is hand-written. + +--- + +## Integrating it + +### 1. Add the hooks + +Open `~/.claude/settings.json`. **If it already has a `hooks` key, merge into it** — do not replace +it, or you will drop whatever else you had. ```json { "hooks": { - "UserPromptSubmit": [ + "Notification": [ { "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state", + "command": "mkdir -p ~/.argos && echo waiting > ~/.argos/claude-state", "timeout": 5 } ] } ], - "Notification": [ + "UserPromptSubmit": [ { "hooks": [ { "type": "command", - "command": "mkdir -p ~/.argos && echo waiting > ~/.argos/claude-state", + "command": "mkdir -p ~/.argos && echo running > ~/.argos/claude-state", "timeout": 5 } ] @@ -87,11 +162,7 @@ rather than replacing it. "SessionEnd": [ { "hooks": [ - { - "type": "command", - "command": "rm -f ~/.argos/claude-state", - "timeout": 5 - } + { "type": "command", "command": "rm -f ~/.argos/claude-state", "timeout": 5 } ] } ] @@ -99,17 +170,20 @@ rather than replacing it. } ``` -`PreToolUse` is what returns the crown to amber after you approve a prompt — answering a -permission request does not fire `Notification` again. +`PreToolUse` and `PostToolUse` carry no `matcher`, which matches every tool. `"*"` is commonly +written for this, but an omitted matcher is the form the settings schema guarantees. + +### 2. That is it -`PreToolUse` and `PostToolUse` carry no `matcher`, which matches every tool. `"*"` is -commonly written for this, but an omitted matcher is the form the settings schema guarantees. +Claude Code reloads `settings.json` on its own — no restart. Start a task and the crown appears. -Claude Code picks the hooks up without a restart — its settings watcher reloads the file. +Check what is installed at any time with `/hooks`. -## Testing it without Claude +--- -With Argos running: +## Verifying it + +**Test the transport first, without Claude Code in the picture.** With Argos running: ```bash mkdir -p ~/.argos @@ -119,23 +193,77 @@ echo idle > ~/.argos/claude-state # green crown rm ~/.argos/claude-state # bare-headed ``` -The colour changes within a second. This is the integration test worth running first: if these -work and the hooks do not, the hooks are the only remaining variable. +The crown changes within a second. This is the test worth running first: if these work and the +hooks do not, the hooks are the only remaining variable. + +**Then test the hooks.** Give Claude Code a task that needs a permission prompt. Expected: gold +while it works, red at the prompt, gold again once you approve, green when it stops. + +--- + +## Troubleshooting + +| Symptom | Likely cause | +|---|---| +| No crown ever | Argos is not running, or the hooks are not installed. Run the `echo` test above to tell which. | +| `echo` test works, real sessions do not | The hooks are not firing. Check `/hooks`, and check your `settings.json` is valid JSON — an invalid file silently disables **every** setting in it. | +| Crown stuck on one colour | A session died without `SessionEnd`. It clears itself after 15 minutes, or `rm ~/.argos/claude-state` now. | +| Crown flickers gold ↔ green | Expected. Every tool call writes `running` and every turn end writes `idle`. | +| Crown is wrong with two sessions open | Known. See Limits. | + +Point Argos at a different file with `ARGOS_CLAUDE_STATE_FILE`, which is also how the screenshot +harness drives it. -Point Argos at a different file with `ARGOS_CLAUDE_STATE_FILE`. +--- ## Limits -- **One session.** The last hook to fire wins, whichever session it came from. -- **Stale state.** A session killed with `Ctrl+C` never fires `SessionEnd`. Its file lingers, and - the crown stays until the file is 15 minutes old. -- **macOS only, so far.** The Linux shape-region handling is written but unverified. +- **One session.** Every session writes the same file, so the last hook to fire wins. With two + sessions open, the one waiting on you goes invisible the moment the other runs a tool. Fixing + this is designed and planned — see + [the multi-session spec](superpowers/specs/2026-09-04-multi-session-crown-design.md) and + [its plan](superpowers/plans/2026-09-04-multi-session-crown.md). +- **A long wait loses its crown.** Staleness is a 15-minute mtime check, and a session parked at a + permission prompt does not touch its file while it waits. Leave a prompt unanswered for 15 + minutes and the red crown disappears — exactly when it is most wanted. The multi-session work + fixes this too, by using the session's pid as a liveness handle instead of a timeout. +- **Green never expires** while a session is alive, so a finished session parks a green crown + indefinitely. Also addressed in that plan. +- **macOS only, so far.** + +--- + +## Working on it + +```bash +pnpm install +pnpm generate # crowns, sprite CSS, alpha mask +pnpm test +pnpm build && pnpm dev +``` + +`pnpm generate:check` runs in CI and fails if any generated file is stale. + +**To change a crown:** replace its PNG in `pet/crowns-source/` and run `pnpm generate`. The +downsample to worn size, the stylesheet rules and the asset copying all follow. -## The art +**To capture screenshots** of the crown at a given state: -`pet/crowns-source/` holds the full-size crowns; `pnpm generate` downsamples them to the size -they are worn at and writes `pet/crown-*.png`. Nothing hand-places them: the size, the gap above -the head and the per-animation-frame position all come out of `scripts/lib/crowns.mjs` and the -sprite art, into `pet.generated.css`. +```bash +ARGOS_CLAUDE_STATE_FILE=/tmp/state sh -c 'echo waiting > /tmp/state && \ + node scripts/smoke.mjs --name crown --no-composite --state idle --size large' +``` -To change a crown, replace its source PNG and run `pnpm generate`. +The harness skips its window-transparency assertion (A2) while a crown is worn, because the crown +legitimately paints in the ring that assertion requires to be empty. + +### Where the code lives + +| Path | What | +|---|---| +| `apps/desktop/src/claude/claude-state-source.ts` | Owns the state file. The only module that knows how state arrives. | +| `apps/desktop/src/pet-frame.ts` | `claudeState` on the main→renderer seam, plus `frameNeedsCellRegion` | +| `apps/desktop/src/renderer/pet.css` | Parks the crown on the sprite cell. No geometry. | +| `scripts/lib/crowns.mjs` | Crown size, art list, gap. One definition. | +| `scripts/generate-crowns.mjs` | Downsamples the source art | +| `scripts/generate-sprite-css.mjs` | Emits the per-frame crown keyframes |