Merge feat/graph-rendering: wave 4 — extraction usage capture (live + persisted), true abort

# Conflicts:
#	src/server/observability.ts

tests/extraction.test.ts

@@ -34,7 +34,7 @@ import type {
 	SessionFindings,
 } from "../src/core/contracts.ts";
 import type { GraphStore } from "../src/core/ports.ts";
-import { createExtractionPipeline, extractionStatuses, transcriptView } from "../src/agent/subagents/extraction.ts";
+import { abortExtraction, createExtractionPipeline, extractionStatuses, transcriptView } from "../src/agent/subagents/extraction.ts";
 import { chatStore } from "../src/store/chats.ts";
 import { PATHS } from "../config.ts";
 
@@ -197,6 +197,24 @@ function submitModel(name: string, input: unknown, onCall?: () => void): MockLan
 	});
 }
 
+/** A model that hangs until its abort signal fires, then rejects —
+ *  mimicking a cancelled provider request (the abort path). Like a real
+ *  provider, an ALREADY-aborted signal rejects immediately (the abort
+ *  can win the race before doGenerate attaches its listener). */
+function hangingModel(): MockLanguageModelV4 {
+	const abortReject = (reject: (reason: Error) => void) =>
+		reject(Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
+	return new MockLanguageModelV4({
+		doGenerate: async (options): Promise<never> => {
+			await new Promise<never>((_, reject) => {
+				if (options.abortSignal?.aborted) abortReject(reject);
+				else options.abortSignal?.addEventListener("abort", () => abortReject(reject));
+			});
+			throw new Error("unreachable");
+		},
+	});
+}
+
 /** A model that never calls a tool (the failure path). */
 function silentModel(): MockLanguageModelV4 {
 	return new MockLanguageModelV4({
@@ -378,6 +396,97 @@ describe("the extraction pipeline (extractor → auditor → merger)", () => {
 		assert.equal(extractionStatuses().length, 0, "the registry clears when the run ends");
 	});
 
+	it("captures per-stage usage live, persists the run's usage into the chat record", async () => {
+		const { chatId } = fixtureChat();
+		const ledgers = memoryLedgers();
+		const existingId = "n_existing";
+		ledgers.appendNode({
+			id: existingId,
+			name: "Derivative",
+			statement: "Derivatives measure rates of change",
+			aliases: [],
+			createdAt: "2026-08-01T00:00:00.000Z",
+			provenance: [],
+		});
+		const usageSeen: (number | undefined)[] = [];
+		const verdict: AuditResult = {
+			propositions: [{ ...FINDINGS.propositions[0]!, linkTo: existingId }],
+			edges: [],
+			attribution: { quiz: {} },
+			dropped: [{ ref: "p2", reason: "evidence not found" }],
+		};
+		const pipeline = createExtractionPipeline({
+			chatStore,
+			graphStore: ledgers,
+			// During the auditor's generate, the registry must already carry
+			// the extractor's fully accumulated live usage (2 steps × 10/5).
+			extractor: submitModel("submit_findings", FINDINGS),
+			auditor: submitModel("submit_review", verdict, () =>
+				usageSeen.push(extractionStatuses().find((r) => r.chatId === chatId)?.usage.extractor?.steps.at(-1)?.inputTokens),
+			),
+		});
+		await pipeline.runExtraction(chatId);
+
+		// Live: mid-audit the extractor's usage was fully accumulated
+		// (the mock bills 10 input / 5 output per step, flat per the SDK).
+		assert.deepEqual(usageSeen, [10]);
+
+		// Persisted: the run appended ONE usage entry to the chat's
+		// extractions log — per-stage model + steps, with merge stats.
+		const record = chatStore.getChat(chatId)!;
+		assert.equal(record.extractions?.length, 1);
+		const run = record.extractions![0]!;
+		assert.equal(run.stats?.nodes, 0); // linked, not created
+		assert.equal(run.stats?.events, 3);
+		assert.equal(run.stages.extractor.model, "mock-model-id"); // the mock's model id
+		assert.equal(run.stages.extractor.steps.length, 2); // tool-call step + text step
+		assert.deepEqual(run.stages.extractor.steps[0], {
+			inputTokens: 10,
+			outputTokens: 5,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			reasoningTokens: 0,
+		});
+		assert.equal(run.stages.auditor.steps.length, 2);
+		assert.ok(!Number.isNaN(Date.parse(run.at)));
+	});
+
+	it("aborts mid-run: cancels the model call, persists partial usage, checkpoints nothing", async () => {
+		const { chatId } = fixtureChat();
+		const ledgers = memoryLedgers();
+
+		const pipeline = createExtractionPipeline({
+			chatStore,
+			graphStore: ledgers,
+			extractor: hangingModel(), // hangs until aborted — no step finishes
+			auditor: submitModel("submit_review", { propositions: [], edges: [], attribution: { quiz: {} }, dropped: [] }),
+		});
+		const runPromise = pipeline.runExtraction(chatId);
+
+		// The registry entry exists synchronously after the call (setPhase
+		// runs before the first await); abort is TRUE cancellation.
+		assert.equal(abortExtraction(chatId), true);
+		const stats = await runPromise;
+
+		// A deliberate stop, not a failure: zero emissions, no throw.
+		assert.deepEqual(stats, { nodes: 0, edges: 0, events: 0 });
+		assert.equal(extractionStatuses().length, 0, "the registry clears");
+		assert.equal(ledgers.readNodes().length, 0, "nothing merged");
+		assert.equal(ledgers.readCheckpoints().length, 0, "nothing checkpointed — the next trigger re-runs");
+
+		// Partial usage still persisted (money was spent): stats absent,
+		// no completed steps in either stage.
+		const record = chatStore.getChat(chatId)!;
+		assert.equal(record.extractions?.length, 1);
+		const run = record.extractions![0]!;
+		assert.equal(run.stats, undefined);
+		assert.equal(run.stages.extractor.steps.length, 0);
+		assert.equal(run.stages.auditor.steps.length, 0);
+
+		// Aborting a non-running chat is an idempotent no-op.
+		assert.equal(abortExtraction(chatId), false);
+	});
+
 	it("is single-flight per chat — a concurrent second run is a no-op", async () => {
 		const { chatId } = fixtureChat();
 		const ledgers = memoryLedgers();

tests/usage.test.ts

@@ -12,7 +12,7 @@ import * as fs from "node:fs";
 import { chatStore } from "../src/store/chats.ts";
 import { PATHS } from "../config.ts";
 import { callCost, contextWindow, jobCost, sessionCost, sumSteps, turnCost } from "../src/core/prices.ts";
-import type { CallUsage, JobRecord, TurnUsage } from "../src/core/contracts.ts";
+import type { CallUsage, ExtractionRunUsage, JobRecord, TurnUsage } from "../src/core/contracts.ts";
 
 const call = (over: Partial<CallUsage> = {}): CallUsage => ({
 	inputTokens: 0,
@@ -134,3 +134,34 @@ test("appendTurnUsage: appends, is idempotent per messageId, survives saveMessag
 
 	fs.unlinkSync(`${PATHS.chats}/${record.id}.json`);
 });
+
+test("appendExtractionUsage: appends, idempotent per startedAt, not in list payload", () => {
+	const record = chatStore.createChat("extraction usage test chat");
+	const runEntry = (startedAt: number): ExtractionRunUsage => ({
+		startedAt,
+		at: "2026-09-09T00:00:00Z",
+		durationMs: 42_000,
+		stats: { nodes: 1, edges: 2, events: 3 },
+		stages: {
+			extractor: { model: "z-ai/glm-5.3-flash", steps: [call({ inputTokens: 100, outputTokens: 10 })] },
+			auditor: { model: "z-ai/glm-5.3-flash", steps: [call({ inputTokens: 50, outputTokens: 5 })] },
+		},
+	});
+	chatStore.appendExtractionUsage(record.id, runEntry(1));
+	chatStore.appendExtractionUsage(record.id, runEntry(1)); // same run appended twice → no-op
+	chatStore.appendExtractionUsage(record.id, runEntry(2)); // a retried run is a NEW spend
+	let reread = chatStore.getChat(record.id);
+	assert.equal(reread?.extractions?.length, 2);
+	// failed runs (stats absent) persist with usage — money was spent
+	chatStore.appendExtractionUsage(record.id, { ...runEntry(3), stats: undefined });
+	reread = chatStore.getChat(record.id);
+	assert.equal(reread?.extractions?.length, 3);
+	assert.equal(reread?.extractions?.at(-1)?.stats, undefined);
+
+	// the list payload must NOT leak the extractions log
+	const listed = chatStore.listChats().find((c) => c.id === record.id);
+	assert.ok(listed);
+	assert.equal("extractions" in listed, false);
+
+	fs.unlinkSync(`${PATHS.chats}/${record.id}.json`);
+});