@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dist/setup.js

@@ -0,0 +1,264 @@
+// `unharness setup`: detect installed agents, install/remove sync hooks, configure profiles, install the skills.
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync, realpathSync, readdirSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { spawn, spawnSync } from 'node:child_process';
+import { claudeDir } from "./adapters/claude-code.js";
+import { codexDir } from "./adapters/codex.js";
+import { configFile, expand, loadConfig, saveConfig } from "./profiles.js";
+export const MARKER = 'unharness-hook';
+// legacy: hooks installed under the old name (agentlens) count as ours, so setup replaces them and --uninstall
+// removes them. Can be dropped once nobody has the old hooks installed.
+const LEGACY_MARKER = 'agentlens-hook';
+const isOurs = (command) => !!command && (command.includes(MARKER) || command.includes(LEGACY_MARKER));
+export function hasHook(f, event) {
+    return !!f.hooks?.[event]?.some((g) => g.hooks?.some((h) => isOurs(h.command)));
+}
+export function addHook(f, event, command) {
+    const out = removeHook(f, event);
+    out.hooks ??= {};
+    (out.hooks[event] ??= []).push({ hooks: [{ type: 'command', command }] });
+    return out;
+}
+// Removes only our entries; everything else in the file stays as it was.
+export function removeHook(f, event) {
+    const out = structuredClone(f);
+    const groups = out.hooks?.[event];
+    if (!groups)
+        return out;
+    const kept = groups
+        .map((g) => ({ ...g, hooks: g.hooks.filter((h) => !isOurs(h.command)) }))
+        .filter((g) => g.hooks.length);
+    if (kept.length)
+        out.hooks[event] = kept;
+    else
+        delete out.hooks[event];
+    if (!Object.keys(out.hooks).length)
+        delete out.hooks;
+    return out;
+}
+function agents() {
+    const h = homedir();
+    const cc = claudeDir(), cx = codexDir();
+    return [
+        { name: 'Claude Code', detected: existsSync(cc), hook: { file: path.join(cc, 'settings.json'), event: 'SessionEnd' }, skillsDir: path.join(cc, 'skills') },
+        // Codex: Stop (end of each turn), because SessionEnd only fires when the app closes / idles 30 min (VS Code)
+        { name: 'Codex', detected: existsSync(cx), hook: { file: path.join(cx, 'hooks.json'), event: 'Stop' }, skillsDir: path.join(cx, 'skills') },
+        { name: 'opencode', detected: existsSync(path.join(h, '.config', 'opencode')) },
+        { name: 'Pi', detected: existsSync(path.join(h, '.pi')) },
+        { name: 'Gemini CLI', detected: existsSync(path.join(h, '.gemini')) },
+        { name: 'Cursor', detected: existsSync(path.join(h, '.cursor')) },
+    ];
+}
+const readJson = (f) => (existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : {});
+// Hooks hardcode the node and CLI paths (see hookCommand), so a Node upgrade (nvm) or a moved checkout breaks them
+// silently: their output goes to /dev/null. Returns e.g. "missing node (/path)" per broken path, [] when fine.
+export function brokenHookPaths(command) {
+    const m = /^(\S+)\s.*?(\S+)\s+sync\b/.exec(command);
+    if (!m)
+        return [];
+    return [['node', m[1]], ['CLI', m[2]]].filter(([, p]) => !existsSync(p)).map(([what, p]) => `missing ${what} (${p})`);
+}
+function brokenHook(a) {
+    let f;
+    try {
+        f = readJson(a.hook.file);
+    }
+    catch {
+        return [];
+    }
+    const ours = Object.values(f.hooks ?? {}).flat().flatMap((g) => g.hooks ?? []).filter((h) => isOurs(h.command));
+    return [...new Set(ours.flatMap((h) => brokenHookPaths(h.command)))];
+}
+// One line per agent whose installed hook points at a missing path. Cheap: reads two small JSON files.
+export function hookWarnings() {
+    return agents().filter((a) => a.hook).flatMap((a) => {
+        const broken = brokenHook(a);
+        return broken.length ? [`${a.name} hook points at a ${broken.join(' and a ')}; run \`unharness setup\` to fix`] : [];
+    });
+}
+// Called by every sync: refresh the package's skills where an older copy is installed, so a package update reaches
+// the agents. Never installs a skill that isn't there already. Silent; errors are ignored.
+export function updateSkills() {
+    const src = path.join(import.meta.dirname, '..', 'skills');
+    const name = (md) => /^name:\s*(\S+)\s*$/m.exec(md)?.[1];
+    try {
+        for (const a of agents()) {
+            if (!a.skillsDir)
+                continue;
+            for (const s of readdirSync(src)) {
+                const dst = path.join(a.skillsDir, s, 'SKILL.md');
+                if (!existsSync(dst))
+                    continue;
+                const want = readFileSync(path.join(src, s, 'SKILL.md'), 'utf8'), have = readFileSync(dst, 'utf8');
+                if (have !== want && name(have) === name(want))
+                    writeFileSync(dst, want);
+            }
+        }
+    }
+    catch { }
+}
+function writeJson(f, v) {
+    mkdirSync(path.dirname(f), { recursive: true });
+    if (existsSync(f))
+        copyFileSync(f, `${f}.unharness-bak`);
+    writeFileSync(f, JSON.stringify(v, null, 2) + '\n');
+}
+// Absolute paths: hooks run without the user's shell PATH (nvm etc.). Background + silent so the agent never waits.
+function hookCommand() {
+    const bin = realpathSync(process.argv[1]);
+    return `${process.execPath} --disable-warning=ExperimentalWarning ${bin} sync >/dev/null 2>&1 & # ${MARKER}`;
+}
+// Codex skips user hooks until trusted (`/hooks` in the TUI). Do what the TUI does: ask `codex app-server` for each
+// hook's key + current hash (hooks/list) and record ours as trusted in config.toml. Editing the hook untrusts it again.
+async function trustCodexHooks() {
+    const fallback = () => console.log('  ! could not trust the hook automatically: open `codex`, run /hooks and trust the Unharness hook');
+    const hooks = await new Promise((resolve) => {
+        const p = spawn('codex', ['app-server'], { stdio: ['pipe', 'pipe', 'ignore'] });
+        const done = (v) => { clearTimeout(t); p.kill(); resolve(v); };
+        const t = setTimeout(() => done(null), 20_000);
+        p.on('error', () => done(null));
+        let buf = '';
+        p.stdout.on('data', (d) => {
+            buf += d;
+            for (let i; (i = buf.indexOf('\n')) >= 0;) {
+                const line = buf.slice(0, i);
+                buf = buf.slice(i + 1);
+                let m;
+                try {
+                    m = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (m.id === 1)
+                    p.stdin.write(JSON.stringify({ id: 2, method: 'hooks/list', params: { cwds: [homedir()] } }) + '\n');
+                if (m.id === 2)
+                    done(m.result?.data?.flatMap((d) => d.hooks ?? []) ?? null);
+            }
+        });
+        p.stdin.write(JSON.stringify({ id: 1, method: 'initialize', params: { clientInfo: { name: 'unharness', version: '1' } } }) + '\n');
+    });
+    if (!hooks)
+        return fallback();
+    const ours = hooks.filter((h) => h.command?.includes(MARKER) && h.trustStatus !== 'trusted' && h.key && h.currentHash);
+    if (!ours.length)
+        return;
+    const toml = path.join(codexDir(), 'config.toml');
+    const text = existsSync(toml) ? readFileSync(toml, 'utf8') : '';
+    if (existsSync(toml))
+        copyFileSync(toml, `${toml}.unharness-bak`);
+    writeFileSync(toml, text.replace(/\n*$/, '\n') + ours.map((h) => `\n[hooks.state.${JSON.stringify(h.key)}]\ntrusted_hash = ${JSON.stringify(h.currentHash)}\n`).join(''));
+    console.log(`  ✓ trusted in ${toml}`);
+}
+const yes = (a) => /^y/i.test(a);
+export async function setup(v) {
+    if (!v.yes && !process.stdin.isTTY)
+        throw new Error('setup is interactive; run it in a terminal or pass --yes');
+    const rl = v.yes ? null : createInterface({ input: process.stdin, output: process.stdout });
+    const ask = async (q, def) => (rl ? (await rl.question(`${q} [${def}] `)).trim() || def : def);
+    try {
+        const list = agents();
+        console.log('Agents on this machine:');
+        for (const a of list) {
+            const state = !a.detected ? 'not found' : !a.hook ? 'found, not supported yet' : hasHook(readJson(a.hook.file), a.hook.event) ? 'hook installed' : 'no hook';
+            console.log(`  ${a.name.padEnd(12)} ${state}`);
+        }
+        for (const w of hookWarnings())
+            console.log(`  ! ${w}`);
+        console.log();
+        if (process.argv[1]?.includes('/_npx/') && !v.uninstall) {
+            console.log('! running from the npx cache: hooks would point at a temporary copy. Install first: npm i -g @codelionapps/unharness\n');
+            return;
+        }
+        for (const a of list.filter((a) => a.detected && a.hook)) {
+            const { file, event } = a.hook;
+            const f = readJson(file);
+            if (v.uninstall) {
+                if (hasHook(f, event)) {
+                    writeJson(file, removeHook(f, event));
+                    console.log(`✓ removed ${a.name} hook from ${file}`);
+                }
+                continue;
+            }
+            const has = hasHook(f, event), ok = has && !brokenHook(a).length;
+            if (yes(await ask(`${has ? 'Reinstall' : 'Install'} sync hook for ${a.name} (${file})?`, ok ? 'n' : 'Y'))) {
+                writeJson(file, addHook(f, event, hookCommand()));
+                console.log(`✓ ${a.name}: ${event} hook → unharness sync (backup: ${path.basename(file)}.unharness-bak)`);
+                if (a.name === 'Codex')
+                    await trustCodexHooks();
+            }
+        }
+        if (v.uninstall)
+            return;
+        await profiles(ask, !!v.yes);
+        const skillTargets = list.filter((a) => a.detected && a.skillsDir);
+        const skillsSrc = path.join(import.meta.dirname, '..', 'skills');
+        const skills = readdirSync(skillsSrc);
+        if (skillTargets.length && yes(await ask(`Install the Unharness skills (${skills.join(', ')}) for ${skillTargets.map((a) => a.name).join(' + ')}?`, 'Y'))) {
+            for (const a of skillTargets) {
+                // legacy: the old `agentlens` skill is replaced by `unharness`. Can be dropped later.
+                const legacy = path.join(a.skillsDir, 'agentlens');
+                const legacyMd = path.join(legacy, 'SKILL.md');
+                if (existsSync(legacyMd) && /^name:\s*agentlens\s*$/m.test(readFileSync(legacyMd, 'utf8'))) {
+                    rmSync(legacy, { recursive: true, force: true });
+                    console.log(`✓ removed legacy skill ${legacy}`);
+                }
+                for (const s of skills) {
+                    const dst = path.join(a.skillsDir, s, 'SKILL.md');
+                    mkdirSync(path.dirname(dst), { recursive: true });
+                    copyFileSync(path.join(skillsSrc, s, 'SKILL.md'), dst);
+                    console.log(`✓ skill → ${dst}`);
+                }
+            }
+        }
+        if (yes(await ask('Run the first sync now?', 'Y')))
+            spawnSync(process.execPath, ['--disable-warning=ExperimentalWarning', process.argv[1], 'sync'], { stdio: 'inherit' });
+    }
+    finally {
+        rl?.close();
+    }
+}
+// Optional: separate databases per group of projects (e.g. work vs private), routed by directory.
+async function profiles(ask, auto) {
+    const c = loadConfig();
+    if (c.profiles) {
+        console.log(`\nProfiles (${configFile()}):`);
+        for (const [n, p] of Object.entries(c.profiles)) {
+            const dirs = (c.routes ?? []).filter((r) => r.profile === n).map((r) => r.path);
+            console.log(`  ${n.padEnd(10)} ${p.home}${dirs.length ? `  ← ${dirs.join(', ')}` : ''}${c.default === n ? '  (default)' : ''}`);
+        }
+        if (c.default === null)
+            console.log('  sessions outside these directories are not collected');
+        if (!yes(await ask('Change profiles?', 'n')))
+            return;
+    }
+    else if (auto || !yes(await ask('\nKeep separate databases for different projects (e.g. work vs private)?', 'n')))
+        return;
+    const profs = {};
+    const routes = [];
+    for (let i = 0;; i++) {
+        const name = await ask(i === 0 ? 'Profile name' : 'Another profile name (empty to finish)', i === 0 ? 'work' : i === 1 ? 'private' : '');
+        if (!name)
+            break;
+        const home = await ask(`  data dir for "${name}"`, i === 0 ? '~/.unharness' : `~/.unharness-${name}`);
+        profs[name] = { home };
+        const dirs = await ask(`  project directories for "${name}" (comma-separated, empty = none)`, '');
+        for (const d of dirs.split(',').map((s) => s.trim()).filter(Boolean)) {
+            if (!existsSync(expand(d)))
+                console.log(`  ! ${d} does not exist (kept anyway)`);
+            routes.push({ path: d, profile: name });
+        }
+        if (i >= 1 && !yes(await ask('  Add another profile?', 'n')))
+            break;
+    }
+    if (!Object.keys(profs).length)
+        return;
+    const names = Object.keys(profs);
+    const def = await ask(`Profile for sessions outside these directories (${names.join(' / ')} / none)`, names[0]);
+    saveConfig({ ...c, profiles: profs, routes, default: def === 'none' ? null : names.includes(def) ? def : names[0] });
+    console.log(`✓ saved ${configFile()}`);
+    console.log('  Per repo override: put {"profile": "<name>"} (or {"profile": null} to skip) in <repo>/.unharness.json');
+    console.log('  Already imported sessions stay where they are; `unharness sync --rebuild` re-imports everything into the new profiles (asks first, backs up, tags are kept).');
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+// Normalized, harness-agnostic records. Adapters produce these; everything else reads only these.
+// Privacy contract: no field may contain prompt/response/tool content, commands, or absolute paths.
+export const SCHEMA_VERSION = 1;

package/dist/update.js

@@ -0,0 +1,50 @@
+// Version and the once-a-day update notice. The registry check here and the pricing table refresh (pricing.ts) are
+// Unharness's only network calls; neither sends anything about your sessions.
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { home } from "./util.js";
+const REGISTRY = 'https://registry.npmjs.org/@codelionapps%2funharness/latest';
+const DAY = 8.64e7;
+// package.json sits one level above both src/ and dist/
+export const version = () => JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+// a > b for x.y.z versions; a prerelease (x.y.z-tag) is older than its release. Malformed input is never newer.
+// ponytail: prereleases of the same x.y.z compare equal; compare their tags if we ever publish several.
+export function isNewer(a, b) {
+    const parts = (v) => [...v.split('-')[0].split('.').map(Number), v.includes('-') ? 0 : 1];
+    const x = parts(a), y = parts(b);
+    for (let i = 0; i < 4; i++)
+        if (x[i] !== y[i])
+            return x[i] > y[i];
+    return false;
+}
+// The notice line when a newer version is published, else undefined. Checks the registry at most once per 24h
+// (cached in <home>/update-check.json, failures too, so offline use never waits twice a day), with a 1.5 s timeout.
+// Skipped in a source checkout, without a terminal, in CI, and with UNHARNESS_NO_UPDATE_CHECK=1. Never throws.
+export async function updateNotice() {
+    if (!import.meta.url.includes('/node_modules/') || !process.stderr.isTTY || process.env.CI || process.env.UNHARNESS_NO_UPDATE_CHECK === '1')
+        return;
+    try {
+        const f = path.join(home(), 'update-check.json');
+        let c = null;
+        try {
+            c = JSON.parse(readFileSync(f, 'utf8'));
+        }
+        catch { }
+        if (!c || !(Date.now() - c.checkedAt < DAY)) {
+            let latest = c?.latest;
+            try {
+                const r = await fetch(REGISTRY, { signal: AbortSignal.timeout(1500) });
+                if (r.ok)
+                    latest = (await r.json()).version ?? latest;
+            }
+            catch { }
+            c = { checkedAt: Date.now(), latest };
+            mkdirSync(home(), { recursive: true });
+            writeFileSync(f, JSON.stringify(c) + '\n');
+        }
+        const have = version();
+        if (typeof c.latest === 'string' && isNewer(c.latest, have))
+            return `Unharness ${c.latest} is available (you have ${have}): npm i -g @codelionapps/unharness`;
+    }
+    catch { }
+}

package/dist/util.js

@@ -0,0 +1,107 @@
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { hostname, userInfo, homedir } from 'node:os';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+export const OUTSIDE_REPO = '<outside-repo>';
+export const home = () => process.env.UNHARNESS_HOME ?? path.join(homedir(), '.unharness');
+export const sha256 = (s) => createHash('sha256').update(s).digest('hex');
+// ponytail: chars/4 heuristic, swap for a real tokenizer if v2 token breakdown needs precision
+export const estimateTokens = (s) => {
+    if (s == null)
+        return 0;
+    const str = typeof s === 'string' ? s : JSON.stringify(s);
+    return Math.ceil(str.length / 4);
+};
+export const machineId = () => sha256(hostname()).slice(0, 16);
+export const currentUser = () => process.env.UNHARNESS_USER ?? userInfo().username;
+const repoCache = new Map();
+// Repo root + name for a cwd. Name from origin remote, falling back to root dir basename.
+export function repoInfo(cwd) {
+    if (!cwd)
+        return { root: null, name: null };
+    const hit = repoCache.get(cwd);
+    if (hit)
+        return hit;
+    const git = (...args) => {
+        try {
+            return execFileSync('git', ['-C', cwd, ...args], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const root = git('rev-parse', '--show-toplevel');
+    const remote = root ? git('remote', 'get-url', 'origin') : null;
+    // An existing non-git dir (e.g. ~) is not a repo: no name, every path counts as outside. A cwd that no longer
+    // exists (deleted worktree / temp checkout) can't be inspected, so fall back to treating it as the repo root.
+    // ponytail: that fallback can't tell a deleted non-repo dir from a deleted repo.
+    const gone = !root && !existsSync(cwd);
+    const base = root ?? (gone ? cwd : null);
+    const name = remote ? remote.replace(/\.git$/, '').split(/[/:]/).pop() : base && path.basename(base);
+    const info = { root: base, name: name || null };
+    repoCache.set(cwd, info);
+    return info;
+}
+export function repoRelative(p, root, cwd) {
+    if (!p || !root)
+        return OUTSIDE_REPO;
+    const abs = path.resolve(cwd ?? root, p);
+    const rel = path.relative(root, abs);
+    return rel === '' ? '.' : rel.startsWith('..') || path.isAbsolute(rel) ? OUTSIDE_REPO : rel;
+}
+// Server names may contain underscores (mcp__claude_ai_Linear__get_issue): split on the LAST `__`.
+export function mcpServer(toolName) {
+    const m = /^mcp__(.+)__/.exec(toolName);
+    return m ? m[1] : null;
+}
+const KIND = {
+    read: 'read', notebookread: 'read', view: 'read', view_image: 'read', read_file: 'read',
+    edit: 'edit', write: 'edit', multiedit: 'edit', notebookedit: 'edit', apply_patch: 'edit', write_file: 'edit',
+    bash: 'bash', shell: 'bash', shell_command: 'bash', exec_command: 'bash', local_shell: 'bash', container_exec: 'bash', bashoutput: 'bash', write_stdin: 'bash',
+    glob: 'search', grep: 'search', ls: 'search', toolsearch: 'search', list_dir: 'search', grep_files: 'search',
+    webfetch: 'web', websearch: 'web', web_search: 'web', web_fetch: 'web',
+    task: 'task', agent: 'task', spawn_agent: 'task',
+};
+export function toolKind(name) {
+    if (name.startsWith('mcp__'))
+        return 'mcp';
+    return KIND[name.toLowerCase()] ?? 'other';
+}
+export const iso = (v) => new Date(v).toISOString();
+// '7d' | '24h' | '90d' -> ms
+export function parseDuration(s) {
+    const m = /^(\d+)([hdw])$/.exec(s);
+    if (!m)
+        throw new Error(`bad duration: ${s} (use e.g. 24h, 7d, 4w)`);
+    return Number(m[1]) * { h: 3.6e6, d: 8.64e7, w: 6.048e8 }[m[2]];
+}
+// Sum of [start,end] interval union in ms (parallel tool calls overlap).
+export function unionMs(intervals) {
+    const iv = intervals.filter(([a, b]) => b >= a).sort((x, y) => x[0] - y[0]);
+    let total = 0, curA = -Infinity, curB = -Infinity;
+    for (const [a, b] of iv) {
+        if (a > curB) {
+            if (curB > curA)
+                total += curB - curA;
+            curA = a;
+            curB = b;
+        }
+        else
+            curB = Math.max(curB, b);
+    }
+    if (curB > curA)
+        total += curB - curA;
+    return total;
+}
+// Wall time across event timestamps, not counting gaps longer than idleMs (user away).
+export function activeMs(timestamps, idleMs = 5 * 60_000) {
+    const t = [...timestamps].sort((a, b) => a - b);
+    let total = 0;
+    for (let i = 1; i < t.length; i++) {
+        const d = t[i] - t[i - 1];
+        if (d <= idleMs)
+            total += d;
+    }
+    return total;
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@codelionapps/unharness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Local, metadata-only analytics for AI coding agent runs (Claude Code, Codex, eve): cost, tokens, tools, checks, subagents",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodeLionApps/unharness.git"
+  },
+  "homepage": "https://github.com/CodeLionApps/unharness#readme",
+  "bugs": {
+    "url": "https://github.com/CodeLionApps/unharness/issues"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "ai-agents",
+    "analytics",
+    "cost",
+    "tokens"
+  ],
+  "type": "module",
+  "bin": {
+    "unharness": "bin/unharness.js"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "test": "node --test --disable-warning=ExperimentalWarning 'test/**/*.test.ts'",
+    "typecheck": "tsc --noEmit",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/pricing-snapshot.json dist/ && node scripts/build-dashboard.ts",
+    "prepack": "npm run build",
+    "smoke": "npm run build && scripts/smoke-pack.sh"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "next": "^16.4.3",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "typescript": "^5.9.0"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "skills",
+    "dashboard/.next/standalone"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skills/summarize-run/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: summarize-run
+description: Summarize the current agent session with Unharness - cost, tokens, cache hit rate, tool calls and errors, subagents, compactions, duration. Use when the user runs /summarize-run or asks how much this session/conversation has cost or used so far.
+---
+
+Run exactly this (one Bash call):
+
+```
+unharness sync >/dev/null && unharness run "${CLAUDE_CODE_SESSION_ID:-$CODEX_THREAD_ID}"
+```
+
+If neither variable is set, or the run isn't found, say so in one line (Unharness hooks may not be set up: `unharness setup`) and stop.
+
+Reply with a short summary, not the raw output:
+- cost (hypothetical API price) and models
+- tokens: input / output / cache read, cache hit rate
+- active time, number of requests, compactions
+- tool calls and errors (name the noisiest tools), subagents with their cost
+- skills invoked: name, source (user/project/plugin = where it is installed), calls, tokens loaded (or "none")
+- checks (tests/lint/typecheck) if any ran
+
+Up to ~8 lines. Note that the current turn is not included yet.

package/skills/unharness/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: unharness
+description: Set up or query Unharness (local metadata-only analytics of Claude Code / Codex runs - cost, tokens, tools, checks, subagents). Use when the user asks to set up Unharness hooks or profiles, or asks how much their agent sessions cost, how runs compare across models/harnesses/setups, or what happened in a past run.
+---
+
+`unharness` is a CLI on PATH. Never read its SQLite files directly — use the CLI.
+
+- Setup / hooks / work-vs-private profiles: tell the user to run `unharness setup` in their own terminal (it is interactive). It detects installed agents and asks per agent; `--uninstall` removes hooks.
+- Refresh data first: `unharness sync`
+- Questions → commands (add `--profile <name>` if the user mentions a profile):
+  - recent runs: `unharness runs --since 7d` (filters: `--harness`, `--repo`, `--tag`)
+  - one run: `unharness run <id-prefix>`
+  - totals and trend: `unharness report --period 1d|7d|30d|90d`
+  - comparisons: `unharness compare --by harness|setup|tag|model --since 30d`
+  - mark an experiment: `unharness tag <run> exp:<name>`
+  - charts: `unharness dashboard` (http://127.0.0.1:4319; reuses a running instance)
+
+Costs are hypothetical API-price costs. Summarize the numbers; don't paste whole tables unless asked.