Graph pipeline cost metrics: capture naming spend, fold all channels, cost pill + panel

- Cluster namer bills the money channel now: per-step usage + model
  captured via onStep, persisted as NamingRunUsage records to
  data/graph/naming-runs.jsonl (idempotent per startedAt; failed/aborted
  runs persist too — money spent either way). callUsage promoted to
  extraction.ts module scope for reuse.
- core/cost-summary.ts: the pure fold behind the pill — chat runs,
  notes-source runs, and naming runs into stage totals (extraction /
  audit / naming) + newest-first recent runs. Dollars INFERRED read-time
  via prices.ts, never stored; unpriced models excluded-but-counted
  (render '—', never a silent zero); tokens always sum.
- GET /api/graph/costs (src/server graphCosts composition, thin route).
- Graph view: bottom-left cost pill (cumulative dollars headline) +
  expandable breakdown panel (stage rows with tokens secondary, recent
  runs with time/title/merged/cost); fetched on mount, refetched when a
  pipeline run finishes; merged into one bottom-left stack with the
  running-pipeline pills.
- Tests: pure-fold suite, naming capture wiring (full importNotes ->
  naming path), store idempotency + strict reads.

tests/cost-summary.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Tests for src/core/cost-summary.ts — the graph cost pill's pure fold.
+ * Same laws as the money channel everywhere: dollars INFERRED at read
+ * time (core/prices.ts), unpriced models excluded-but-counted (render
+ * "—", never a silent zero), tokens always sum.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it as test } from "node:test";
+import {
+	graphCostSummary,
+	type CostSummaryInput,
+	type GraphCostSummary,
+} from "../src/core/cost-summary.ts";
+import type { CallUsage, ExtractionRunUsage, NamingRunUsage } from "../src/core/contracts.ts";
+import { PRICES, callCost } from "../src/core/prices.ts";
+
+/** A model with full published pricing (from the generated registry). */
+const PRICED = "z-ai/glm-5.3-flash";
+assert.ok(PRICES[PRICED], "fixture model must exist in PRICES");
+
+const step = (input: number, output: number): CallUsage => ({
+	inputTokens: input,
+	outputTokens: output,
+	cacheReadTokens: 0,
+	cacheWriteTokens: undefined,
+	reasoningTokens: 0,
+});
+
+const extractionRun = (
+	startedAt: number,
+	extractorModel: string,
+	auditorModel: string,
+	stats?: ExtractionRunUsage["stats"],
+): ExtractionRunUsage => ({
+	startedAt,
+	at: new Date(startedAt).toISOString(),
+	durationMs: 10_000,
+	stages: {
+		extractor: { model: extractorModel, steps: [step(1000, 200)] },
+		auditor: { model: auditorModel, steps: [step(2000, 100)] },
+	},
+	...(stats ? { stats } : {}),
+});
+
+const namingRun = (startedAt: number, model: string, appended: number): NamingRunUsage => ({
+	startedAt,
+	at: new Date(startedAt).toISOString(),
+	durationMs: 4_000,
+	model,
+	steps: [step(500, 50)],
+	stats: { detected: 8, claimed: 6, named: 2, appended },
+});
+
+describe("graphCostSummary (the cost pill's fold)", () => {
+	test("folds all three channels: stage totals, tokens, newest-first runs", () => {
+		const input: CostSummaryInput = {
+			chats: [{ title: "Testing session", extractions: [extractionRun(100, PRICED, PRICED)] }],
+			sources: [{ filePath: "/vault/modal.md", extractions: [extractionRun(200, PRICED, PRICED)] }],
+			naming: [namingRun(300, PRICED, 2)],
+		};
+		const s = graphCostSummary(input);
+		const extStep = callCost(step(1000, 200), PRICED)!;
+		const audStep = callCost(step(2000, 100), PRICED)!;
+		assert.equal(s.stages.extraction.dollars, extStep * 2);
+		assert.equal(s.stages.audit.dollars, audStep * 2);
+		assert.equal(s.stages.naming.dollars, callCost(step(500, 50), PRICED));
+		assert.equal(s.stages.extraction.runs, 2);
+		assert.equal(s.stages.naming.runs, 1);
+		assert.equal(s.stages.extraction.tokens.inputTokens, 2000);
+		assert.equal(s.stages.audit.tokens.outputTokens, 200);
+		assert.equal(s.totalDollars, extStep * 2 + audStep * 2 + callCost(step(500, 50), PRICED)!);
+		// All three runs, newest first, titles joined per front door.
+		assert.deepEqual(
+			s.runs.map((r) => r.title),
+			["Cluster naming", "/vault/modal.md", "Testing session"],
+		);
+		assert.equal(s.runs[0]!.labels, 2);
+		assert.equal(s.runs[0]!.kind, "naming");
+		assert.equal(s.unpricedRuns, 0);
+	});
+
+	test("unpriced models: excluded dollars, counted honestly, run null only when BOTH stages unpriced", () => {
+		const s: GraphCostSummary = graphCostSummary({
+			chats: [{ title: "partial", extractions: [extractionRun(100, PRICED, "unknown-model")] }],
+			sources: [{ filePath: "/vault/x.md", extractions: [extractionRun(200, "unknown-model", "unknown-model")] }],
+			naming: [],
+		});
+		assert.equal(s.stages.audit.unpricedRuns, 2);
+		assert.equal(s.stages.audit.dollars, 0); // never a silent zero: unpricedRuns says it
+		assert.equal(s.stages.extraction.unpricedRuns, 1);
+		// The partial run still prices its extractor side; the fully
+		// unpriced run renders "—". Newest first: 200 (both unpriced), 100.
+		assert.equal(s.runs[0]!.dollars, null);
+		assert.notEqual(s.runs[1]!.dollars, null);
+		assert.equal(s.unpricedRuns, 1); // run-level: only the both-stages run
+	});
+
+	test("recent runs cap: newest survive", () => {
+		const extractions = [1, 2, 3, 4].map((n) => extractionRun(n * 100, PRICED, PRICED));
+		const s = graphCostSummary({
+			chats: [{ title: "chat", extractions }],
+			sources: [],
+			naming: [],
+			recentCap: 2,
+		});
+		assert.equal(s.runs.length, 2);
+		assert.deepEqual(s.runs.map((r) => r.startedAt), [400, 300]);
+		// stage totals still count EVERY run, cap is presentational.
+		assert.equal(s.stages.extraction.runs, 4);
+	});
+
+	test("failed runs carry no merged stats; empty input folds to zero", () => {
+		const s = graphCostSummary({
+			chats: [{ title: "failed", extractions: [extractionRun(100, PRICED, PRICED)] }],
+			sources: [],
+			naming: [],
+		});
+		assert.equal(s.runs[0]!.merged, undefined);
+		const empty = graphCostSummary({ chats: [], sources: [], naming: [] });
+		assert.equal(empty.totalDollars, 0);
+		assert.equal(empty.runs.length, 0);
+		assert.equal(empty.stages.naming.runs, 0);
+		assert.equal(empty.stages.extraction.tokens.inputTokens, undefined);
+	});
+});