Extraction-UX data layer: the chunk budget becomes a graph setting; the chat view gets a per-session coverage read

Owner-locked extraction-UX redesign (dispatch 2026-09-24), part 1 (data
layer; the UI chunk follows).

THRESHOLD -> SETTING
- config.ts's EXTRACTION.chunkTokens dies; the default moves into
  FACTORY_SETTINGS.graph.extractionChunkTokens (4096, the old constant's
  value). GraphSettings gains the optional field, Required at resolution
  via the standard ?? FACTORY pattern — pre-redesign records resolve the
  default cleanly.
- FLOOR 500 (the implementer's call, documented on the field): every run
  pays the graph-carrying prompt overhead out of the write channel's
  money — a smaller budget fires penny-batches that cost more per
  extracted token than the content is worth. The sanitizer CLAMPS up
  (bd68486 clamp-never-reject discipline: fractions floor, junk drops);
  the settings PUT REJECTS below-floor with the rationale in the message.
  No ceiling: a large budget just delays extraction — the user's stated
  cost/thoroughness tradeoff, not a misconfiguration to police.
- The trigger (turn-service.triggerExtraction) takes the budget as a
  parameter — chat-handler passes effective.graph.extractionChunkTokens,
  the fresh per-turn read, same as every other gate.
- The pipeline's BATCH side threads through the same number:
  ExtractionPipelineDeps gains an OPTIONAL getChunkTokens getter with the
  factory default (Teacher's 24 test fixtures stay untouched; the two
  call-site lines inside extraction.ts are the only cross-band edits,
  flagged). chat-handler + backfill/import-notes wire the live
  effectiveSettings — trigger and batches share one budget, always.

PER-SESSION COVERAGE READ
- sessionCoverage(chatId) (server/chats.ts): the chat view's ring-meter
  block — totalMessages/coveredCount/uncoveredCount/coveredTokens/
  uncoveredTokens (the same coverageOf derivation /api/graph/coverage
  serves, scoped to one chat), running (chat-kind extraction registered
  for this id), and lastFoldedAt (the chat's newest coverage row's fold
  — a cheap single pass; null before any fold). GET /api/chats/[id]
  carries it as coverage: {...}; unknown chat -> null (the route 404s
  first).
- /api/graph/coverage (the all-sessions list) compiles untouched — the
  per-session read is a scoping of it, not a supersession; the UI's
  sidebar/ring chunk decides which surface it consumes.

Tests: factory/sanitizer pins (clamp-up, fraction-floor, junk-drop),
resolution pins (absent -> 4096, stored 2000 wins), settings-body pins
(valid/absent/fraction/below-floor 400/junk 400), sessionCoverage pins
(derived split, newest-fold scoping, cross-session isolation, running via
the registry, null on unknown chat). 893/893.

tests/settings-body.test.ts

@@ -162,6 +162,28 @@ describe("parseGraphSettingsBody", () => {
 		assert.equal(parseGraphSettingsBody("nope").ok, false);
 	});
 
+	it("extractionChunkTokens: whole tokens ≥ the 500 floor (extraction-UX redesign, 2026-09-24)", () => {
+		const ok = parseGraphSettingsBody({ enabled: true, extractionChunkTokens: 2048 });
+		assert.ok(ok.ok);
+		assert.deepEqual(ok.settings, { enabled: true, extractionChunkTokens: 2048 });
+		// absent = unset — replace-whole keeps the factory default at resolution
+		const absent = parseGraphSettingsBody({ enabled: true });
+		assert.ok(absent.ok);
+		assert.deepEqual(absent.settings, { enabled: true });
+		// fractions floor to whole tokens
+		const fraction = parseGraphSettingsBody({ extractionChunkTokens: 1024.9 });
+		assert.ok(fraction.ok);
+		assert.equal(fraction.settings.extractionChunkTokens, 1024);
+		// below the cost floor: 400 with the floor named (penny-batches)
+		const tiny = parseGraphSettingsBody({ extractionChunkTokens: 100 });
+		assert.equal(tiny.ok, false, "below-floor rejected");
+		assert.match(tiny.ok === false ? tiny.error : "", /at least 500/);
+		// junk shapes: 400
+		assert.equal(parseGraphSettingsBody({ extractionChunkTokens: "4096" }).ok, false);
+		assert.equal(parseGraphSettingsBody({ extractionChunkTokens: NaN }).ok, false);
+		assert.equal(parseGraphSettingsBody({ extractionChunkTokens: null }).ok, false);
+	});
+
 	it("the dead wave-6 rungs in a body are ignored — the section collapses on write", () => {
 		// Old clients may still send {embedding: true, embeddingModel: …};
 		// the parser reads ONLY the master switch — the dead keys are not