claude-agent-ledger 0.4.1 → 0.7.1

package/src/parser.ts

@@ -5,6 +5,9 @@ import type { SessionTurn, TokenUsage } from './types.ts';
 
 const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
 
+// Limit concurrent file reads so we don't exhaust fd on huge setups.
+const CONCURRENCY = 8;
+
 export interface ParseOptions {
 	from?: Date;
 	to?: Date;
@@ -15,16 +18,9 @@ interface LogFile {
 	path: string;
 	projectId: string;
 	subagentType: string | undefined;
+	parentSessionId?: string | undefined; // for subagent logs, the parent session
 }
 
-// Walk the projects directory and yield every JSONL log.
-// Real Claude Code layout (as of 2026-04):
-//   ~/.claude/projects/<encoded-project>/<session-uuid>.jsonl             (main session)
-//   ~/.claude/projects/<encoded-project>/<session-uuid>/subagents/agent-<hash>.jsonl  (subagent)
-//   ~/.claude/projects/<encoded-project>/<session-uuid>/subagents/agent-<hash>.meta.json
-//
-// The .meta.json next to each subagent .jsonl carries { "agentType": "...", "description": "..." }.
-// We read it to attribute the subagent by its real name (e.g. "Reality Checker") rather than an opaque hash.
 export async function* findSessionLogs(
 	projectsDir: string = CLAUDE_PROJECTS_DIR,
 ): AsyncGenerator<LogFile> {
@@ -34,11 +30,22 @@ export async function* findSessionLogs(
 	} catch {
 		return;
 	}
-	for (const project of projects) {
-		yield* walkForJsonl(join(projectsDir, project), project);
+	// Parallelize the project-level walks; collect LogFiles via streaming queue.
+	const walkers = projects.map((project) =>
+		collectWalk(join(projectsDir, project), project),
+	);
+	const settled = await Promise.all(walkers);
+	for (const list of settled) {
+		for (const lf of list) yield lf;
 	}
 }
 
+async function collectWalk(dir: string, projectId: string): Promise<LogFile[]> {
+	const out: LogFile[] = [];
+	for await (const lf of walkForJsonl(dir, projectId)) out.push(lf);
+	return out;
+}
+
 async function* walkForJsonl(dir: string, projectId: string): AsyncGenerator<LogFile> {
 	let entries: string[] = [];
 	try {
@@ -46,6 +53,9 @@ async function* walkForJsonl(dir: string, projectId: string): AsyncGenerator<Log
 	} catch {
 		return;
 	}
+	// If this directory IS named 'subagents', its parent session is one level up.
+	// e.g. .../<session-uuid>/subagents/agent-XXX.jsonl → parent = <session-uuid>
+	const parentSession = basename(dir) === 'subagents' ? basename(dirname(dir)) : undefined;
 	for (const name of entries) {
 		if (name.startsWith('.') || name === 'memory') continue;
 		const full = join(dir, name);
@@ -60,13 +70,18 @@ async function* walkForJsonl(dir: string, projectId: string): AsyncGenerator<Log
 			continue;
 		}
 		if (name.endsWith('.jsonl')) {
-			yield { path: full, projectId, subagentType: await resolveSubagentType(full) };
+			const subagentType = await resolveSubagentType(full);
+			yield {
+				path: full,
+				projectId,
+				subagentType,
+				parentSessionId: parentSession,
+			};
 		}
 	}
 }
 
 async function resolveSubagentType(jsonlPath: string): Promise<string | undefined> {
-	// Subagent logs live under `.../subagents/agent-<hash>.jsonl` with a sibling `.meta.json`.
 	if (basename(dirname(jsonlPath)) !== 'subagents') return undefined;
 	const metaPath = jsonlPath.replace(/\.jsonl$/, '.meta.json');
 	try {
@@ -78,26 +93,51 @@ async function resolveSubagentType(jsonlPath: string): Promise<string | undefine
 	}
 }
 
-// Stream-parse one JSONL file. Skips malformed lines rather than aborting.
+// Streaming line reader — does NOT buffer the whole file.
+// Handles partial lines across chunk boundaries. Skips malformed JSON.
 export async function* parseFile(
 	path: string,
 	subagentType?: string,
 	projectId?: string,
+	parentSessionId?: string,
 ): AsyncGenerator<SessionTurn> {
-	const file = Bun.file(path);
-	const text = await file.text();
 	const sessionId = basename(path).replace('.jsonl', '');
-
-	for (const line of text.split('\n')) {
-		if (!line.trim()) continue;
-		let obj: Record<string, unknown>;
-		try {
-			obj = JSON.parse(line);
-		} catch {
-			continue;
+	const stream = Bun.file(path).stream();
+	const decoder = new TextDecoder('utf-8', { fatal: false });
+	let buffer = '';
+	for await (const chunk of stream) {
+		buffer += decoder.decode(chunk, { stream: true });
+		let nl: number;
+		while ((nl = buffer.indexOf('\n')) !== -1) {
+			const line = buffer.slice(0, nl);
+			buffer = buffer.slice(nl + 1);
+			if (!line.trim()) continue;
+			const turn = tryParseLine(line, sessionId, subagentType, projectId, parentSessionId);
+			if (turn) yield turn;
 		}
-		yield extractTurn(obj, sessionId, subagentType, projectId);
 	}
+	// Flush any trailing partial line.
+	buffer += decoder.decode();
+	if (buffer.trim()) {
+		const turn = tryParseLine(buffer, sessionId, subagentType, projectId, parentSessionId);
+		if (turn) yield turn;
+	}
+}
+
+function tryParseLine(
+	line: string,
+	sessionId: string,
+	subagentType: string | undefined,
+	projectId: string | undefined,
+	parentSessionId: string | undefined,
+): SessionTurn | undefined {
+	let obj: Record<string, unknown>;
+	try {
+		obj = JSON.parse(line);
+	} catch {
+		return undefined;
+	}
+	return extractTurn(obj, sessionId, subagentType, projectId, parentSessionId);
 }
 
 function extractTurn(
@@ -105,14 +145,29 @@ function extractTurn(
 	sessionId: string,
 	subagentType: string | undefined,
 	projectId: string | undefined,
+	parentSessionId: string | undefined,
 ): SessionTurn {
 	const msg = (obj.message ?? {}) as Record<string, unknown>;
 	const usage = (msg.usage ?? undefined) as TokenUsage | undefined;
 	const model = (msg.model ?? undefined) as string | undefined;
-	// If the raw turn carries its own subagentType (our fixture format), prefer it;
-	// otherwise fall back to the directory-derived one.
 	const perTurnSubagent = ((obj.subagentType as string) ?? undefined) || undefined;
 	const perTurnProject = ((obj.projectId as string) ?? undefined) || undefined;
+	const perTurnParent = ((obj.parentSessionId as string) ?? undefined) || undefined;
+
+	// Extract tool_use blocks from the assistant message content (if any).
+	// Used by the --by tool aggregator and subagent-graph attribution.
+	const toolUses: string[] = [];
+	const content = msg.content;
+	if (Array.isArray(content)) {
+		for (const block of content) {
+			if (block && typeof block === 'object') {
+				const b = block as Record<string, unknown>;
+				if (b.type === 'tool_use' && typeof b.name === 'string') {
+					toolUses.push(b.name);
+				}
+			}
+		}
+	}
 
 	return {
 		type: ((obj.type as string) ?? 'assistant') as SessionTurn['type'],
@@ -120,20 +175,43 @@ function extractTurn(
 		sessionId,
 		projectId: perTurnProject ?? projectId,
 		subagentType: perTurnSubagent ?? subagentType,
+		parentSessionId: perTurnParent ?? parentSessionId,
 		model,
 		usage,
+		toolUses: toolUses.length > 0 ? toolUses : undefined,
 		raw: obj,
 	};
 }
 
-// Convenience: stream every turn across every log under ~/.claude/projects.
+// Parallelized, streaming. Does not materialize all turns — caller iterates
+// once and dispatches to aggregators. Reads up to CONCURRENCY files at a time.
 export async function* parseAll(opts: ParseOptions = {}): AsyncGenerator<SessionTurn> {
 	const dir = opts.projectsDir ?? CLAUDE_PROJECTS_DIR;
-	for await (const file of findSessionLogs(dir)) {
-		for await (const turn of parseFile(file.path, file.subagentType, file.projectId)) {
-			if (opts.from && new Date(turn.timestamp) < opts.from) continue;
-			if (opts.to && new Date(turn.timestamp) > opts.to) continue;
-			yield turn;
+	const files: LogFile[] = [];
+	for await (const f of findSessionLogs(dir)) files.push(f);
+
+	// Fan out file reads in batches of CONCURRENCY, yield turns in arrival order.
+	for (let i = 0; i < files.length; i += CONCURRENCY) {
+		const batch = files.slice(i, i + CONCURRENCY);
+		const streams = batch.map((f) =>
+			collectBatch(parseFile(f.path, f.subagentType, f.projectId, f.parentSessionId), opts),
+		);
+		const results = await Promise.all(streams);
+		for (const turns of results) {
+			for (const t of turns) yield t;
 		}
 	}
 }
+
+async function collectBatch(
+	gen: AsyncGenerator<SessionTurn>,
+	opts: ParseOptions,
+): Promise<SessionTurn[]> {
+	const out: SessionTurn[] = [];
+	for await (const t of gen) {
+		if (opts.from && new Date(t.timestamp) < opts.from) continue;
+		if (opts.to && new Date(t.timestamp) > opts.to) continue;
+		out.push(t);
+	}
+	return out;
+}

package/src/pricing.ts

@@ -1,7 +1,7 @@
 import type { CostBreakdown, ModelId, TokenUsage } from './types.ts';
 
 // Prices are per 1M tokens, USD. Keep in sync with
-// https://www.anthropic.com/pricing as of 2026-04-21.
+// https://platform.claude.com/docs/en/about-claude/pricing as of 2026-07-23.
 //
 // Prompt caching (Anthropic):
 //   cache_creation 5-min TTL: 1.25× base input rate
@@ -10,15 +10,31 @@ import type { CostBreakdown, ModelId, TokenUsage } from './types.ts';
 //
 // We include both current and prior-generation model IDs because real logs span
 // version bumps (Claude Code does not auto-rewrite historical logs when you upgrade).
+const SONNET_5_STANDARD_PRICE_START = new Date('2026-09-01T00:00:00Z');
+const SONNET_5_INTRO_RATE = { input: 2, output: 10 };
+const SONNET_5_STANDARD_RATE = { input: 3, output: 15 };
+
 const PRICING: Record<string, { input: number; output: number }> = {
-	// Current generation (2026-04)
-	'claude-opus-4-7': { input: 15, output: 75 },
+	// Current generation (2026-07)
+	'claude-fable-5': { input: 10, output: 50 },
+	'claude-mythos-5': { input: 10, output: 50 },
+	'claude-opus-4-8': { input: 5, output: 25 },
+	'claude-opus-4-7': { input: 5, output: 25 },
+	'claude-opus-4-6': { input: 5, output: 25 },
+	'claude-opus-4-5': { input: 5, output: 25 },
+	// resolveModel applies the introductory rate through 2026-08-31.
+	'claude-sonnet-5': SONNET_5_STANDARD_RATE,
 	'claude-sonnet-4-6': { input: 3, output: 15 },
-	'claude-haiku-4-5-20251001': { input: 0.8, output: 4 },
-	// Prior generation (still appears in logs written before model upgrades)
-	'claude-opus-4-6': { input: 15, output: 75 },
-	'claude-opus-4-5': { input: 15, output: 75 },
 	'claude-sonnet-4-5': { input: 3, output: 15 },
+	'claude-haiku-4-5-20251001': { input: 1, output: 5 },
+	'claude-haiku-4-5': { input: 1, output: 5 },
+	// Prior generation (still appears in logs written before model upgrades)
+	'claude-opus-4-1-20250805': { input: 15, output: 75 },
+	'claude-opus-4-20250514': { input: 15, output: 75 },
+	'claude-sonnet-4-20250514': { input: 3, output: 15 },
+	'claude-haiku-3-5-20241022': { input: 0.8, output: 4 },
+	'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
+	// Kept for the aliases observed in older Claude Code logs.
 	'claude-haiku-4-0': { input: 0.8, output: 4 },
 };
 
@@ -30,25 +46,30 @@ const CACHE_5M_MULTIPLIER = 1.25;
 const CACHE_1H_MULTIPLIER = 2.0;
 const CACHE_READ_MULTIPLIER = 0.1;
 
-// Anthropic server-tool pricing (https://www.anthropic.com/pricing as of 2026-04):
+// Anthropic server-tool pricing (official pricing docs as of 2026-07-23):
 //   Web search: $10 per 1,000 requests = $0.01 / request
-//   Web fetch:  treated identically here pending Anthropic split (file an issue if wrong)
+//   Web fetch:  no per-request charge; fetched content still incurs token costs
 const WEB_SEARCH_PRICE_PER_REQUEST = 0.01;
-const WEB_FETCH_PRICE_PER_REQUEST = 0.01;
+const WEB_FETCH_PRICE_PER_REQUEST = 0;
 
-function resolveModel(model: ModelId | undefined): { input: number; output: number } {
+function resolveModel(model: ModelId | undefined, asOf: Date): { input: number; output: number } {
 	if (!model) return { input: 0, output: 0 };
 	if (FREE_MODELS.has(model)) return { input: 0, output: 0 };
+	if (model === 'claude-sonnet-5' || model.startsWith('claude-sonnet-5-')) {
+		return asOf < SONNET_5_STANDARD_PRICE_START
+			? SONNET_5_INTRO_RATE
+			: SONNET_5_STANDARD_RATE;
+	}
 	const exact = PRICING[model];
 	if (exact) return exact;
-	// Fuzzy family prefix match as a safety net for unknown subversions.
-	// e.g. "claude-opus-4-8-20260301" falls back to Opus pricing until we add it.
+	// A provider/date-suffixed ID can inherit a verified base model's rate.
+	// Unknown future model families deliberately return zero instead of silently
+	// inventing a price; the CLI warns when it sees one.
 	for (const key of Object.keys(PRICING)) {
-		if (model.startsWith(key)) return PRICING[key] as { input: number; output: number };
+		if (model.startsWith(`${key}-`)) {
+			return PRICING[key] as { input: number; output: number };
+		}
 	}
-	if (model.startsWith('claude-opus-')) return { input: 15, output: 75 };
-	if (model.startsWith('claude-sonnet-')) return { input: 3, output: 15 };
-	if (model.startsWith('claude-haiku-')) return { input: 0.8, output: 4 };
 	return { input: 0, output: 0 };
 }
 
@@ -70,8 +91,12 @@ function splitCacheCreation(usage: TokenUsage): CacheBreakdown {
 	};
 }
 
-export function costFor(usage: TokenUsage, model: ModelId | undefined): CostBreakdown {
-	const rate = resolveModel(model);
+export function costFor(
+	usage: TokenUsage,
+	model: ModelId | undefined,
+	asOf: Date = new Date(),
+): CostBreakdown {
+	const rate = resolveModel(model, asOf);
 	const cacheRead = usage.cache_read_input_tokens ?? 0;
 	const { fiveMin, oneHour } = splitCacheCreation(usage);
 
@@ -110,5 +135,5 @@ export function isKnownModel(model: ModelId | undefined): boolean {
 	if (!model) return false;
 	if (FREE_MODELS.has(model)) return true;
 	if (PRICING[model]) return true;
-	return Object.keys(PRICING).some((key) => model.startsWith(key));
+	return Object.keys(PRICING).some((key) => model.startsWith(`${key}-`));
 }

package/src/tree.ts

@@ -0,0 +1,107 @@
+// ASCII tree renderer for subagent graph (the MOAT feature).
+// Helicone/Langfuse observe API calls; only Claude Code knows that
+// orchestrator → 3×researcher + 6×swift-dev. We render that tree.
+
+import type { SubagentTreeNode } from './types.ts';
+
+const fmtUsd = (n: number): string => {
+	if (n < 0.01) return '$' + n.toFixed(4);
+	return '$' + n.toFixed(2);
+};
+
+const dim = (s: string): string =>
+	process.env.NO_COLOR || !process.stdout.isTTY ? s : `\x1b[2m${s}\x1b[0m`;
+
+const bold = (s: string): string =>
+	process.env.NO_COLOR || !process.stdout.isTTY ? s : `\x1b[1m${s}\x1b[0m`;
+
+const amber = (s: string): string =>
+	process.env.NO_COLOR || !process.stdout.isTTY ? s : `\x1b[38;5;215m${s}\x1b[0m`;
+
+export function formatTree(roots: SubagentTreeNode[], totalCost: number): string {
+	if (roots.length === 0) return dim('No subagent graphs found in this period.');
+
+	const lines: string[] = [];
+	lines.push(
+		bold('Subagent graphs') +
+			dim('  · top ') +
+			roots.length +
+			dim(' orchestrators by total cost · grand-total ') +
+			amber(fmtUsd(totalCost)),
+	);
+	lines.push('');
+	for (const root of roots) {
+		renderNode(root, '', true, lines, totalCost, true);
+		lines.push('');
+	}
+	return lines.join('\n');
+}
+
+function renderNode(
+	node: SubagentTreeNode,
+	prefix: string,
+	isLast: boolean,
+	lines: string[],
+	grandTotal: number,
+	isRoot: boolean,
+): void {
+	const connector = isRoot ? '' : isLast ? '└─ ' : '├─ ';
+	const sessionShort = dim(node.sessionId.slice(0, 8));
+	const pct = grandTotal > 0 ? ((node.totalCost / grandTotal) * 100).toFixed(1) + '%' : '—';
+	const turns = dim(`${node.turnCount} turns`);
+
+	if (isRoot) {
+		const childCount = countDescendants(node);
+		const childInfo = childCount > 0 ? dim(` (${childCount} children)`) : '';
+		lines.push(
+			`${bold(node.label)} ${sessionShort}${childInfo}  ${amber(fmtUsd(node.totalCost))}  ${dim(`(${pct})`)}`,
+		);
+	} else {
+		const selfNote =
+			node.children.length > 0
+				? dim(`  self ${fmtUsd(node.selfCost)}`)
+				: '';
+		lines.push(
+			`${dim(prefix)}${connector}${node.label} ${sessionShort}  ${amber(fmtUsd(node.totalCost))}${selfNote}  ${turns}`,
+		);
+	}
+
+	const childPrefix = prefix + (isRoot ? '' : isLast ? '   ' : '│  ');
+	node.children.forEach((child, idx) => {
+		const last = idx === node.children.length - 1;
+		renderNode(child, childPrefix, last, lines, grandTotal, false);
+	});
+}
+
+function countDescendants(node: SubagentTreeNode): number {
+	let n = node.children.length;
+	for (const c of node.children) n += countDescendants(c);
+	return n;
+}
+
+// Markdown variant — same data, GH-friendly nested list.
+export function formatTreeMarkdown(roots: SubagentTreeNode[], totalCost: number): string {
+	const lines: string[] = ['# Subagent graphs', ''];
+	lines.push(`Top ${roots.length} orchestrators by total cost. Grand total: **${fmtUsd(totalCost)}**.`);
+	lines.push('');
+	for (const root of roots) {
+		const childCount = countDescendants(root);
+		lines.push(
+			`## ${root.label} \`${root.sessionId.slice(0, 8)}\` — ${fmtUsd(root.totalCost)} (${childCount} children, ${root.turnCount} turns)`,
+		);
+		mdNode(root, lines, 0);
+		lines.push('');
+	}
+	return lines.join('\n');
+}
+
+function mdNode(node: SubagentTreeNode, lines: string[], depth: number): void {
+	for (const child of node.children) {
+		const indent = '  '.repeat(depth);
+		const self = child.children.length > 0 ? ` _self ${fmtUsd(child.selfCost)}_` : '';
+		lines.push(
+			`${indent}- **${child.label}** \`${child.sessionId.slice(0, 8)}\` — ${fmtUsd(child.totalCost)} (${child.turnCount} turns)${self}`,
+		);
+		mdNode(child, lines, depth + 1);
+	}
+}

package/src/types.ts

@@ -1,8 +1,15 @@
-export type ModelId =
-	| 'claude-opus-4-7'
-	| 'claude-sonnet-4-6'
-	| 'claude-haiku-4-5-20251001'
-	| string;
+// Known model ids — kept narrow for documentation. Use `string` at the boundary.
+export const KNOWN_MODELS = [
+	'claude-opus-4-7',
+	'claude-sonnet-4-6',
+	'claude-haiku-4-5-20251001',
+	'claude-opus-4-6',
+	'claude-opus-4-5',
+	'claude-sonnet-4-5',
+	'claude-haiku-4-0',
+] as const;
+
+export type ModelId = string;
 
 export type TurnType = 'user' | 'assistant' | 'summary' | 'system';
 
@@ -19,12 +26,9 @@ export interface ServerToolUse {
 export interface TokenUsage {
 	input_tokens: number;
 	output_tokens: number;
-	// Legacy flat counter. Real logs also carry `cache_creation` with TTL split; if present,
-	// prefer that for accurate pricing.
 	cache_creation_input_tokens?: number;
 	cache_read_input_tokens?: number;
 	cache_creation?: CacheCreationDetail;
-	// Anthropic server-side tool use (web_search, web_fetch). Priced per request, not per token.
 	server_tool_use?: ServerToolUse;
 }
 
@@ -34,8 +38,10 @@ export interface SessionTurn {
 	sessionId: string;
 	projectId?: string | undefined;
 	subagentType?: string | undefined;
+	parentSessionId?: string | undefined;
 	model?: ModelId | undefined;
 	usage?: TokenUsage | undefined;
+	toolUses?: string[] | undefined; // tool names invoked in this assistant turn
 	raw: unknown;
 }
 
@@ -67,3 +73,15 @@ export interface LedgerReport {
 	rows: AggregatedRow[];
 	total: AggregatedRow;
 }
+
+// Subagent-graph node — the MOAT feature.
+// Represents one parent session's tree-rooted cost attribution:
+// the parent's own cost + all child subagent costs, recursively.
+export interface SubagentTreeNode {
+	sessionId: string;
+	label: string; // subagentType or '(orchestrator)'
+	selfCost: number;
+	totalCost: number; // self + children
+	children: SubagentTreeNode[];
+	turnCount: number;
+}

package/.github/ISSUE_TEMPLATE/bug.md

@@ -1,35 +0,0 @@
----
-name: Bug report
-about: Report incorrect output, crashes, or wrong attribution
-title: ''
-labels: bug
----
-
-## What happened
-
-<!-- What did agent-ledger do? What did you expect it to do instead? -->
-
-## How to reproduce
-
-```bash
-agent-ledger <your-exact-command>
-```
-
-## Output (redact sensitive paths / subagent names)
-
-```
-<paste the output here>
-```
-
-## Your setup
-
-- OS: <!-- macOS 15.3 / Ubuntu 22.04 / ... -->
-- Bun version: <!-- `bun --version` -->
-- agent-ledger version: <!-- `agent-ledger --version` (pre-alpha: use commit SHA) -->
-- Claude Code version: <!-- `claude --version` -->
-
-## If you're on pay-as-you-go, the calibration ask
-
-If you compare `agent-ledger month` against a real Anthropic invoice and
-they differ by > 10%, I want to hear about it. Even one line: "agent-ledger
-says $X, invoice says $Y" is incredibly useful. Thanks.

package/.github/ISSUE_TEMPLATE/model-pricing.md

@@ -1,29 +0,0 @@
----
-name: Model pricing gap
-about: A model ID shows $0 in your ledger — we're missing it from the price table
-title: 'pricing: add <model-id>'
-labels: pricing
----
-
-## Model ID
-
-<!-- e.g. claude-opus-4-8-20260301 -->
-
-## Anthropic's published rates
-
-- Input: $<X> / 1M tokens
-- Output: $<Y> / 1M tokens
-- Link to Anthropic pricing page (with date):
-
-## Where you saw it
-
-Sample from your log (redact the content, keep the model field):
-
-```json
-{"message":{"model":"<model-id>", "usage":{"input_tokens":..., "output_tokens":...}}}
-```
-
-## Optional: PR
-
-If you want to open the PR, the pricing table lives in `src/pricing.ts`. Add a
-matching test in `test/pricing.test.ts`.

package/.github/pull_request_template.md

@@ -1,19 +0,0 @@
-## What this PR does
-
-<!-- One or two sentences. -->
-
-## Checklist
-
-- [ ] `bun run typecheck` passes
-- [ ] `bun test` passes
-- [ ] If you touched `src/pricing.ts`, there's a matching test in
-      `test/pricing.test.ts`
-- [ ] If you touched `src/parser.ts`, the change doesn't break the nested
-      `subagents/` walk (see `test/parser.test.ts`)
-- [ ] No runtime dependencies added (this tool intentionally has none)
-
-## Log snippet (if relevant)
-
-<!-- If the change is about handling some real log shape, include a redacted
-example of what it looks like. Helps me reason about whether other tools
-produce the same shape. -->

package/.github/workflows/ci.yml

@@ -1,19 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-      - run: bun install --frozen-lockfile
-      - run: bun run typecheck
-      - run: bun test