Clusters phases B+C: labeling records, the naming call, snapshot payload

Core-survival labelings (vision section 1, DECIDED 2026-09-13):
ClusterLabeling records in a new append-only ledger
(data/graph/cluster-labels.jsonl), immutable, id = clu_ + sha256 of the
sorted core so re-naming races and re-runs dedupe at the store seam.
matchClusterLabelings (core/clusters.ts, pure): a community keeps a
record's label while at least half its core survives in it; both sides
single-successor (a split keeps one name; greedy by overlap, ties to
the newer record).

The namer (src/agent/subagents/cluster-namer.ts): ONE singular cheap LLM
call (new 'labeler' role, glm-flash/low) names every new/changed
community at once, given member names + statements (capped at 12
members per cluster). refreshClusterLabels runs POST-EXTRACTION
(user-decided) from both front doors, fire-and-forget — naming failure
never fails the run; refreshes serialize behind a chain so parallel
imports never mint duplicate labels. import-notes.ts awaits
clusterNamingSettled before exit.

Payload: GraphSnapshot.clusters (>= MIN_CLUSTER_SIZE 3) joins detection
with labelings at read time — claimed clusters carry the record's label
and id; unlabeled ones carry a member-hash id and null label. Detection
is deterministic so no memo in v1 (ms at current scale; revisit at
vault scale).

Tests (372/372): matcher half-rule/split/merge/greedy/tie cases; naming
end-to-end through importNotes (one call, one record, claim on
re-refresh), naming failure non-fatal; snapshot derivation with
labeling join; 11 test pipelines now pin an explicit labeler seam.

src/core/clusters.ts

@@ -26,6 +26,7 @@
  */
 import Graph from "graphology";
 import louvain from "graphology-communities-louvain";
+import type { ClusterLabeling } from "./contracts.ts";
 
 /** A detected community. Members are SORTED node ids — the member set IS
  * the identity a labeling record can outlive a reshuffle with. */
@@ -33,6 +34,11 @@ export interface Community {
 	members: string[];
 }
 
+/** Communities below this size are not rendered, not named — presentation
+ *  rule (user-decided 2026-09-13): a region of the world model needs at
+ *  least three propositions to be worth a hull and a label. */
+export const MIN_CLUSTER_SIZE = 3;
+
 export interface CommunityDetection {
 	communities: Community[];
 	/** Modularity of the found partition — the one quality number. */
@@ -116,3 +122,47 @@ export function detectCommunities(
 		);
 	return { communities, modularity: details.modularity };
 }
+
+/**
+ * Claim labeling records for detected communities — CORE-SURVIVAL (DECIDED
+ * 2026-09-13): a community keeps a record's label while AT LEAST HALF of
+ * the record's core survives in it (overlap * 2 >= core.length; exactly
+ * half survives). Both sides are single-successor: one community holds at
+ * most one label, one record is claimed by at most one community — on a
+ * split, only the branch carrying the majority of the core keeps the name;
+ * on a merge, the best-overlapping record wins.
+ *
+ * Greedy assignment by overlap size (largest first; ties broken by newer
+ * record). Returns a claim (or null) per community, in input order —
+ * unclaimed communities are the namer's input. Pure: same inputs, same
+ * claims.
+ */
+export function matchClusterLabelings(
+	communities: readonly Community[],
+	labelings: readonly ClusterLabeling[],
+): (ClusterLabeling | null)[] {
+	interface Pair {
+		community: number;
+		labeling: ClusterLabeling;
+		overlap: number;
+	}
+	const pairs: Pair[] = [];
+	communities.forEach((community, ci) => {
+		const members = new Set(community.members);
+		for (const labeling of labelings) {
+			const overlap = labeling.core.reduce((n, id) => n + (members.has(id) ? 1 : 0), 0);
+			if (overlap * 2 >= labeling.core.length && overlap > 0) {
+				pairs.push({ community: ci, labeling, overlap });
+			}
+		}
+	});
+	pairs.sort((a, b) => b.overlap - a.overlap || (a.labeling.createdAt < b.labeling.createdAt ? 1 : -1));
+	const claims: (ClusterLabeling | null)[] = communities.map(() => null);
+	const takenRecords = new Set<string>();
+	for (const pair of pairs) {
+		if (claims[pair.community] || takenRecords.has(pair.labeling.id)) continue;
+		claims[pair.community] = pair.labeling;
+		takenRecords.add(pair.labeling.id);
+	}
+	return claims;
+}