@ethlete/agent-rules 0.1.0-next.3 → 0.1.0-next.31

package/content/hooks/subagent-model-policy.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: make a subagent's model an explicit choice.
+
+A `Task` call that passes no `model` runs the subagent on the parent session's
+model. A session led by an expensive model therefore spends that model on every
+grep and every file read it delegates, which burns a usage limit in minutes for
+work a small model does just as well.
+
+So this hook gates the tool call rather than only advising:
+
+  * No `model` at all - denied, with the model table returned to the agent. The
+    agent then repeats the call with a model, so the cost of the mistake is one
+    tool call, not a whole subagent run.
+  * `model: fable` - the user is asked. Fable is the right pick for planning,
+    design, cross-cutting review and leading other subagents, and the wrong pick
+    for the twentieth mechanical lookup; only the user knows which this is.
+  * Any other model - allowed silently.
+
+Two cases are left alone, because the tool's `model` would change nothing:
+
+  * `subagent_type: fork`, which always inherits the parent model.
+  * An agent type whose own definition under `.claude/agents/` sets a model.
+
+Can be disabled per machine via a gitignored ethlete-agents.config.local.json at
+the repo root: {"disableHooks": true} or {"disableHooks": ["subagent-model-policy"]}.
+
+Fail-safe: any error exits 0 with no output - the hook must never block work
+because it could not read its own input.
+"""
+
+import json
+import os
+import sys
+
+HOOK_NAME = "subagent-model-policy"
+LOCAL_CONFIG_FILE = "ethlete-agents.config.local.json"
+
+# The tool that spawns a subagent, under both names it has carried.
+SUBAGENT_TOOLS = ("Task", "Agent")
+
+POLICY = """A subagent's model is a choice, not an inheritance. This call passes no `model`, so the subagent \
+would run on the model leading this session - which is how one expensive model ends up doing every small job. \
+Call the tool again with `model` set:
+
+- `haiku` - lookups and small, fully specified jobs: grep, find, read and summarize files or a CI log, run a command and report, a mechanical edit in named files.
+- `sonnet` - scoped work with a clear target: a fix in a named file, a spec, a docs page, a lint cleanup, \
+research that needs reasoning. Sonnet 5.5 is close to opus here and costs less.
+- `opus` - hard work: a bug with no known cause, a change across many files, a review of a diff, and any task \
+sonnet did not finish.
+- `fable` - judgment-heavy work: planning, design, cross-cutting review, leading other subagents. The most \
+expensive of the four, so choosing it asks the user first.
+
+Effort follows the prompt, not a parameter: scope the prompt to one question, name what "done" is, and say \
+"keep it brief" for a lookup. A subagent has the session's context budget on its own transcript and hands back \
+at the critical tier, so size the prompt to one slice that fits; more work means a fresh subagent per slice. An agent type defined under `.claude/agents/` carries its own model and reasoning \
+effort, so a call that names one needs no `model` of its own."""
+
+FABLE_REASON = """This subagent would run on fable, the most expensive model. Approve it where the task is \
+judgment-heavy - planning, design, cross-cutting review, or leading other subagents. Deny it for implementation \
+(`model: "sonnet"` or `"opus"`) or for a lookup or a small, fully specified job (`model: "haiku"`), then repeat the call with that model."""
+
+
+def agent_name(argv):
+    """The --agent value, defaulting to claude — older registrations pass no flag."""
+    for index, arg in enumerate(argv):
+        if arg == "--agent" and index + 1 < len(argv):
+            return argv[index + 1]
+        if arg.startswith("--agent="):
+            return arg.split("=", 1)[1]
+    return "claude"
+
+
+def repo_root(data):
+    """Repo root: the env var the agent sets, else the script's own location, else the cwd.
+
+    The script always lives at <root>/.<agent>/hooks/ethlete/subagent-model-policy.py, so
+    walking four levels up works for any agent that has no project-dir variable of its own.
+    """
+    for variable in ("CLAUDE_PROJECT_DIR", "CODEX_PROJECT_DIR"):
+        value = os.environ.get(variable)
+        if value:
+            return value
+    here = os.path.abspath(__file__)
+    derived = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(here))))
+    if os.path.isfile(os.path.join(derived, LOCAL_CONFIG_FILE)):
+        return derived
+    cwd = data.get("cwd")
+    return cwd if isinstance(cwd, str) and cwd else derived
+
+
+def load_local_config(root):
+    """Parsed ethlete-agents.config.local.json at the repo root, or {} if missing/unreadable."""
+    if not root:
+        return {}
+    try:
+        with open(os.path.join(root, LOCAL_CONFIG_FILE), encoding="utf-8") as f:
+            config = json.load(f)
+    except (OSError, ValueError, AttributeError):
+        return {}
+    return config if isinstance(config, dict) else {}
+
+
+def disabled_locally(config):
+    """True when the local config disables this hook (or all hooks) on this machine."""
+    disabled = config.get("disableHooks")
+    return disabled is True or (isinstance(disabled, list) and HOOK_NAME in disabled)
+
+
+def definition_sets_model(root, subagent_type):
+    """True when a project or user agent definition of that name declares its own model."""
+    if not subagent_type:
+        return False
+    file_name = f"{subagent_type.split(':')[-1]}.md".lower()
+    candidates = []
+    for directory in (
+        os.path.join(root or ".", ".claude", "agents"),
+        os.path.join(os.path.expanduser("~"), ".claude", "agents"),
+    ):
+        try:
+            entries = os.listdir(directory)
+        except OSError:
+            continue
+        candidates += [os.path.join(directory, entry) for entry in entries if entry.lower() == file_name]
+    for path in candidates:
+        try:
+            with open(path, encoding="utf-8") as f:
+                head = f.read(4096)
+        except OSError:
+            continue
+        for line in head.split("\n"):
+            key, separator, value = line.partition(":")
+            if separator and key.strip() == "model" and value.strip():
+                return True
+    return False
+
+
+def decision_for(tool_input, root):
+    """The (decision, reason) this call needs, or None when it may run untouched."""
+    subagent_type = str(tool_input.get("subagent_type") or "").strip().lower()
+    model = str(tool_input.get("model") or "").strip().lower()
+
+    if "fable" in model:
+        return "ask", FABLE_REASON
+    if model:
+        return None
+    if subagent_type == "fork" or definition_sets_model(root, subagent_type):
+        return None
+    return "deny", POLICY
+
+
+def main():
+    if agent_name(sys.argv[1:]) != "claude":
+        return
+
+    data = json.load(sys.stdin)
+
+    if data.get("tool_name") not in SUBAGENT_TOOLS:
+        return
+
+    tool_input = data.get("tool_input")
+
+    if not isinstance(tool_input, dict):
+        return
+
+    root = repo_root(data)
+
+    if disabled_locally(load_local_config(root)):
+        return
+
+    outcome = decision_for(tool_input, root)
+
+    if not outcome:
+        return
+
+    decision, reason = outcome
+    print(
+        json.dumps(
+            {
+                "hookSpecificOutput": {
+                    "hookEventName": "PreToolUse",
+                    "permissionDecision": decision,
+                    "permissionDecisionReason": reason,
+                }
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass
+    sys.exit(0)

package/content/mods/.claude-plugin/marketplace.json

@@ -0,0 +1,11 @@
+{
+  "name": "ethlete",
+  "owner": { "name": "ethlete" },
+  "plugins": [
+    {
+      "name": "e2e-progress",
+      "source": "./plugins/e2e-progress",
+      "description": "Live Playwright e2e progress from a run log, as a status line entry and a pane"
+    }
+  ]
+}

package/content/mods/plugins/e2e-progress/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "e2e-progress",
+  "version": "0.1.0-next.31",
+  "description": "Live Playwright e2e progress from a run log, as a status line entry and a pane",
+  "types": "./types/index.d.ts"
+}

package/content/mods/plugins/e2e-progress/hooks/hooks.json

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

package/content/mods/plugins/e2e-progress/hooks/register.tsx

@@ -0,0 +1,442 @@
+import { atom, read, update } from 'claude-code';
+import type { EngineInterface, Register, Timer } from 'claude-code';
+
+import type { Progress } from '../types';
+
+const PANE = 'e2e-progress';
+const HANDOFFS = ['.claude/handoffs', '.agents/handoffs'];
+const WORKTREES = '.claude/worktrees';
+const TICK_MS = 5000;
+const STALE_MS = 15_000;
+const HIDE_AFTER_MS = 60_000;
+const MIN_ETA_TESTS = 5;
+const MIN_ETA_MS = 30_000;
+const MAX_CANDIDATES = 12;
+const STALLED_MS = 15 * 60_000;
+const runs = atom({ plugin: 'e2e-progress', key: 'runs' } as const, []);
+const pinnedPath = atom({ plugin: 'e2e-progress', key: 'path' } as const, null);
+
+const count = (text: string, re: RegExp) => (text.match(re) ?? []).length;
+const summary = (text: string, word: string) => {
+  const hit = text.match(new RegExp(`^\\s+(\\d+) ${word}\\b`, 'm'));
+  return hit ? Number(hit[1]) : undefined;
+};
+
+const doneOf = (p: Progress) => p.passed + p.failed + p.skipped;
+
+const FAIL_LINE = /✘\s+\d+\s+\[[^\]]+\]\s+›\s+(\S+?):(\d+):\d+\s+›\s+(.*)$/;
+const TEST_DECLARATION = /\btest(\.\w+)?\(/;
+const indentOf = (line: string) => line.length - line.trimStart().length;
+
+const titleOf = (rest: string) =>
+  (
+    rest
+      .replace(/\s+@\S+.*$/, '')
+      .replace(/\s+\([\d.]+m?s\)$/, '')
+      .split(' › ')
+      .pop() ?? ''
+  ).trim();
+
+const declaresAt = (source: string[], index: number, title: string) => {
+  if (!TEST_DECLARATION.test(source[index] ?? '')) return false;
+  const head = source.slice(index, index + 3).join('\n');
+  return head.includes(title.slice(0, 25)) || head.includes('`');
+};
+
+const callsTestFail = (source: string[], index: number) => {
+  const declaration = source[index] ?? '';
+  if (/\btest\.fail\(/.test(declaration)) return true;
+  const indent = indentOf(declaration);
+  for (const line of source.slice(index + 1)) {
+    if (line.trim() !== '' && indentOf(line) <= indent && !/=>\s*\{\s*$/.test(line)) return false;
+    if (/\btest\.fail\(/.test(line)) return true;
+  }
+  return false;
+};
+
+const sourceCache = new Map<string, string[] | null>();
+
+async function sourceOf($: EngineInterface, path: string) {
+  if (!sourceCache.has(path))
+    sourceCache.set(
+      path,
+      await $.fs.read(path).then(
+        (t) => t.split('\n'),
+        () => null,
+      ),
+    );
+  return sourceCache.get(path) ?? null;
+}
+
+async function rootsFor($: EngineInterface, logPath: string) {
+  const at = Math.max(...HANDOFFS.map((dir) => logPath.indexOf(dir)));
+  const own = at > 0 ? logPath.slice(0, at) : '';
+  const worktrees = await $.fs.list(WORKTREES).catch(() => []);
+  const all = [own, '', ...worktrees.filter((d) => d.kind === 'dir').map((d) => `${WORKTREES}/${d.name}/`)];
+  return [...new Set(all)];
+}
+
+async function expectedFailures($: EngineInterface, logPath: string, text: string) {
+  const expected = new Set<string>();
+  const failLines = text.split('\n').filter((line) => FAIL_LINE.test(line));
+  if (failLines.length === 0) return expected;
+  const roots = await rootsFor($, logPath);
+  for (const line of failLines) {
+    const [, file = '', lineNo = '0', rest = ''] = line.match(FAIL_LINE) ?? [];
+    const index = Number(lineNo) - 1;
+    const title = titleOf(rest);
+    for (const root of roots) {
+      const source = await sourceOf($, `${root}${file}`);
+      if (source === null || !declaresAt(source, index, title)) continue;
+      if (callsTestFail(source, index)) expected.add(line);
+      break;
+    }
+  }
+  return expected;
+}
+
+const parse = (
+  path: string,
+  text: string,
+  expected: Set<string>,
+  mtimeMs: number,
+  nowMs: number,
+  last: Progress | null,
+): Progress => {
+  const isDone = /^\s+\d+ (passed|failed|did not run)\b/m.test(text) || /^EXIT \d+/m.test(text);
+  const lines = text.split('\n');
+  const listFailures = lines
+    .filter((line) => line.includes('✘') && !expected.has(line))
+    .map((line) => line.replace(/^.*?✘\s+\d+\s+\[[^\]]+\]\s+›\s+/, '').replace(/\s+@\S+.*$/, ''));
+  const lineFailures = new Map<string, string>();
+  for (const line of lines) {
+    const hit = line.match(/^\s+(\d+)\) \[[^\]]+\] › (.*)$/);
+    if (hit?.[1] && hit[2]) lineFailures.set(hit[1], hit[2].replace(/\s+@\S+.*$/, '').replace(/\s*─+\s*$/, ''));
+  }
+  const failures = isDone && lineFailures.size > 0 ? [...lineFailures.values()] : listFailures;
+  const started = Math.max(0, ...[...text.matchAll(/^\[(\d+)\/\d+\]/gm)].map((m) => Number(m[1])));
+  const ticks = count(text, /✓/g);
+  const p = {
+    path,
+    total: Number(text.match(/Running (\d+) tests?/)?.[1] ?? 0),
+    passed: summary(text, 'passed') ?? (ticks > 0 ? ticks + expected.size : Math.max(0, started - failures.length)),
+    failed: summary(text, 'failed') ?? failures.length,
+    skipped: summary(text, 'skipped') ?? (ticks > 0 ? count(text, /^\s+-\s+\d+\s/gm) : 0),
+    flaky: summary(text, 'flaky') ?? 0,
+    didNotRun: summary(text, 'did not run') ?? 0,
+    workers: Number(text.match(/Running \d+ tests? using (\d+) workers?/)?.[1] ?? 1),
+    duration: text.match(/^\s+\d+ passed \(([^)]+)\)/m)?.[1],
+    expected: expected.size,
+    isDone,
+    failures,
+    mtimeMs,
+    firstSeenMs: nowMs,
+    firstDone: 0,
+  };
+  const isSameRun =
+    last !== null &&
+    last.path === path &&
+    !last.isDone &&
+    Number.isFinite(last.firstSeenMs) &&
+    Number.isFinite(last.firstDone) &&
+    doneOf(p) >= last.firstDone;
+  return isSameRun
+    ? { ...p, firstSeenMs: last.firstSeenMs, firstDone: last.firstDone }
+    : { ...p, firstDone: doneOf(p) };
+};
+
+const FAILURES_FILE_LINE = /^\[failure-reporter\] Writing failures to (.+)$/m;
+
+type FailureRecord = { test: string; location: string; error?: string; detail?: string | null };
+
+const recordsOf = (text: string): FailureRecord[] =>
+  text.split('\n').flatMap((line) => {
+    if (line.trim() === '') return [];
+    try {
+      const record = JSON.parse(line);
+      return typeof record?.test === 'string' && typeof record?.location === 'string' ? [record] : [];
+    } catch {
+      return [];
+    }
+  });
+
+const firstErrorLine = (error: string | undefined) =>
+  (error ?? '')
+    .split('\n')
+    .find((line) => line.trim() !== '')
+    ?.replace(/^Error:\s*/, '')
+    .trim() ?? '';
+
+const failuresOf = (records: FailureRecord[]) => {
+  const latest = new Map<string, FailureRecord>();
+  for (const record of records) latest.set(`${record.location} › ${record.test}`, record);
+  return [...latest].map(([key, record]) => {
+    const error = firstErrorLine(record.error);
+    const line = error ? `${key} — ${error}` : key;
+    return record.detail ? `${line} (${record.detail})` : line;
+  });
+};
+
+async function withRecords($: EngineInterface, p: Progress, text: string): Promise<Progress> {
+  const file = text.match(FAILURES_FILE_LINE)?.[1]?.trim();
+  if (!file) return p;
+  const records = await $.fs.read(file).then(recordsOf, () => undefined);
+  if (records === undefined) return p;
+  const failures = failuresOf(records);
+  return { ...p, failures, failed: summary(text, 'failed') ?? failures.length };
+}
+
+const remainingMs = (p: Progress, nowMs: number) => {
+  const doneSince = doneOf(p) - p.firstDone;
+  const elapsed = nowMs - p.firstSeenMs;
+  if (p.isDone || doneSince < MIN_ETA_TESTS || elapsed < MIN_ETA_MS) return undefined;
+  return ((p.total - doneOf(p)) / doneSince) * elapsed;
+};
+
+const formatEta = (ms: number | undefined) => {
+  if (ms === undefined) return '';
+  const minutes = Math.round(ms / 60_000);
+  return minutes < 1 ? ' ~<1m left' : ` ~${minutes}m left`;
+};
+
+type LogFile = { path: string; mtimeMs: number };
+
+async function logsUnder($: EngineInterface, dir: string, depth: number): Promise<LogFile[]> {
+  const entries = await $.fs.list(dir).catch(() => []);
+  const files = entries
+    .filter((f) => f.kind === 'file' && f.name.endsWith('.log'))
+    .map((f) => ({ path: `${dir}/${f.name}`, mtimeMs: f.mtimeMs }));
+  if (depth === 0) return files;
+  const nested = await Promise.all(
+    entries.filter((d) => d.kind === 'dir').map((d) => logsUnder($, `${dir}/${d.name}`, depth - 1)),
+  );
+  return [...files, ...nested.flat()];
+}
+
+async function baseDirs($: EngineInterface) {
+  const bases = new Set([await $.session.root()]);
+  let dir = await $.session.cwd();
+  for (let up = 0; up <= 3 && dir !== ''; up++) {
+    bases.add(dir);
+    dir = dir.slice(0, dir.lastIndexOf('/'));
+  }
+  return [...bases];
+}
+
+async function handoffDirs($: EngineInterface) {
+  const perBase = await Promise.all(
+    (await baseDirs($)).map(async (base) => {
+      const worktrees = await $.fs.list(`${base}/${WORKTREES}`).catch(() => []);
+      const roots = [base, ...worktrees.filter((d) => d.kind === 'dir').map((d) => `${base}/${WORKTREES}/${d.name}`)];
+      return roots.flatMap((root) => HANDOFFS.map((dir) => `${root}/${dir}`));
+    }),
+  );
+  return perBase.flat();
+}
+
+const nameOf = (path: string) => (path.split('/').pop() ?? path).replace(/\.log$/, '');
+
+const isRunLog = (text: string) => /^Running \d+ tests?/m.test(text);
+
+const notRunLogs = new Map<string, number>();
+
+async function candidateLogs($: EngineInterface) {
+  const perDir = await Promise.all((await handoffDirs($)).map((dir) => logsUnder($, dir, 2)));
+  const unique = new Map(perDir.flat().map((log) => [log.path, log]));
+  return [...unique.values()].sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_CANDIDATES);
+}
+
+async function newestLog($: EngineInterface) {
+  for (const log of await candidateLogs($)) {
+    if (isRunLog(await $.fs.read(log.path).catch(() => ''))) return log;
+  }
+  return undefined;
+}
+
+async function pinnedLog($: EngineInterface): Promise<LogFile | undefined> {
+  const pinned = await read($, pinnedPath);
+  if (pinned === null) return undefined;
+  const stat = await $.fs.stat(pinned).catch(() => undefined);
+  const newest = await newestLog($);
+  if (newest !== undefined && newest.path !== pinned && (stat === undefined || newest.mtimeMs > stat.mtimeMs)) {
+    await update($, pinnedPath, () => null);
+    return undefined;
+  }
+  return stat === undefined ? undefined : { path: pinned, mtimeMs: stat.mtimeMs };
+}
+
+const isVisible = (p: Progress, nowMs: number) =>
+  p.isDone ? nowMs - p.mtimeMs <= HIDE_AFTER_MS : nowMs - p.mtimeMs <= STALLED_MS;
+
+let isHidden = false;
+let timer: Timer | undefined;
+let lastTickMs = 0;
+let shownStatus: string | undefined | null = null;
+
+function setStatus($: EngineInterface, text: string | undefined) {
+  if (text === shownStatus) return;
+  shownStatus = text;
+  $.ui.status(text);
+}
+
+const statusOf = (p: Progress, nowMs: number) =>
+  `${nameOf(p.path)} w${p.workers} ${p.isDone ? `done ${p.duration ?? ''}`.trim() : `${doneOf(p)}/${p.total}`} ✓${p.passed} ✘${p.failed}` +
+  `${p.flaky ? ` ~${p.flaky}` : ''}${p.skipped ? ` -${p.skipped}` : ''}${p.didNotRun ? ` ⊘${p.didNotRun}` : ''}${formatEta(remainingMs(p, nowMs))}`;
+
+async function tick($: EngineInterface) {
+  const nowMs = await $.clock.now();
+  const pinned = await pinnedLog($);
+  const logs = pinned ? [pinned] : await candidateLogs($);
+  const last = new Map((await read($, runs)).map((p) => [p.path, p]));
+  const next: Progress[] = [];
+  for (const log of logs) {
+    const previous = last.get(log.path);
+    if (previous?.mtimeMs === log.mtimeMs) {
+      next.push(previous);
+      continue;
+    }
+    if (notRunLogs.get(log.path) === log.mtimeMs) continue;
+    const text = await $.fs.read(log.path).catch(() => '');
+    if (!isRunLog(text)) {
+      notRunLogs.set(log.path, log.mtimeMs);
+      continue;
+    }
+    sourceCache.clear();
+    const parsed = parse(
+      log.path,
+      text,
+      await expectedFailures($, log.path, text),
+      log.mtimeMs,
+      nowMs,
+      previous ?? null,
+    );
+    next.push(await withRecords($, parsed, text));
+  }
+  const visible = next.filter((p) => isVisible(p, nowMs)).sort((a, b) => a.path.localeCompare(b.path));
+  await update($, runs, () => visible);
+
+  if (visible.length === 0) {
+    setStatus($, undefined);
+    if (!isHidden) {
+      isHidden = true;
+      await $.ui.close({ id: PANE }).catch(() => undefined);
+    }
+    return;
+  }
+
+  isHidden = false;
+  setStatus($, `e2e ${visible.map((p) => statusOf(p, nowMs)).join('  │  ')}`);
+}
+
+async function run($: EngineInterface) {
+  lastTickMs = await $.clock.now();
+  try {
+    await tick($);
+  } catch (error) {
+    setStatus($, `e2e-progress failed: ${String(error)}`);
+  }
+}
+
+function start($: EngineInterface) {
+  timer?.cancel();
+  timer = $.clock.every(TICK_MS, () => run($));
+}
+
+async function revive($: EngineInterface) {
+  if ((await $.clock.now()) - lastTickMs < STALE_MS) return;
+  start($);
+  await run($);
+}
+
+export const register: Register = (on) => {
+  on('session.start', async ($, e, next) => {
+    await $.command.register({
+      name: 'e2e',
+      description:
+        'Show e2e run progress. Optional arg: a log path to pin; "auto" removes the pin; "off" clears the status',
+    });
+    start($);
+    return next(e);
+  });
+
+  on('prompt.submit', async ($, e, next) => {
+    await revive($);
+    return next(e);
+  });
+
+  on('tool.call', async ($, e, next) => {
+    await revive($);
+    return next(e);
+  });
+
+  on('turn.complete', async ($, e, next) => {
+    await revive($);
+    return next(e);
+  });
+
+  on('command.run', { command: 'e2e' }, async ($, e) => {
+    const arg = e.args.trim();
+    if (arg === 'off') {
+      setStatus($, undefined);
+      return { text: 'e2e status cleared until the log changes.' };
+    }
+    if (arg === 'auto') {
+      await update($, pinnedPath, () => null);
+      start($);
+      await run($);
+      return { text: `Pin removed. Watching the newest logs under ${HANDOFFS.join(' and ')}.` };
+    }
+    if (arg !== '') await update($, pinnedPath, () => arg);
+    start($);
+    await $.ui.open({ id: PANE, title: 'E2E progress' });
+    return { text: arg ? `Watching ${arg}.` : 'E2E progress pane opened.' };
+  });
+
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const { Box, Text } = $.ui.resolve(e);
+    const shown = await read($, runs);
+    if (shown.length === 0)
+      return (
+        <Text dimColor>
+          No active run log under {HANDOFFS.join(' or ')}, also in {WORKTREES}/*.
+        </Text>
+      );
+
+    const nowMs = await $.clock.now();
+    const room = Math.max(1, Math.floor(((e.viewport?.rows ?? 24) - 6 * shown.length) / shown.length));
+    return (
+      <Box flexDirection="column">
+        {shown.map((p) => {
+          const done = doneOf(p);
+          return (
+            <Box flexDirection="column" marginBottom={1}>
+              <Text bold>
+                {nameOf(p.path)} <Text dimColor>· {p.workers} workers</Text>
+              </Text>
+              <Text dimColor wrap="truncate-start">
+                {p.path}
+              </Text>
+              <Text>
+                {p.isDone ? `finished in ${p.duration ?? '?'}` : `${done} / ${p.total}`}
+                {p.total > 0 && !p.isDone ? ` (${Math.round((done / p.total) * 100)}%)` : ''}
+                {formatEta(remainingMs(p, nowMs))}
+              </Text>
+              <Text>
+                <Text color="green">✓ {p.passed}</Text> <Text color="red">✘ {p.failed}</Text>{' '}
+                <Text dimColor>- {p.skipped} skipped</Text>
+                {p.didNotRun > 0 ? <Text color="yellow"> ⊘ {p.didNotRun} did not run</Text> : ''}
+                {p.flaky > 0 ? <Text color="yellow"> ~ {p.flaky} flaky</Text> : ''}
+              </Text>
+              {p.expected > 0 && <Text dimColor>{p.expected} expected failures (test.fail) counted as passed</Text>}
+              {p.failures.slice(-room).map((f) => (
+                <Text color="red" wrap="truncate-end">
+                  ✘ {f}
+                </Text>
+              ))}
+            </Box>
+          );
+        })}
+      </Box>
+    );
+  });
+};

package/content/mods/plugins/e2e-progress/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.claude-plugin/types/tsconfig.json"
+}

package/content/mods/plugins/e2e-progress/types/index.d.ts

@@ -0,0 +1,23 @@
+export type Progress = {
+  path: string;
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  flaky: number;
+  didNotRun: number;
+  workers: number;
+  duration: string | undefined;
+  expected: number;
+  isDone: boolean;
+  failures: string[];
+  mtimeMs: number;
+  firstSeenMs: number;
+  firstDone: number;
+};
+
+declare module 'claude-code' {
+  interface PluginState {
+    'e2e-progress': { runs: Progress[]; path: string | null };
+  }
+}