memhtml 0.2.4 → 0.3.0

package/dist/{dist-dfrcDFad.mjs → dist-B3yDga97.mjs}

@@ -1,4 +1,4 @@
-import { $ as MEMORY_EXTENSION, B as ModelUnavailable, Ct as slugify, H as StorageFailure, J as relClassFor, L as DirtyTree, Q as INBOX_DIR, R as InvalidMemory, St as filenameFor, U as WriteConflict, V as PathNotFound, W as EdgeRel, X as relTokenFor, Y as relForToken, Z as ARCS_DIR, _t as TaskStatus, at as memoryPathFor, bt as parseEntity, ct as placementFor, dt as MEMORY_TYPES, et as PEOPLE_DIR, ft as MemoryStatus, gt as TASK_STATUSES, ht as PERSON_ENTITY_PREFIX, it as isValidMemoryPath, lt as Confidence, mt as PARA_BUCKETS, nt as archivePathFor, ot as normalizePath, pt as MemoryType, q as isEdgeRel, rt as isArchivePath, st as paraBucketOf, ut as Importance, vt as WRITABLE_MEMORY_TYPES, wt as withCollisionOrdinal, xt as SLUG_FALLBACK, yt as isTaskStatus, z as LlmContractViolation } from "./dist-t84Q_98w.mjs";
+import { $ as INBOX_DIR, B as ModelUnavailable, Ct as filenameFor, H as StorageFailure, J as relClassFor, L as DirtyTree, Q as ARCS_DIR, R as InvalidMemory, St as SLUG_FALLBACK, Tt as withCollisionOrdinal, U as WriteConflict, V as PathNotFound, W as EdgeRel, X as relTokenFor, Y as relForToken, Z as ARCHIVE_BUCKET, _t as TASK_STATUSES, at as isValidMemoryPath, bt as isTaskStatus, ct as paraBucketOf, dt as Importance, et as MEMORY_EXTENSION, ft as MEMORY_TYPES, gt as PERSON_ENTITY_PREFIX, ht as PARA_BUCKETS, it as isArchivePath, lt as placementFor, mt as MemoryType, ot as memoryPathFor, pt as MemoryStatus, q as isEdgeRel, rt as archivePathFor, st as normalizePath, tt as PEOPLE_DIR, ut as Confidence, vt as TaskStatus, wt as slugify, xt as parseEntity, yt as WRITABLE_MEMORY_TYPES, z as LlmContractViolation } from "./dist-CSo_XRfz.mjs";
 import { createRequire } from "node:module";
 import { Config, Context, Effect, Layer, Result, Schedule, Schema } from "effect";
 import { mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
@@ -429,6 +429,12 @@ const bridgeCounts = (nodes, edges, communities) => {
 * correction was written to fix. These guards are a deterministic veto. A divergent pair
 * becomes a candidate contradiction for the conflict phase instead of a merge, no matter how
 * high its cosine runs.
+*
+* The guards are a POST-FILTER over every proposal, including a model's. `dedup-merge` asks a model
+* to partition a connected component into merge groups, and each pair that partition implies is
+* routed through {@link mergeCandidates} before anything is written. A model that groups a claim with
+* its own negation is refused by the same predicate that refuses a blind cosine, so the set of pairs
+* that can be committed does not widen when a model is bound.
 */
 /** Cosine similarity above which two bodies are the same content. Strict. */
 const NEAR_DUPLICATE_THRESHOLD = .92;
@@ -589,6 +595,59 @@ const mergeCandidates = (pairs, options = {}) => {
 	return decisions;
 };
 /**
+* Connected components over an undirected edge list, as sorted member lists.
+*
+* The near-duplicate graph's components are dedup's units of work. A component is what "these
+* memories might all be one memory" looks like before anything has judged them, and it is the right
+* unit because near-duplication is transitive in practice: three rewordings of one fact produce
+* three edges, and folding them one pair at a time would ask the same question three times and could
+* answer it three different ways.
+*
+* **The partition is order-INVARIANT, not merely order-stable.** A union always keeps the
+* lexicographically smaller root, so every set's root is the smallest key it holds no matter which
+* order the edges arrive in. Members come back sorted, and components come back ordered by root,
+* which is each component's own smallest member. So the same edge SET produces the same output
+* whether it arrives mined-first, frame-first, mirrored, or shuffled. That is stronger than sorting
+* the input would be, and it is why no sort happens here: a caller cannot make this disagree with
+* itself by changing how it enumerates.
+*
+* A "larger root wins" or "first root seen wins" rule would break exactly that, because both make
+* the surviving root a fact about arrival order rather than about the set.
+*
+* Each pair is normalized before it is unioned, so `(a, b)` and `(b, a)` are one edge. A self-edge
+* introduces its key and joins nothing. Cost is near-linear in the edge count, and no step here ever
+* enumerates a pair the caller did not hand over.
+*/
+const connectedComponents = (edges) => {
+	const parent = /* @__PURE__ */ new Map();
+	const find = (key) => {
+		let current = key;
+		while ((parent.get(current) ?? current) !== current) {
+			const next = parent.get(current);
+			parent.set(current, parent.get(next) ?? next);
+			current = parent.get(current);
+		}
+		return current;
+	};
+	for (const [left, right] of edges) {
+		if (!parent.has(left)) parent.set(left, left);
+		if (!parent.has(right)) parent.set(right, right);
+		const rootLeft = find(left);
+		const rootRight = find(right);
+		if (rootLeft === rootRight) continue;
+		if (rootLeft < rootRight) parent.set(rootRight, rootLeft);
+		else parent.set(rootLeft, rootRight);
+	}
+	const byRoot = /* @__PURE__ */ new Map();
+	for (const key of parent.keys()) {
+		const root = find(key);
+		const bucket = byRoot.get(root);
+		if (bucket === void 0) byRoot.set(root, [key]);
+		else bucket.push(key);
+	}
+	return [...byRoot.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, members]) => members.sort());
+};
+/**
 * The compress-path exclusion: the members of a batch to supersede and archive, with the
 * canonical removed and order preserved. When a batch folds into a pre-existing canonical, a
 * member can *be* that canonical, and archiving it would destroy the file just folded into.
@@ -644,6 +703,139 @@ const applyMmr = (candidates, limit, lambda = MMR_LAMBDA) => {
 	return selected;
 };
 
+//#endregion
+//#region packages/domain/dist/neighbors.js
+/**
+* A `Float32Array` over stored bytes, copying only when it must.
+*
+* `Float32Array` requires a 4-byte-aligned `byteOffset`, and a driver row's `Uint8Array` may be
+* a view into a pooled buffer at any offset. Viewing in place is the common case and costs
+* nothing. A misaligned or ragged blob is copied rather than rejected, because the vector arm's
+* job is to rank and a throw here would fail a whole search over one row.
+*/
+const float32View = (bytes) => {
+	if (bytes.byteLength === 0 || bytes.byteLength % 4 !== 0) return void 0;
+	const aligned = bytes.byteOffset % 4 === 0 ? bytes : Uint8Array.from(bytes);
+	return new Float32Array(aligned.buffer, aligned.byteOffset, aligned.byteLength / 4);
+};
+/** `sqrt(Σ x²)` accumulated in index order — the same order {@link cosine} accumulates its norms. */
+const sqrtNorm = (vec) => {
+	let sum = 0;
+	for (let index = 0; index < vec.length; index += 1) {
+		const x = vec[index];
+		sum += x * x;
+	}
+	return Math.sqrt(sum);
+};
+/**
+* Cosine similarity from precomputed norms: {@link cosine}'s operations with the square roots
+* hoisted out of the pair loop, so the result is bit-identical for equal-length vectors. The
+* zero-norm rule and the `[-1, 1]` clamp are the same ones, for the same reasons. Mismatched
+* lengths fall back to {@link cosine}, whose min-length walk defines that case; equal lengths are
+* what the `embed_model` watermark guarantees for stored vectors.
+*/
+const pairSimilarity = (a, aNorm, b, bNorm) => {
+	if (a.length !== b.length) return cosine(a, b);
+	if (aNorm === 0 || bNorm === 0) return 0;
+	let dot = 0;
+	for (let index = 0; index < a.length; index += 1) dot += a[index] * b[index];
+	return Math.max(-1, Math.min(1, dot / (aNorm * bNorm)));
+};
+/**
+* Insert into a per-source list ordered `sim` DESC then `dst` ASC, bounded at `k`. Linear
+* insertion, because `k` is single-digit everywhere this runs and a heap's constant factors lose
+* at that size. Memory across the whole selection is O(n·k), never the pair space.
+*/
+const insertBounded = (list, k, dst, sim) => {
+	let at = list.length;
+	for (let index = 0; index < list.length; index += 1) {
+		const held = list[index];
+		if (sim > held.sim || sim === held.sim && dst < held.dst) {
+			at = index;
+			break;
+		}
+	}
+	if (at >= k) return;
+	list.splice(at, 0, {
+		dst,
+		sim
+	});
+	if (list.length > k) list.pop();
+};
+/** The final ordering every consumer sees: `sim` DESC, then `src` ASC, then `dst` ASC, then cap. */
+const collectRanked = (bySource, limit) => {
+	const rows = [];
+	for (const [src, list] of bySource) for (const held of list) rows.push({
+		src,
+		dst: held.dst,
+		sim: held.sim
+	});
+	rows.sort((left, right) => {
+		if (left.sim !== right.sim) return left.sim < right.sim ? 1 : -1;
+		if (left.src !== right.src) return left.src < right.src ? -1 : 1;
+		return left.dst < right.dst ? -1 : left.dst > right.dst ? 1 : 0;
+	});
+	return rows.slice(0, limit);
+};
+/**
+* Per-source top-`k` nearest neighbors above a similarity floor, over every unordered pair.
+*
+* Each pair's similarity is computed ONCE and offered to BOTH endpoints' neighborhoods, so the
+* output can hold `(a, b)` and `(b, a)` — each is a fact about a different source's neighborhood,
+* and a consumer folding pairs must dedup the mirror itself (dedup-merge does, with its `seen`
+* set). A floor comparison a NaN similarity cannot pass keeps a vector carrying NaN bytes out of
+* every neighborhood rather than poisoning an ordering.
+*/
+const topNeighborPairs = (vectors, options) => {
+	const norms = vectors.map((entry) => sqrtNorm(entry.vec));
+	const bySource = /* @__PURE__ */ new Map();
+	for (const entry of vectors) bySource.set(entry.key, []);
+	for (let i = 0; i < vectors.length; i += 1) {
+		const left = vectors[i];
+		const leftNorm = norms[i];
+		const leftList = bySource.get(left.key);
+		for (let j = i + 1; j < vectors.length; j += 1) {
+			const right = vectors[j];
+			const sim = pairSimilarity(left.vec, leftNorm, right.vec, norms[j]);
+			if (!(sim >= options.floor)) continue;
+			insertBounded(leftList, options.perSourceK, right.key, sim);
+			insertBounded(bySource.get(right.key), options.perSourceK, left.key, sim);
+		}
+	}
+	return collectRanked(bySource, options.limit);
+};
+/**
+* Rank an ENUMERATED pair set: similarity, floor, per-source top-`k`, final ordering, cap.
+*
+* This is the shape for a consumer whose candidate pairs come from a selective predicate — the
+* conflict scan's shared-entity join — rather than from the whole pair space. The predicate runs
+* BEFORE ranking, exactly as a `WHERE` inside the ranking CTE would, so per-source top-`k` is
+* computed over passing pairs only. A pair naming a key with no vector contributes nothing, the
+* same outcome the SQL join's missing-embedding row produces.
+*/
+const rankCandidatePairs = (pairs, vectors, options) => {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of vectors) byKey.set(entry.key, {
+		vec: entry.vec,
+		norm: sqrtNorm(entry.vec)
+	});
+	const bySource = /* @__PURE__ */ new Map();
+	for (const pair of pairs) {
+		const left = byKey.get(pair.src);
+		const right = byKey.get(pair.dst);
+		if (left === void 0 || right === void 0) continue;
+		const sim = pairSimilarity(left.vec, left.norm, right.vec, right.norm);
+		if (!(sim >= options.floor)) continue;
+		let list = bySource.get(pair.src);
+		if (list === void 0) {
+			list = [];
+			bySource.set(pair.src, list);
+		}
+		insertBounded(list, options.perSourceK, pair.dst, sim);
+	}
+	return collectRanked(bySource, options.limit);
+};
+
 //#endregion
 //#region packages/domain/dist/reinforce.js
 /** The signal a reinforcement carries. `negative` is what drives the outcome EWMA down. */
@@ -2181,8 +2373,18 @@ const META_PREFIX = "memhtml-";
 /**
 * Meta keys that may appear more than once. Each value is its own `<meta>` element
 * rather than a comma-joined string, so correcting one tag is a one-line diff.
+*
+* `memhtml-alias` is the third: a person file declares the other names the same person is recorded
+* under, so `laith al-saadoon` can state that `laith` is them. Sleep's entity resolution reads it as
+* EVIDENCE and auto-merges an alias-backed pair whatever the character distance says, which no
+* string similarity can supply — `laith` against `laith al-saadoon` scores 0.476, below even the
+* review band. One meta per alias, for the same one-line-diff reason.
 */
-const REPEATABLE_META = ["memhtml-entity", "memhtml-tag"];
+const REPEATABLE_META = [
+	"memhtml-entity",
+	"memhtml-tag",
+	"memhtml-alias"
+];
 /** True when a metadata name may legitimately appear more than once in one head. */
 const isRepeatableMeta = (name) => REPEATABLE_META.includes(name);
 /**
@@ -2224,7 +2426,8 @@ const META_ORDER = [
 	"memhtml-task-status",
 	"memhtml-due",
 	"memhtml-entity",
-	"memhtml-tag"
+	"memhtml-tag",
+	"memhtml-alias"
 ];
 /** True when a `memhtml-`-prefixed metadata name is in the closed vocabulary. */
 const isMemoryMetaName = (name) => META_ORDER.includes(name);
@@ -3283,6 +3486,17 @@ const MemoryDoc = Schema.Struct({
 	entities: Schema.Array(Schema.String),
 	/** `memhtml-tag` values as authored, in document order. Open vocabulary. */
 	tags: Schema.Array(Schema.String),
+	/**
+	* `memhtml-alias` values as authored, in document order. The other names this file's subject is
+	* recorded under — a person file's declaration that `laith` and `l.alsaadoon` are the same person
+	* as its own `person:` entity.
+	*
+	* Read as EVIDENCE by sleep's entity resolution, which auto-merges an alias-backed pair whatever
+	* the name similarity says. That is why the field is a bare string list rather than a parsed
+	* `type:name`: the declaring file's own `memhtml-entity` already carries the type, and an alias
+	* that restated it could disagree with it.
+	*/
+	aliases: Schema.Array(Schema.String),
 	links: Schema.Array(MemoryLink),
 	article: ArticleExtractions,
 	/**
@@ -3694,6 +3908,7 @@ const parseMemory = (html) => Effect.suspend(() => {
 		metas: metaResult.metas,
 		entities: repeated(metas, "memhtml-entity"),
 		tags: repeated(metas, "memhtml-tag"),
+		aliases: repeated(metas, "memhtml-alias"),
 		links: readLinks(document),
 		article: readArticle(article),
 		warnings: structural.warnings
@@ -3774,7 +3989,11 @@ const metaPairs = (doc) => {
 	put("memhtml-needs-revision", metas.needsRevision);
 	put("memhtml-task-status", metas.taskStatus);
 	put("memhtml-due", metas.dueAt);
-	const repeatables = /* @__PURE__ */ new Map([["memhtml-entity", doc.entities], ["memhtml-tag", doc.tags]]);
+	const repeatables = /* @__PURE__ */ new Map([
+		["memhtml-entity", doc.entities],
+		["memhtml-tag", doc.tags],
+		["memhtml-alias", doc.aliases]
+	]);
 	const pairs = [];
 	for (const name of META_ORDER) {
 		if (isRepeatableMeta(name)) {
@@ -3906,6 +4125,7 @@ const newMemoryDoc = (input) => {
 		},
 		entities: input.entities ?? [],
 		tags: input.tags ?? [],
+		aliases: input.aliases ?? [],
 		links: input.links ?? [],
 		article: {
 			html,
@@ -5487,19 +5707,6 @@ const packSentences = (units, maxChars) => {
 */
 const BUSY_TIMEOUT_MS = 5e3;
 /**
-* A `Float32Array` over stored bytes, copying only when it must.
-*
-* `Float32Array` requires a 4-byte-aligned `byteOffset`, and a driver row's `Uint8Array` may be
-* a view into a pooled buffer at any offset. Viewing in place is the common case and costs
-* nothing. A misaligned or ragged blob is copied rather than rejected, because the vector arm's
-* job is to rank and a throw here would fail a whole search over one row.
-*/
-const float32View = (bytes) => {
-	if (bytes.byteLength === 0 || bytes.byteLength % 4 !== 0) return void 0;
-	const aligned = bytes.byteOffset % 4 === 0 ? bytes : Uint8Array.from(bytes);
-	return new Float32Array(aligned.buffer, aligned.byteOffset, aligned.byteLength / 4);
-};
-/**
 * Register `vector_distance_cos(a, b)`, the cosine distance over two float32 blobs.
 *
 * SQLite ships no vector functions, so the vector retrieval arm's distance is this. It calls
@@ -5513,6 +5720,12 @@ const float32View = (bytes) => {
 * vectors at top-40 (probed 2026-08-12 on node 24.19.0), against a Bedrock query-embedding round
 * trip of a few hundred milliseconds that every vector search pays first. An approximate index buys
 * nothing until the corpus is an order of magnitude larger.
+*
+* That measurement is the 1×n shape — one bound query vector against the table, n calls, n blob
+* copies — and it is the ONLY shape this function serves. Each invocation materializes a fresh
+* `Uint8Array` per blob argument, so an n×n consumer pays the corpus re-copied n times (probed
+* 2026-08-18, issue #40: 8.45M calls and an OOM at n = 2,907). The sleep pair scans decode once
+* and rank in `@memhtml/domain`'s neighbors module instead.
 */
 const registerVectorDistance = (db) => {
 	db.function("vector_distance_cos", { deterministic: true }, (a, b) => {
@@ -8169,7 +8382,9 @@ const clampTokens = (requested) => Math.min(requested ?? 16384, MAX_TOKENS_CEILI
 * `emit` call, and that is the whole structured-output mechanism.
 *
 * `system` is omitted rather than sent empty, because an empty system block is a distinct
-* (and rejected) input from no system block at all.
+* (and rejected) input from no system block at all. An omitted system also has nothing to cache, so
+* `cacheSystem` over an absent or empty system emits no `system` key at all instead of an empty
+* cached block.
 */
 const buildInvokeBody = (key, prompt, options, tool) => {
 	const body = {
@@ -8181,7 +8396,11 @@ const buildInvokeBody = (key, prompt, options, tool) => {
 		}],
 		output_config: { effort: options.effort }
 	};
-	if (options.system !== void 0 && options.system.length > 0) body.system = options.system;
+	if (options.system !== void 0 && options.system.length > 0) body.system = options.cacheSystem === true ? [{
+		type: "text",
+		text: options.system,
+		cache_control: { type: "ephemeral" }
+	}] : options.system;
 	const thinking = thinkingFor(key);
 	if (thinking !== null) body.thinking = thinking;
 	if (tool !== void 0) {
@@ -8273,7 +8492,8 @@ const makeModelClient = (client) => {
 			const { parsed } = yield* invoke(request.modelKey, request.prompt, {
 				system: request.system,
 				maxTokens: request.maxTokens,
-				effort: request.effort
+				effort: request.effort,
+				cacheSystem: request.cacheSystem
 			}, {
 				inputSchema: request.inputSchema ?? toInputSchema(request.schema),
 				...request.toolDescription === void 0 ? {} : { description: request.toolDescription }
@@ -8562,6 +8782,163 @@ var DiscriminationFailed = class {
 */
 const discriminationGate = (options = {}) => runDiscrimination(options).pipe(Effect.flatMap((outcome) => outcome.passed ? Effect.succeed(outcome) : Effect.fail(new DiscriminationFailed(outcome))));
 
+//#endregion
+//#region packages/sleep/dist/batch.js
+/**
+* Mint `m1`..`mN` over `items` in the order given, and index each key back to its item.
+*
+* The keys carry no information beyond position, which is the point. A key that encoded a path or a
+* title would let a model answer with a target it inferred rather than one it was offered, and this
+* corpus stores instructions, so a member's own text can read as a directive about naming.
+*
+* `charBudget` slices each text after `textOf` builds it. The budget is per member and is applied
+* here so every phase slices at the same boundary, where the text stops being a row and becomes a
+* prompt.
+*/
+const keyMembers = (items, textOf, options) => {
+	const budget = options?.charBudget;
+	const keyed = [];
+	const itemForKey = /* @__PURE__ */ new Map();
+	for (const [offset, item] of items.entries()) {
+		const key = `m${offset + 1}`;
+		const text = textOf(item);
+		keyed.push({
+			key,
+			text: budget === void 0 ? text : text.slice(0, budget)
+		});
+		itemForKey.set(key, item);
+	}
+	return {
+		keyed,
+		itemForKey
+	};
+};
+/**
+* Resolve the keys a model named back to items: unknown keys are dropped, repeats collapse.
+*
+* A key the batch never offered is a member the model invented, and every phase on this kernel turns
+* a named member into a write, so an unresolvable key must not reach that write. Dropping it leaves
+* the corresponding file untouched, which is the safe outcome for every one of the five phases.
+*
+* The result keeps the order the model named the keys in, and a key named twice appears once.
+* De-duplication is on the KEY rather than on the resolved item, so the count a phase gates on
+* ("at least two members absorbed") counts distinct offered members.
+*/
+const resolveKeys = (batch, keys) => [...new Set(keys)].flatMap((key) => {
+	const item = batch.itemForKey.get(key);
+	return item === void 0 ? [] : [item];
+});
+/**
+* Slice each pre-sorted group into batches of at most `maxMembers`, dropping any batch that falls
+* below `minMembers`.
+*
+* The groups arrive in the order the caller wants them called in, and each group's members arrive in
+* the caller's own stable order. This walks both in that order, so the boundaries are reproducible.
+*
+* `minMembers` defaults to 1, which keeps every slice. A phase whose question is meaningless for a
+* lone member raises it: compress passes 2, because folding one memory into a "canonical" rewrites it
+* under a new path and archives the original for no gain.
+*/
+const assembleBatches = (groups, options) => {
+	const floor = options.minMembers ?? 1;
+	const batches = [];
+	for (const group of groups) for (let at = 0; at < group.length; at += options.maxMembers) {
+		const slice = group.slice(at, at + options.maxMembers);
+		if (slice.length >= floor) batches.push(slice);
+	}
+	return batches;
+};
+/**
+* Pack whole groups into shared batches, bounded by a member count and a character budget together.
+*
+* For a phase whose groups are mostly tiny. `dedup-merge` works over connected components of the
+* near-duplicate graph, where a typical component is a pair, so one call per component would spend a
+* model call on two memories. Ten or twenty components in one call cost one.
+*
+* Group boundaries survive into the result, because they are evidence. Two members in different
+* components are known NOT to be near-duplicates, and a prompt that flattened the pack into one list
+* would ask the model to rediscover that.
+*
+* A group longer than `maxMembers` is sliced on the same stride {@link assembleBatches} uses, so no
+* returned batch breaches either cap. Packing is greedy in the order given and closes a batch when the
+* next unit would breach a cap, which makes the packing a function of the input order. Filtering out
+* groups the phase does not want called (a singleton component, for dedup) is the caller's step,
+* because a floor applied after packing would measure the pack instead of the group.
+*/
+const packGroups = (groups, options) => {
+	const batches = [];
+	let current = [];
+	let members = 0;
+	let chars = 0;
+	const close = () => {
+		if (current.length > 0) batches.push(current);
+		current = [];
+		members = 0;
+		chars = 0;
+	};
+	for (const group of groups) {
+		if (group.length === 0) continue;
+		const units = group.length > options.maxMembers ? assembleBatches([group], { maxMembers: options.maxMembers }) : [group];
+		for (const unit of units) {
+			const cost = unit.reduce((total, item) => total + options.charsOf(item), 0);
+			const breaches = members + unit.length > options.maxMembers || chars + cost > options.maxChars;
+			if (current.length > 0 && breaches) close();
+			current.push(unit);
+			members += unit.length;
+			chars += cost;
+		}
+	}
+	close();
+	return batches;
+};
+/**
+* The numbered member list as one prompt block: each member wrapped as data under `<label>_<key>`,
+* blocks separated by a blank line.
+*
+* Every member goes through `wrapAsData`, which is the prompt-injection boundary. This corpus stores
+* instructions, so a procedural memory about a deploy step reads exactly like a directive to the
+* model, and un-delimited member text in a user turn would be an injection surface the system built
+* for itself.
+*/
+const memberList = (keyed, options) => {
+	const label = options?.label ?? "member";
+	return keyed.map((member) => wrapAsData(`${label}_${member.key}`, member.text)).join("\n\n");
+};
+/**
+* A batch's user turn: the member list first, the instruction that closes it last.
+*
+* The phase's own instruction sentence is the tail rather than the head, matching the order every
+* copy of this pattern already used. The stable half of a batch prompt is `system` and the tool
+* schema, which {@link batchCall} marks cacheable; the user turn is new bytes on every call whatever
+* order its parts sit in.
+*/
+const batchPrompt = (keyed, instruction, options) => `${memberList(keyed, options)}\n\n${instruction}`;
+/**
+* Run one model call in isolation: a failure becomes `undefined` and a counted skip.
+*
+* This is the per-item posture the packet's §4 requires, expressed with `Effect.result` because
+* `Effect.either` does not exist in this beta. One violation skips its item and leaves the phase
+* running. A night that judged 199 pairs and lost the 200th to a malformed tool payload has done 199
+* pairs of work, and failing the phase would throw all of it away.
+*/
+const isolate = (label, call) => Effect.gen(function* () {
+	const outcome = yield* Effect.result(call);
+	if (Result.isSuccess(outcome)) return outcome.success;
+	yield* Effect.logWarning(`sleep.llm ${label} skipped: ${outcome.failure.reason}`);
+});
+/**
+* Run one batch's model call: prompt-cache the stable prefix, and isolate the failure.
+*
+* `cacheSystem` is set here instead of at each call site, because every phase on this kernel has the
+* same shape: one system prompt and one tool schema repeated across every batch of the night, with
+* only the member list changing. A phase that forgot the flag would re-bill its whole prefix on every
+* batch, and the omission would be invisible in the phase's output.
+*/
+const batchCall = (model, label, request) => isolate(label, model.generateObject({
+	...request,
+	cacheSystem: true
+}));
+
 //#endregion
 //#region packages/sleep/dist/contract.js
 /**
@@ -8585,7 +8962,7 @@ const SLEEP_PHASES = [
 	"entity-resolution",
 	"person-links",
 	"relationship-mining",
-	"conflict-detection",
+	"edge-typing",
 	"confidence-decay",
 	"arc-synthesis",
 	"retention-triage",
@@ -8612,6 +8989,10 @@ const phaseIndexOf = (phase) => SLEEP_PHASES.indexOf(phase) + 1;
 * `dedup-merge` is the one hard prerequisite, for `compress` and `retention-triage`: both operate
 * on the post-merge set, and running them over a corpus that still holds the duplicates would
 * compress a near-duplicate pair into a canonical while a merge later archives one of its members.
+*
+* That is why `dedup-merge` isolates each of its model calls instead of failing on one. It batches
+* components and a batch whose call comes back malformed is counted and skipped, so a single bad tool
+* payload cannot take two later phases down with it.
 */
 const HARD_PREREQUISITES = [["dedup-merge", "compress"], ["dedup-merge", "retention-triage"]];
 /** The phases blocked by `phase` failing. */
@@ -8849,7 +9230,7 @@ const datePlusDays = (date, days) => {
 //#endregion
 //#region packages/sleep/dist/env.js
 /**
-* Model assignments per LLM phase: the cheap judge for stance, the strong one for synthesis.
+* Model assignments per LLM phase: the cheap judge for classification, the strong one for synthesis.
 *
 * `trace-consolidation` names `opus-5` and does not thereby choose it. The consolidator is an eve
 * agent that pins its own model in `apps/consolidator/agent/agent.ts`, and this map cannot reach that
@@ -8858,7 +9239,22 @@ const datePlusDays = (date, days) => {
 * the Bedrock global endpoint, high reasoning effort, no cost ceiling.)
 */
 const DEFAULT_MODELS = {
-	"conflict-detection": "sonnet-5",
+	/**
+	* `dedup-merge` names sonnet for the same reason the edge-typing judge does: the question is a
+	* classification over text the model is shown, not a synthesis it has to write. It partitions a
+	* component into "these are the same memory" groups, and every consequence of that answer — which
+	* file survives, whether the pair diverges, whether either path is already claimed — is decided by
+	* code afterwards. The strong model is spent where prose gets written.
+	*/
+	"dedup-merge": "sonnet-5",
+	/**
+	* Sonnet, and one or two calls a night: the whole of one entity type's name list goes in one call.
+	* The question is a partition over short strings with their evidence inline, not a synthesis, so
+	* the strong model would buy nothing the deterministic floors around the answer do not already
+	* supply.
+	*/
+	"entity-resolution": "sonnet-5",
+	"edge-typing": "sonnet-5",
 	"arc-synthesis": "opus-5",
 	compress: "sonnet-5",
 	"trace-consolidation": "opus-5"
@@ -8875,7 +9271,7 @@ const emptyOutcome = (counts = {}) => ({
 //#endregion
 //#region packages/sleep/dist/llm.js
 /**
-* The structured-output schemas the four LLM phases share, and the per-item isolation wrapper.
+* The structured-output schemas the four LLM phases share, and their prompts.
 *
 * Two rules govern everything here, both of them found by hitting the failure:
 *
@@ -8889,32 +9285,87 @@ const emptyOutcome = (counts = {}) => ({
 * itself. The prompts are also blind by construction. None names a path, a score, or a decision the
 * caller has already made, so the model cannot agree with a verdict it was shown.
 */
-/** A stance judgment over one candidate pair. What conflict-detection asks for. */
-const StanceVerdict = Schema.Literals([
-	"contradicts",
-	"entails",
-	"neutral"
-]);
-const StanceJudgment = Schema.Struct({
-	verdict: StanceVerdict,
-	/** Unitless in `[0, 1]`. The assertion gate is deterministic and reads this, not the prose. */
+/**
+* The rels edge typing may propose, plus `none`. A closed subset of `MEMORY_RELS`, and the
+* omissions are deliberate.
+*
+* `supersedes` is out because it is a one-way door on stored belief: it says one memory REPLACES
+* another, which is dedup-merge's and compress's business and rides with an archive. `relates_to`
+* is out because it is what the pair already carries as a derived edge, so proposing it is a no-op
+* with a model call attached. `laterally_related` is out for the same reason one notch weaker.
+* A pair the model cannot type answers `none` and stays a mined suspicion.
+*/
+const EDGE_TYPED_RELS = [
+	"caused_by",
+	"leads_to",
+	"example_of",
+	"supports",
+	"part_of",
+	"contradicts"
+];
+/**
+* The five DIRECTIONAL rels: the ones whose meaning depends on which endpoint is the subject.
+*
+* `contradicts` is excluded and that is the whole distinction this list draws. A contradiction is
+* symmetric — a reader arriving at either file must see it — so it is promoted into BOTH files and
+* its `direction` field is ignored. A directional rel is promoted into ONE file, the subject's, and
+* the direction decides which one.
+*/
+const EDGE_DIRECTIONAL_RELS = [
+	"caused_by",
+	"leads_to",
+	"example_of",
+	"supports",
+	"part_of"
+];
+/** The rel vocabulary the model answers over: the typed rels plus the refusal. */
+const EdgeVerdictRel = Schema.Literals([...EDGE_TYPED_RELS, "none"]);
+/**
+* Which endpoint is the rel's subject. Meaningful only for {@link EDGE_DIRECTIONAL_RELS}.
+*
+* Required rather than optional, because a model allowed to omit it would omit it on the rels where
+* it matters. `contradicts` and `none` carry a value the phase does not read.
+*/
+const EdgeDirection = Schema.Literals(["src_to_dst", "dst_to_src"]);
+/** One pair's verdict, under the opaque key the pair was offered as. */
+const EdgeVerdict = Schema.Struct({
+	/** The offered key, e.g. `m3`. A key the batch never held resolves to nothing and is dropped. */
+	pairKey: Schema.String,
+	rel: EdgeVerdictRel,
+	direction: EdgeDirection,
+	/** Unitless in `[0, 1]`. The promotion gate is deterministic and reads this, not the prose. */
 	confidence: Schema.Finite.check(Schema.isBetween({
 		minimum: 0,
 		maximum: 1
 	})),
-	/** One or two sentences naming the specific claims that conflict, or why they are compatible. */
-	rationale: Schema.String
+	/** One or two sentences naming the specific claims that carry the rel. Optional: `none` has none. */
+	rationale: Schema.optional(Schema.String)
 });
+/** One batch's whole answer: a verdict LIST, never one call per pair. */
+const EdgeTyping = Schema.Struct({ verdicts: Schema.Array(EdgeVerdict) });
+/**
+* The confidence a verdict must clear before the phase writes anything.
+*
+* A `contradicts` feeds a retention penalty that can eventually evict a memory, so a false one is
+* worse than a missed one; the floor and the `detections >= 2` corroboration gate are two
+* independent guards on that one-way door. A directional rel is milder but still an authored edge in
+* a file a human reads, so it clears the same floor. One number, because a second one would be a
+* knob nobody could say the meaning of.
+*/
+const EDGE_CONFIDENCE_FLOOR = .7;
+/** True when a verdict is a proposal at all, above the floor. Computed here, never by the model. */
+const assertsEdge = (verdict) => verdict.rel !== "none" && verdict.confidence >= .7;
+/** True when a verdict earns a `contradicts` edge. The corroboration gate's precondition. */
+const assertsContradiction = (verdict) => verdict.rel === "contradicts" && verdict.confidence >= .7;
 /**
-* The confidence a `contradicts` verdict must clear before the phase asserts an edge.
+* True when a rel's meaning depends on which endpoint is its subject.
 *
-* A detected contradiction feeds a retention penalty that can eventually evict a memory, so a
-* false `contradicts` is worse than a missed one. The floor and the `detections >= 2`
-* corroboration gate are two independent guards on the same one-way door.
+* A NARROWING predicate, not a boolean, so the caller's `rel` becomes an `EdgeDirectionalRel` — and
+* therefore a `MemoryRel` — inside the branch that writes a `<link>`. A plain boolean would leave the
+* write site casting `"none"`-inclusive union to `EdgeRel`, which is the cast that would silently
+* survive someone adding a non-rel member to the verdict vocabulary.
 */
-const STANCE_CONFIDENCE_FLOOR = .7;
-/** True when a judgment earns a `contradicts` edge. Computed here, not decided by the model. */
-const assertsContradiction = (judgment) => judgment.verdict === "contradicts" && judgment.confidence >= .7;
+const isDirectionalRel = (rel) => EDGE_DIRECTIONAL_RELS.includes(rel);
 /** One arc the triage call proposes to act on. */
 const ArcAction = Schema.Literals([
 	"update",
@@ -8957,21 +9408,98 @@ const CompressSynthesis = Schema.Struct({
 	*/
 	absorbedKeys: Schema.Array(Schema.String)
 });
-/** The stance judge's system prompt. */
-const STANCE_SYSTEM = `You are a natural-language-inference stance judge for an AI agent's long-term memory system.
-You are given two memories, A and B, that are embedding-near and about the same entity or topic.
-Decide the stance of B relative to A in one pass:
+/** One proposed identity cluster over the entity names a batch offered. */
+const EntityCluster = Schema.Struct({
+	/**
+	* The member key the cluster's canonical name was offered under. The phase re-derives the canonical
+	* from ITS OWN weight-then-lexicographic rule, so this names which member the model considers the
+	* fullest form and never which file gets rewritten. A key the batch did not offer resolves to
+	* nothing and drops the cluster.
+	*/
+	canonicalKey: Schema.String,
+	/**
+	* Every member key in the cluster, canonical included. A cluster of one is a valid answer meaning
+	* "this name stands alone", and it produces no merge.
+	*/
+	memberKeys: Schema.Array(Schema.String),
+	/** Unitless in `[0, 1]`. The merge gate is deterministic and reads this, not the prose. */
+	confidence: Schema.Finite.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 1
+	})),
+	/** One sentence naming what makes these one subject: a declared alias, a shared neighborhood. */
+	evidence: Schema.String
+});
+/**
+* The whole clustering answer for one batch: a partition of the offered names.
+*
+* `clusters: []` is a refusal and a valid answer. A model that cannot tell two short names apart must
+* be able to say so, because the alternative — inventing a cluster to fill the field — reaches a
+* permanent rewrite of stored identity.
+*/
+const EntityClustering = Schema.Struct({ clusters: Schema.Array(EntityCluster) });
+/**
+* One merge group: the members the model says are the same memory, by their offered keys.
+*
+* **No canonical field, deliberately.** The keeper is the OLDER file, decided from corpus order in
+* the phase, and a model-chosen canonical would be a model-chosen write target: the file that
+* survives and the files that get archived. The model's whole job here is the partition — which
+* members are one memory — and orientation is arithmetic over `created_at` that needs no judgment.
+*
+* A group of fewer than two keys is meaningless and the phase drops it. That is the shape a model
+* produces when it wants to say "this one is on its own", which is a valid answer.
+*/
+const MergeGroup = Schema.Struct({ memberKeys: Schema.Array(Schema.String) });
+/**
+* The dedup partition for one packed batch: every merge group the model found, across every
+* component in the batch.
+*
+* **The groups are FLAT, not nested per component, and the phase re-derives which component each one
+* came from.** A nested answer would need the model to keep a component index aligned with its
+* groups, which is bookkeeping a model gets wrong under load, and a mis-aligned index would attach a
+* group to the wrong component's files. A flat list of member keys carries the same information,
+* because a key already identifies its member and therefore its component. So the phase can check
+* containment itself instead of trusting a label.
+*
+* `groups: []` is a full refusal: every member stays where it is, which is the safe outcome and the
+* behavior a night with no model already has.
+*/
+const MergePartition = Schema.Struct({ groups: Schema.Array(MergeGroup) });
+/**
+* The edge-typing system prompt: the whole rel vocabulary, one pass, one answer per pair.
+*
+* The same conservative posture the per-pair stance judge carried, generalized. An unsure pair
+* answers `none` and keeps the machine-mined `relates_to` it already has, which costs the corpus
+* nothing; a wrong `contradicts` starts a memory down the eviction path and a wrong directional rel
+* writes a claim about causality into a file a human reads.
+*/
+const EDGE_TYPING_SYSTEM = `You type relationships between memories in an AI agent's long-term memory system. You are given a
+NUMBERED LIST of candidate pairs. Each pair holds two memories, src and dst, that are embedding-near
+or share an entity. Return ONE verdict per pair, naming the pair by the key it was offered under.
+
+Choose the rel that holds between the two memories:
 
-- contradicts: A and B make claims about the same thing that CANNOT both be true at the same time
-  (negation, opposite outcomes, mutually exclusive values).
-- entails: B restates, paraphrases, or is fully implied by A — redundant, not conflicting.
-- neutral: A and B are about the same entity but make compatible, complementary, or simply
-  unrelated claims that can both hold.
+- caused_by: one memory's fact is the CAUSE of the other's. The subject is the effect.
+- leads_to: one memory's fact leads to, triggers, or produces the other's. The subject is the cause.
+- example_of: one memory is a concrete instance of the other's general claim. The subject is the instance.
+- supports: one memory is evidence FOR the other's claim, without restating it. The subject is the evidence.
+- part_of: one memory is a component, step, or subtopic of the other's larger whole. The subject is the part.
+- contradicts: the two make claims about the same thing that CANNOT both be true at the same time
+  (negation, opposite outcomes, mutually exclusive values). SYMMETRIC: direction is ignored.
+- none: the two are merely about the same topic, restate each other, or carry no relationship you can
+  name from the text. This is the correct answer whenever you are unsure.
 
-Be conservative. A detected contradiction feeds a retention penalty that can eventually evict a
-memory, so when the two claims COULD both be true — different scope, different time, different
-aspect — answer neutral, not contradicts. Rate your confidence honestly and name the specific
-conflicting or compatible claims in the rationale.`;
+direction says which endpoint is the rel's SUBJECT, as described per rel above: src_to_dst means src
+is the subject and dst the object; dst_to_src is the reverse. Answer src_to_dst on contradicts and
+none, where it is not read.
+
+Be conservative. A verdict above the confidence floor is written into the memory files as an authored
+edge, and a false contradicts feeds a retention penalty that can eventually evict a memory. When the
+relationship COULD be something else — different scope, different time, mere topical adjacency —
+answer none. Two memories being similar is not a relationship. Rate confidence honestly and name the
+specific claims that carry the rel in the rationale.
+
+Omitting a pair is allowed: an omitted pair is simply left untyped.`;
 /** The arc-triage system prompt: plan only, no content. */
 const ARC_TRIAGE_SYSTEM = `You triage behavioral arcs for an AI agent's long-term memory system. This is the planning pass:
 a second pass writes each arc's content, so your output is only the plan.
@@ -9010,34 +9538,151 @@ them, and each member you list in absorbedKeys is archived once the canonical is
   member you omit stays active, which is the safe outcome — never list one to be tidy.
 - If the members do not actually describe one thing, return an empty absorbedKeys and say so in the
   claim. Refusing to fold is a valid answer.`;
+/**
+* The entity-clustering system prompt: partition one type's names into subjects.
+*
+* Names the three evidence kinds a member block carries, because each one supports a different
+* inference and a model told only "decide if these are the same" would weigh the name string — the
+* signal that is measurably wrong here. `laith` against `laith al-saadoon` is 0.476 by character
+* overlap, below even the review band, while their memory centroids are near-identical.
+*
+* The refusal instruction is load-bearing rather than polite. A cluster this phase acts on rewrites
+* every `memhtml-entity` meta naming the alias across the corpus, and no later commit separates two
+* subjects whose memories were fused.
+*/
+const ENTITY_CLUSTER_SYSTEM = `You group entity names for an AI agent's long-term memory system. Every name below is the same KIND of
+thing — all people, or all services, or all concepts — and several may be different ways of writing one
+subject. Partition them into subjects.
+
+Each member gives you:
+- the name as the corpus records it, and how many active memories claim it;
+- up to three titles of memories claiming it, which say what that name is ABOUT;
+- its nearest neighbors by MEMORY CENTROID with a cosine — the centroid is the average of the vectors
+  of every memory claiming the name, so a high cosine means two names are written about in the same
+  terms. Two spellings of one person have near-identical centroids; two different services in one
+  domain do not;
+- for a person, aliases DECLARED in that person's own file, which are an authoritative statement of
+  identity rather than a guess.
+
+Rules:
+- Every cluster lists canonicalKey plus every other member key that names the same subject. Set
+  canonicalKey to the fullest, most complete form of the name.
+- A name that stands alone is its own cluster of one, or you may leave it out. Both mean "no merge".
+- Return an empty clusters list when nothing here is the same subject. Refusing to group is a valid
+  and often correct answer.
+- Short name against long name is the case to look for: 'laith' and 'laith al-saadoon' are one person
+  when the evidence supports it. Shared prefix is NOT: 'checkout-api' and 'payments-api' are two
+  services, and 'metrics-api' and 'metrics-cli' are a service and a tool.
+- Never group two names because their strings are similar. Group them because the evidence says one
+  subject, and cite that evidence.
+- Rate confidence honestly. A merge fuses two subjects' memories permanently and nothing separates
+  them again, so answer low when you are unsure and the system will hold the merge back.`;
+/** The instruction that closes an entity-clustering batch's user turn, after the member list. */
+const ENTITY_CLUSTER_INSTRUCTION = "Partition these names into subjects. Return one cluster per subject with its canonicalKey, every member key it covers, your confidence, and the specific evidence that makes them one subject.";
+/**
+* The entity-clustering user turn for one batch: every member's evidence block under its offered key.
+*
+* `batchPrompt` from the kernel builds the list and appends the instruction, so the stable half of the
+* call is {@link ENTITY_CLUSTER_SYSTEM} plus the tool schema and only the member list is new bytes per
+* batch. Kept as a named function because the instruction belongs beside the system prompt.
+*/
+const entityClusterPrompt = (members) => batchPrompt(members, ENTITY_CLUSTER_INSTRUCTION, { label: "entity" });
+/**
+* The dedup-partition system prompt.
+*
+* The stable prefix for every dedup call of a {@link batchCall} marks it cacheable, so only
+* the member list is new bytes per batch.
+*
+* It tells the model that a group is a claim about SAMENESS and nothing else. Every other decision
+* the fold needs — which file survives, whether the pair diverges in polarity or in a number,
+* whether either path is already spoken for — is made by code after the answer comes back, and the
+* prompt says so, because a model told it is choosing what gets deleted answers more conservatively
+* than the question deserves.
+*/
+const DEDUP_SYSTEM = `You partition groups of near-duplicate memories for an AI agent's long-term memory system.
+Each component below holds memories that are near neighbors in vector space, or that state the same
+relation. Within EACH component, group the memories that are THE SAME MEMORY — one fact stored more
+than once, in different words.
+
+- A group means: these state one fact, and keeping all of them stores it repeatedly. Two memories
+  about the same topic that carry DIFFERENT facts are not a group.
+- Group only members of the SAME component. Members of different components are already known not to
+  be near-duplicates.
+- A member belongs to at most one group. Leave a member out of every group when it is on its own.
+- Return groups: [] when no component holds a duplicate. Refusing to group is a valid answer and is
+  the right one whenever you are unsure.
+- You are not choosing what to delete. Which memory survives a fold is decided from the memories'
+  own dates afterwards, and a proposed group is still checked for contradicting claims, differing
+  numbers, and differing product variants before anything is written. Answer only the question of
+  sameness.`;
 /** One labelled corpus block, delimited so its prose cannot be read as an instruction. */
 const dataBlock = (label, text) => wrapAsData(label, text);
 /**
-* The stance judge's user turn for one pair. Both texts are wrapped; neither carries a path.
+* One pair as the model sees it: both memories inline, delimited, under `src` and `dst` headings.
+*
+* This is a MEMBER's text, not a whole prompt: the kernel's `keyMembers` slices it to the phase's
+* per-member budget and `memberList` wraps the whole thing again under the pair's opaque key, so a
+* batch of thirty pairs is one nesting of sixty delimited memories. Neither half carries a path, a
+* cosine, or a prior verdict, so the model cannot infer which answer the caller is hoping for and
+* cannot recognize a pair it judged last night.
+*
+* The inner headings are plain lines rather than another `wrapAsData` block, because the outer wrap
+* already carries the "this is data" instruction and a second copy per member would repeat that
+* sentence sixty times in one prompt for no added guard.
+*/
+const pairText = (srcText, dstText) => `src:\n${srcText}\n\ndst:\n${dstText}`;
+/** The instruction that closes an edge-typing batch's user turn, after the pair list. */
+const EDGE_TYPING_INSTRUCTION = "Type each pair above. Return one verdict per pair, naming the pair by its offered key, with the rel, the direction, your confidence, and a rationale naming the claims that carry the rel. Answer none whenever you are unsure.";
+/**
+* One edge-typing batch's user turn: every pair's two memories under its offered key, then the
+* instruction.
 *
-* The prompt names no path, no cosine, and no prior verdict, so the model cannot infer which answer
-* the caller is hoping for and cannot recognize a pair it judged last night.
+* `batchPrompt` from the kernel builds the list and appends the instruction, so the framing is the
+* same bytes compress's batches use. Kept as a named function because the instruction belongs beside
+* {@link EDGE_TYPING_SYSTEM}, which is the other half of what the model is told.
 */
-const stancePrompt = (textA, textB) => `${dataBlock("memory_a", textA)}\n\n${dataBlock("memory_b", textB)}\n\nDo these two memories contradict each other? Give your verdict, your confidence, and a rationale naming the specific claims that conflict or why they are compatible.`;
+const edgeTypingPrompt = (pairs) => batchPrompt(pairs, EDGE_TYPING_INSTRUCTION, { label: "pair" });
 /** The arc-triage user turn: the live arcs and the recent evidence, both wrapped. */
 const arcTriagePrompt = (arcsText, evidenceText) => `${dataBlock("current_arcs", arcsText)}\n\n${dataBlock("evidence", evidenceText)}\n\nProduce a triage plan. Assign update or skip to every existing arc, and add a create entry for any genuinely new behavioral pattern the existing arcs do not cover.`;
 /** The arc-execute user turn for one arc. `current` is absent on a create. */
 const arcExecutePrompt = (input) => (input.current === void 0 ? `${dataBlock("new_arc_title", input.title)}\n\n` : `${dataBlock("existing_arc", input.current)}\n\n`) + `${dataBlock("evidence", input.evidenceText)}\n\n${dataBlock("triage_rationale", input.rationale)}\n\n` + (input.current === void 0 ? "Synthesize a new behavioral principal from this evidence." : "Update the arc to incorporate the new evidence, preserving existing knowledge that holds.");
-/** The compress user turn for one batch: every member's text, wrapped, under its offered key. */
-const compressPrompt = (members) => `${members.map((member) => dataBlock(`member_${member.key}`, member.text)).join("\n\n")}\n\nFold these memories into one canonical memory. List in absorbedKeys exactly the members whose content the canonical carries forward.`;
+/** The instruction that closes a compress batch's user turn, after the member list. */
+const COMPRESS_INSTRUCTION = "Fold these memories into one canonical memory. List in absorbedKeys exactly the members whose content the canonical carries forward.";
 /**
-* Run one model call in isolation: a failure becomes `undefined` and a counted skip.
+* The compress user turn for one batch: every member's text, wrapped, under its offered key.
 *
-* This is the per-item posture the packet's §4 requires, expressed with `Effect.result` because
-* `Effect.either` does not exist in this beta. One violation skips its item and leaves
-* the phase running. A night that judged 199 pairs and lost the 200th to a malformed tool payload has
-* done 199 pairs of work, and failing the phase would throw all of it away.
+* `batchPrompt` from the kernel builds the member list and appends the instruction, so this produces
+* the same bytes it did when the framing was inline here. Kept as a named function because the
+* instruction belongs beside {@link COMPRESS_SYSTEM}, which is the other half of what the model is
+* told.
 */
-const isolate = (label, call) => Effect.gen(function* () {
-	const outcome = yield* Effect.result(call);
-	if (Result.isSuccess(outcome)) return outcome.success;
-	yield* Effect.logWarning(`sleep.llm ${label} skipped: ${outcome.failure.reason}`);
-});
+const compressPrompt = (members) => batchPrompt(members, COMPRESS_INSTRUCTION);
+/** The instruction that closes a dedup batch's user turn, after the components. */
+const DEDUP_INSTRUCTION = "Within each component above, group the members that are the same memory stated more than once. Name each group's members by the keys they were offered under. Return groups: [] if no component holds a duplicate.";
+/**
+* The dedup user turn for one packed batch: each component's members, wrapped, under a header that
+* names which keys sit in that component.
+*
+* **The component boundary is in the prompt because it is EVIDENCE.** Two members in different
+* components have already been measured as not near-duplicates, by a cosine floor and a frame-key
+* lookup, and a flat member list would throw that away and ask the model to rediscover it across the
+* whole batch. Packing ten components into one call is a cost decision; letting them blur into one
+* list would make it a correctness one.
+*
+* The headers are built from the OFFERED KEYS alone, never from a path or a title, so a header
+* carries nothing a member's own text could have chosen. `memberList` still wraps every member's
+* text, so the injection boundary is per member and the framing around it holds no corpus bytes.
+*
+* A containment claim in the prompt is not a containment guarantee: the phase re-checks that every
+* group the model returns sits inside ONE component, because the prompt is an instruction and the
+* post-pass is the enforcement.
+*/
+const dedupPrompt = (components) => {
+	return `${components.map((members, offset) => {
+		const keys = members.map((member) => member.key).join(", ");
+		return `component_${offset + 1} holds ${keys}.\n\n${memberList(members)}`;
+	}).join("\n\n")}\n\n${DEDUP_INSTRUCTION}`;
+};
 
 //#endregion
 //#region packages/sleep/dist/sql.js
@@ -9054,8 +9699,8 @@ const isolate = (label, call) => Effect.gen(function* () {
 * The memory type no phase of a sleep cycle touches.
 *
 * A task is live working state, and every one of the fifteen phases is a judgment about REMEMBERED
-* FACTS: decay says a claim is fading, dedup says two claims are one, conflict detection says two
-* claims disagree, retention says a claim has stopped earning its place. None of those hold for
+* FACTS: decay says a claim is fading, dedup says two claims are one, edge typing says one claim
+* caused or contradicts another, retention says a claim has stopped earning its place. None of those hold for
 * a thing an agent intends to do, and each would be wrong applied to one. A task the agent has
 * not got to yet is not a claim losing confidence, and two open tasks with the same body are two
 * things to do, not one fact stored twice.
@@ -9080,8 +9725,10 @@ const isSleepExcluded = (memoryType) => SLEEP_EXCLUDED_TYPES.includes(memoryType
 const activeCorpus = (db) => db.all(`SELECT path, memory_type, title, gist, body_text, content_hash, confidence, importance,
             word_count, created_at, updated_at, valid_until, reprieves
      FROM files WHERE archived = 0 ORDER BY created_at ASC, path ASC`);
+/** A `memory_type NOT IN (…)` clause against alias `f`, or nothing when nothing is excluded. */
+const typeFilterFor = (alias, excluded) => excluded.length === 0 ? "" : ` AND ${alias}.memory_type NOT IN (${excluded.map(() => "?").join(", ")})`;
 /**
-* Per-source top-`k` nearest neighbors above a similarity floor, over first-chunk vectors.
+* Every active file's first-chunk vector, decoded ONCE into the shape the pair kernel ranks.
 *
 * `ordinal = 0` collapses a file to its first chunk, not its best chunk. The format is one
 * fact per file, so almost every file is a single chunk. Taking the first keeps the pair set
@@ -9089,85 +9736,166 @@ const activeCorpus = (db) => db.all(`SELECT path, memory_type, title, gist, body
 * would make `(a, b)` a candidate while `(b, a)` is not, so which of two files was read first
 * would decide whether they merge.
 *
-* `ROW_NUMBER() OVER (PARTITION BY src ...)` is the per-source cap. `vector_distance_cos` takes two
-* STORED blobs here instead of a blob and a bound parameter. It can, because it is a registered
-* SQL function over two `Uint8Array` arguments (`packages/index/src/database.ts`) and not a driver
-* builtin with a fixed calling shape.
+* A row whose blob does not decode (empty or ragged) is dropped, the same exclusion the SQL
+* UDF's NULL produces for it in the retrieval arm.
 */
-const neighborPairs = (db, options) => {
-	const excluded = options.excludeTypes ?? [];
-	const typeFilter = excluded.length === 0 ? "" : ` AND f.memory_type NOT IN (${excluded.map(() => "?").join(", ")})`;
-	return db.all(`WITH vecs AS (
-       SELECT f.path AS path, e.vec AS vec
+const firstChunkVectors = (db, excluded) => db.all(`SELECT f.path AS path, e.vec AS vec
        FROM files f
        JOIN chunks c ON c.path = f.path AND c.ordinal = 0
        JOIN embeddings e ON e.chunk_id = c.chunk_id
-       WHERE f.archived = 0${typeFilter}
-     ),
-     pairs AS (
-       SELECT l.path AS src, r.path AS dst, 1 - vector_distance_cos(l.vec, r.vec) AS sim
-       FROM vecs l JOIN vecs r ON r.path <> l.path
-     ),
-     ranked AS (
-       SELECT src, dst, sim, ROW_NUMBER() OVER (PARTITION BY src ORDER BY sim DESC, dst ASC) AS k
-       FROM pairs WHERE sim >= ?
-     )
-     SELECT src, dst, sim FROM ranked WHERE k <= ? ORDER BY sim DESC, src ASC, dst ASC LIMIT ?`, [
-		...excluded,
-		options.floor,
-		options.perSourceK,
-		options.limit
-	]);
-};
+       WHERE f.archived = 0${typeFilterFor("f", excluded)}`, [...excluded]).pipe(Effect.map((rows) => rows.flatMap((row) => {
+	const vec = float32View(row.vec);
+	return vec === void 0 ? [] : [{
+		key: row.path,
+		vec
+	}];
+})));
+/**
+* Per-source top-`k` nearest neighbors above a similarity floor, over first-chunk vectors.
+*
+* The corpus filter is SQL, because that is where the index's reading semantics live. The pair
+* space is n² and ranks in TypeScript (`topNeighborPairs`), because a pair routed through the
+* `vector_distance_cos` UDF pays a fresh decode of BOTH 4 KB blobs per call — at a ~3k corpus
+* that is 8.45M calls and an OOM before the first phase records (issue #40), against ~12 MB
+* decoded once. The kernel reproduces this ordering exactly: floor, then per-source `sim` DESC /
+* `dst` ASC, then global `sim` DESC / `src` ASC / `dst` ASC, then the cap.
+*/
+const neighborPairs = (db, options) => firstChunkVectors(db, options.excludeTypes ?? []).pipe(Effect.map((vectors) => topNeighborPairs(vectors, {
+	floor: options.floor,
+	perSourceK: options.perSourceK,
+	limit: options.limit
+})));
 /**
-* Candidate pairs for conflict detection: embedding-near, sharing an entity, and carrying no
+* Active non-task pairs that occupy the SAME frame key. Dedup's component seeds.
+*
+* A frame key is a claim's slot as surface grammar states it, so two active memories sharing one are
+* making a claim about the same thing by the corpus's own indexed evidence — no cosine, no model.
+* That is signal the vector floor can miss: "the owner of the deploy runbook is Priya" and "the owner
+* of the deploy runbook is Priya Raman" share a slot while their bodies share almost no vocabulary,
+* and their measured cosine under the fixture embedder is 0.59, far under any floor a night could
+* afford to mine at. Seeding components with these pairs puts them in front of the model, which is
+* the only reader that can say whether one is a rewording of the other.
+*
+* **The statement is OUTPUT-SENSITIVE: its cost follows the frame sharing that exists, not the pair
+* space.** The self-join is an equality on `frame_key`, which `files_frame_key_active` indexes under
+* exactly this predicate (`archived = 0 AND memory_type <> 'task' AND frame_key IS NOT NULL`,
+* migration 0009). So each row seeks its own key's bucket and emits one row per co-occupant, and a
+* corpus where no two memories share a slot emits nothing having read no pairs. `frame_key IS NOT
+* NULL` is stated even though the join equality already excludes NULL, because it is what makes the
+* partial index usable rather than leaving the planner to prove it.
+*
+* `r.path < l.path` orients each unordered pair once, which keeps the seed set the same size as the
+* edge set the component builder wants.
+*
+* **`memory_type <> 'task'` is written as the LITERAL the index uses, not as this module's
+* {@link SLEEP_EXCLUDED_TYPES} binding.** It is the same exclusion for the same reason — two open
+* tasks phrased alike are two things to do — but `NOT IN (?)` and `<> 'task'` are different
+* expressions to the planner, and only the second one matches `files_frame_key_active`'s predicate.
+* A bound form here would read as more general while quietly turning the seek into a scan.
+* `activeFramesFor` writes the literal for the same reason. `tests/units.test.ts` holds the two in
+* agreement, so a change to the excluded set cannot leave this statement behind silently.
+*
+* Measured plan (2026-08-19, node 24.19.0 against the shipped migrations): `SCAN l` then
+* `SEARCH r USING INDEX files_frame_key_active (frame_key=?)`. One side walks the KEYED rows, which
+* the partial index confines to the rows with a frame at all, and the other seeks.
+*/
+const frameKeyPairs = (db) => db.all(`SELECT l.path AS src, r.path AS dst
+     FROM files l
+     JOIN files r ON r.frame_key = l.frame_key AND r.path < l.path
+       AND r.archived = 0 AND r.memory_type <> 'task' AND r.frame_key IS NOT NULL
+     WHERE l.archived = 0 AND l.memory_type <> 'task' AND l.frame_key IS NOT NULL
+     ORDER BY l.path ASC, r.path ASC`);
+/**
+* Candidate pairs for edge typing: embedding-near, sharing an entity, and carrying no
 * AUTHORED edge between them in either direction.
 *
 * The shared-entity requirement is what keeps the model budget on pairs that could actually be about
-* one thing. The anti-join keeps the phase from re-judging a pair an agent already linked. An
-* authored `contradicts` is a settled fact, and re-asking the model about it would let a `neutral`
-* answer look like new information.
+* one thing. The anti-join keeps the phase from re-typing a pair an agent already linked. An
+* authored `contradicts` or `caused_by` is a settled fact, and re-asking the model about it would let
+* a `none` answer look like new information.
 *
 * **`derived = 0` is what makes the anti-join correct.** Relationship mining runs one phase EARLIER and
 * writes a derived `relates_to` for every pair above 0.85 cosine, a strict superset of the
-* pairs above the 0.80 conflict floor. An anti-join over ALL edges therefore excludes every candidate
-* this phase exists to find, and the phase reports `candidates: 0` forever with no error anywhere.
+* pairs above the 0.80 typing floor. An anti-join over ALL edges therefore excludes every candidate
+* this scan exists to find, and the phase reports `candidates: 0` forever with no error anywhere.
 * A mined edge is a machine suspicion, not a settled relationship; only an authored one closes a pair.
+* {@link minedPairs} reads that same mined set as the OTHER arm of edge typing's candidate union, and
+* carries the identical anti-join for the identical reason.
+*
+* The statement ENUMERATES pairs from the shared-entity join instead of filtering an n×n vector
+* self-join, so its cost follows the entity sharing that actually exists. Similarity then ranks in
+* TypeScript over vectors decoded once (`rankCandidatePairs`), with the enumerated set standing
+* where the ranking CTE's `WHERE` stood: the predicates run BEFORE per-source top-`k`. `re.path <
+* le.path` orients each pair once, dst below src.
 */
-const conflictCandidates = (db, options) => {
+const sharedEntityPairs = (db, options) => {
 	const excluded = options.excludeTypes ?? [];
-	const typeFilter = excluded.length === 0 ? "" : ` AND f.memory_type NOT IN (${excluded.map(() => "?").join(", ")})`;
-	return db.all(`WITH vecs AS (
-       SELECT f.path AS path, e.vec AS vec
-       FROM files f
-       JOIN chunks c ON c.path = f.path AND c.ordinal = 0
-       JOIN embeddings e ON e.chunk_id = c.chunk_id
-       WHERE f.archived = 0${typeFilter}
-     ),
-     pairs AS (
-       SELECT l.path AS src, r.path AS dst, 1 - vector_distance_cos(l.vec, r.vec) AS sim
-       FROM vecs l JOIN vecs r ON r.path < l.path
-       WHERE EXISTS (
-         SELECT 1 FROM file_entities le
-         JOIN file_entities re ON re.entity_type = le.entity_type AND re.entity_name = le.entity_name
-         WHERE le.path = l.path AND re.path = r.path
-       )
+	const pairs = db.all(`SELECT DISTINCT le.path AS src, re.path AS dst
+     FROM file_entities le
+     JOIN file_entities re ON re.entity_type = le.entity_type
+       AND re.entity_name = le.entity_name AND re.path < le.path
+     JOIN files fl ON fl.path = le.path AND fl.archived = 0${typeFilterFor("fl", excluded)}
+     JOIN files fr ON fr.path = re.path AND fr.archived = 0${typeFilterFor("fr", excluded)}
+     WHERE NOT EXISTS (
+       SELECT 1 FROM edges e
+       WHERE e.derived = 0
+         AND ((e.src_path = le.path AND e.dst_path = re.path)
+           OR (e.src_path = re.path AND e.dst_path = le.path))
+     )`, [...excluded, ...excluded]);
+	return Effect.all([pairs, firstChunkVectors(db, excluded)]).pipe(Effect.map(([candidatePairs, vectors]) => rankCandidatePairs(candidatePairs, vectors, {
+		floor: options.floor,
+		perSourceK: options.perSourceK,
+		limit: options.limit
+	})));
+};
+/**
+* The MINED edges of one rel, as candidate pairs: edge typing's second arm.
+*
+* Relationship mining runs one phase earlier and writes a derived `relates_to` for every pair above
+* its cosine floor, index-only. Those pairs are the corpus's own answer to "which memories look
+* related", and they are NOT a subset of {@link sharedEntityPairs}: two memories about one incident
+* that name no entity in common are invisible to the shared-entity join and obvious to the embedder.
+* Reading them here is what makes edge typing's recall the union of both signals rather than the
+* entity-authoring habits of whoever wrote the memories.
+*
+* `strength` is the mined edge's own cosine (`replaceMinedEdges` clamps it into `[0, 1]`), so the
+* caller can rank both arms of the union on one scale without re-decoding a vector. The statement
+* ORDERS BY it, descending, for the same reason {@link sharedEntityPairs} hands back a ranked list:
+* the caller's cap is a model-cost bound, and a cap over a path-ordered read would spend the night on
+* whichever pairs sort alphabetically first. `src_path` then `dst_path` break a tie, which is
+* `collectRanked`'s ordering, so both arms of the union arrive in one ordering.
+*
+* **Deliberately unbounded**, unlike the other arm: the caller ranks the UNION and caps that, so a
+* limit here would cut candidates before the two arms have been compared. The mined set is one row per
+* pair above mining's cosine floor (measured 1,498 on the production corpus), which is a read this
+* phase already performs once a night.
+*
+* Three filters, each load-bearing:
+*
+* - `derived = 1` restricts this to the machine-mined set. An authored `relates_to` is an agent's
+*   assertion, and re-typing it would let a nightly job overwrite a human judgment with a narrower rel.
+* - `edge_class = 'memory'` is the same firewall every graph read carries.
+* - The `derived = 0` anti-join drops a pair that already carries ANY authored edge either way, which
+*   is exactly {@link sharedEntityPairs}' rule. Without it a pair typed last night would be re-judged
+*   every night, because promoting a typed edge does not delete the mined `relates_to` underneath it.
+*/
+const minedPairs = (db, options) => {
+	const excluded = options.excludeTypes ?? [];
+	return db.all(`SELECT e.src_path AS src, e.dst_path AS dst, e.strength AS sim
+     FROM edges e
+     JOIN files fs ON fs.path = e.src_path AND fs.archived = 0${typeFilterFor("fs", excluded)}
+     JOIN files fd ON fd.path = e.dst_path AND fd.archived = 0${typeFilterFor("fd", excluded)}
+     WHERE e.derived = 1 AND e.edge_class = 'memory' AND e.rel = ?
        AND NOT EXISTS (
-         SELECT 1 FROM edges e
-         WHERE e.derived = 0
-           AND ((e.src_path = l.path AND e.dst_path = r.path)
-             OR (e.src_path = r.path AND e.dst_path = l.path))
+         SELECT 1 FROM edges a
+         WHERE a.derived = 0
+           AND ((a.src_path = e.src_path AND a.dst_path = e.dst_path)
+             OR (a.src_path = e.dst_path AND a.dst_path = e.src_path))
        )
-     ),
-     ranked AS (
-       SELECT src, dst, sim, ROW_NUMBER() OVER (PARTITION BY src ORDER BY sim DESC, dst ASC) AS k
-       FROM pairs WHERE sim >= ?
-     )
-     SELECT src, dst, sim FROM ranked WHERE k <= ? ORDER BY sim DESC, src ASC, dst ASC LIMIT ?`, [
+     ORDER BY e.strength DESC, e.src_path ASC, e.dst_path ASC`, [
+		...excluded,
 		...excluded,
-		options.floor,
-		options.perSourceK,
-		options.limit
+		options.rel
 	]);
 };
 /**
@@ -9204,6 +9932,62 @@ const pathsForEntity = (db, entityType, entityName) => db.all(`SELECT e.path AS
 /** `?` per excluded type, so the exclusion binds instead of interpolating a value into SQL. */
 const typePlaceholders = () => SLEEP_EXCLUDED_TYPES.map(() => "?").join(", ");
 /**
+* Every (entity, claiming active non-task file) pair in ONE statement, entity-ordered then path.
+*
+* The same corpus {@link activeEntities} counts, enumerated instead of aggregated. Entity resolution
+* needs both a per-entity memory centroid and a few sample titles per entity, and deriving either from
+* {@link pathsForEntity} would be one query per entity — 59 entities on the measured corpus, and one
+* round trip each for a join the database performs once.
+*
+* **The `ORDER BY` is for a reader, NOT for the centroid's determinism.** A centroid is a sum over its
+* members' vectors and float addition is not associative, so the summation order decides the bytes —
+* but `entityCentroids` re-sorts each entity's paths itself and does not inherit this order. That is
+* deliberate: the guarantee has to live where the sum happens, so a future caller reading these rows
+* through a different statement cannot silently lose it. (Confirmed by mutation: replacing this clause
+* with `ORDER BY e.path DESC` leaves the whole sleep suite green, while dropping the phase's own sort
+* fails it.)
+*/
+const entityClaims = (db) => db.all(`SELECT e.entity_type AS entity_type, e.entity_name AS entity_name,
+            e.path AS path, f.title AS title
+     FROM file_entities e JOIN files f ON f.path = e.path
+     WHERE f.archived = 0 AND f.memory_type NOT IN (${typePlaceholders()})
+     ORDER BY e.entity_type ASC, e.entity_name ASC, e.path ASC`, [...SLEEP_EXCLUDED_TYPES]);
+/**
+* Every active file's first-chunk vector, path-keyed and decoded once. The centroid pass's input.
+*
+* Exported wrapper over the module-private statement the pair arms use, so entity resolution reads the
+* SAME vector space they do — `ordinal = 0`, the same drop of a blob that does not decode — instead of
+* a second SELECT free to disagree about which chunk represents a file.
+*
+* Tasks are excluded, matching {@link entityClaims}: a centroid built partly from working state would
+* describe what the agent intends to do about a subject rather than what it knows about one.
+*/
+const entityVectors = (db) => firstChunkVectors(db, SLEEP_EXCLUDED_TYPES);
+/**
+* Every indexed person file, path-ordered. The alias oracle's file list.
+*
+* Selected by DIRECTORY, because that is what a person file is: `person-links` mints one per
+* `person:` entity under `PEOPLE_DIR`, and a hand-authored one placed there by an operator is just as
+* authoritative. Selecting by entity instead would miss a file whose subject the corpus has since
+* stopped mentioning, whose declaration is still the truth about those names.
+*
+* Archived files are included. Archiving a person file records that the corpus moved on from the
+* person, not that two of their names stopped being the same name, and an alias declaration losing its
+* force on archival would silently re-split a person the phase had already merged.
+*
+* **Which is why the archive prefix is matched too, and not just `archived = 0` left off.** Eviction is
+* the `git mv` into `archive/<YYYY>/<original-path>`, so an archived person file's PATH is
+* `archive/2026/resources/people/…` and no longer matches `resources/people/%` at all. A single
+* `LIKE` here would have said "archived files are included" while excluding every one of them, and the
+* re-split above is exactly what would have followed. The second pattern mirrors
+* `archivePathFor`'s shape (`%` for the year segment, which is four digits the statement need not
+* verify — a false match would be another file under `resources/people/`, which is a person file).
+*
+* The phase reads the BYTES of each of these; this statement only says which paths to open, because
+* `memhtml-alias` is repeatable and lives in the file rather than in any projection.
+*/
+const peoplePaths = (db) => db.all("SELECT path FROM files WHERE path LIKE ? OR path LIKE ? ORDER BY path ASC", [`${PEOPLE_DIR}/%`, `${ARCHIVE_BUCKET}/%/${PEOPLE_DIR}/%`]);
+/**
 * The memory-class edge list over active files, both authored and derived.
 *
 * `edge_class = 'memory'` is the firewall. A person or provenance edge cannot enter PageRank, label
@@ -9241,7 +10025,7 @@ const accessRows = (db) => db.hasState ? db.all(`SELECT path, access_count, rein
 * one pair cannot both read `detections = 1` and both decline to promote.
 *
 * **The bump is idempotent WITHIN one run's instant.** `detections` advances only when `updated_at`
-* differs from `at`. Corroboration means "two DIFFERENT nights saw this", and conflict detection
+* differs from `at`. Corroboration means "two DIFFERENT nights saw this", and edge typing
 * commits only when something is promoted, so a run that judged pairs and promoted nothing leaves no
 * trailer and `memhtml sleep resume` re-executes it. Without the guard that second pass would count as a
 * second detection and promote a contradiction one night's evidence had not earned. That puts a machine
@@ -9269,6 +10053,47 @@ const markPromoted = (db, input) => db.run(`UPDATE ${STATE_SCHEMA}.edge_corrobor
 	input.rel,
 	input.dstPath
 ]);
+/**
+* Bump an entity merge's detection counter and read the result back.
+*
+* The same `RETURNING` upsert {@link bumpCorroboration} uses, for the same reason: the promotion
+* decision is made in the database at the instant of the write, so two runs racing on one merge cannot
+* both read `detections = 1` and both decline to apply it, leaving a genuinely corroborated merge
+* pending forever.
+*
+* **And the bump is idempotent WITHIN one run's instant**, which entity resolution needs even more than
+* conflict detection does. This phase commits whenever it rewrites ANY file, so a night whose only work
+* was a deterministic normalization commits and leaves a trailer, while a night that only bumped
+* counters does not. `memhtml sleep resume` therefore re-executes this phase on the second pass, and
+* without the `updated_at` guard that pass would count as a second night's independent sighting and
+* apply a merge one night's evidence had not earned. `at` comes from the run's own date, so a resume of
+* the same run reuses it and a genuinely later night does not.
+*
+* Names are the NORMALIZED forms, which is what makes one merge one counter: `Checkout API` and
+* `checkout api` would otherwise be two rows for one merge and neither would reach two detections.
+*/
+const bumpEntityCorroboration = (db, input) => db.all(`INSERT INTO ${STATE_SCHEMA}.entity_corroboration
+       (entity_type, alias_name, canonical_name, detections, updated_at)
+     VALUES (?, ?, ?, 1, ?)
+     ON CONFLICT(entity_type, alias_name, canonical_name) DO UPDATE SET
+       detections = detections + CASE
+         WHEN entity_corroboration.updated_at = excluded.updated_at THEN 0 ELSE 1 END,
+       updated_at = excluded.updated_at
+     RETURNING entity_type, alias_name, canonical_name, detections, promoted`, [
+	input.entityType,
+	input.aliasName,
+	input.canonicalName,
+	input.at
+]);
+/** Mark a corroborated merge applied, so a later night reads it as done instead of pending. */
+const markEntityPromoted = (db, input) => db.run(`UPDATE ${STATE_SCHEMA}.entity_corroboration
+     SET promoted = 1, confirmed = 1, updated_at = ?
+     WHERE entity_type = ? AND alias_name = ? AND canonical_name = ?`, [
+	input.at,
+	input.entityType,
+	input.aliasName,
+	input.canonicalName
+]);
 /** Sessions with no memory linked to them, which is what trace-consolidation counts in v1. */
 const unlinkedSessionCount = (db) => db.get(`SELECT count(*) AS n FROM traces t
        WHERE NOT EXISTS (SELECT 1 FROM memory_session_links l WHERE l.session_id = t.session_id)`).pipe(Effect.map((row) => row?.n ?? 0));
@@ -9731,6 +10556,12 @@ const arcSynthesis = (env) => Effect.gen(function* () {
 * Phase 10, compress. COMPRESS-band memories grouped by community, folded into a synthesized
 * canonical in batches. ONE COMMIT PER BATCH.
 *
+* The batching runs on the shared kernel in `batch.ts`: this phase sorts the communities and their
+* members, and `assembleBatches`, `keyMembers`, `compressPrompt`, and `resolveKeys` do the slicing,
+* the opaque keying, the prompt framing, and the key resolution that four other phases also need. The
+* kernel preserves the order it is handed and does no sorting of its own, so the two sorts below are
+* what make a night's batch boundaries and member keys reproducible.
+*
 * Grouped by community instead of by similarity, because a community is the graph's own answer to
 * "what belongs together". A similarity group folds two memories that happen to share vocabulary,
 * while a community folds memories the corpus itself has linked. Communities below the minimum size
@@ -9752,6 +10583,11 @@ const arcSynthesis = (env) => Effect.gen(function* () {
 */
 /** Members per model call. Small enough that every member's facts fit the answer's attention. */
 const COMPRESS_BATCH_SIZE = 8;
+/**
+* Members a batch needs before it is worth a call. A batch of one is not a fold: it would rewrite a
+* lone memory into a "canonical" saying the same thing under a new path, and archive the original.
+*/
+const COMPRESS_MIN_BATCH = 2;
 /** COMPRESS-band candidates considered per cycle. The model-cost guard. */
 const COMPRESS_CANDIDATE_LIMIT = 2e3;
 /** Characters of each member shown. A fold must see the facts, so this is wider than arc evidence. */
@@ -9776,14 +10612,16 @@ const compress = (env) => Effect.gen(function* () {
 		if (bucket === void 0) byCommunity.set(label, [entry]);
 		else bucket.push(entry);
 	}
-	const batches = [];
-	for (const [, members] of [...byCommunity.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
-		const ordered = [...members].sort((left, right) => left.row.path < right.row.path ? -1 : left.row.path > right.row.path ? 1 : 0);
-		for (let at = 0; at < ordered.length; at += 8) {
-			const slice = ordered.slice(at, at + 8);
-			if (slice.length >= 2) batches.push(slice);
-		}
-	}
+	/**
+	* Both sorts are this phase's, and the kernel keeps the order they produce. Communities are
+	* walked lexicographically by label so a night's call order is fixed, and each community's members
+	* by `row.path` so the `m1`..`mN` keys land on the same files twice over.
+	*/
+	const groups = [...byCommunity.entries()].sort(([left], [right]) => left < right ? -1 : 1).map(([, members]) => [...members].sort((left, right) => left.row.path < right.row.path ? -1 : left.row.path > right.row.path ? 1 : 0));
+	const batches = assembleBatches(groups, {
+		maxMembers: 8,
+		minMembers: 2
+	});
 	const counts = {
 		candidates: candidates.length,
 		communities: byCommunity.size,
@@ -9802,33 +10640,22 @@ const compress = (env) => Effect.gen(function* () {
 	let lastCommit = null;
 	for (const batch of batches) {
 		/** Opaque keys again, so `absorbedKeys` cannot name a path. */
-		const keyed = batch.map((entry, offset) => ({
-			key: `m${offset + 1}`,
-			path: entry.row.path,
-			title: entry.row.title,
-			text: `${entry.row.title}\n${entry.row.gist}\n${entry.row.body_text}`.slice(0, COMPRESS_MEMBER_CHARS)
-		}));
-		const pathForKey = new Map(keyed.map((entry) => [entry.key, entry.path]));
+		const keyed = keyMembers(batch, (entry) => `${entry.row.title}\n${entry.row.gist}\n${entry.row.body_text}`, { charBudget: COMPRESS_MEMBER_CHARS });
 		llmCalls += 1;
-		const synthesis = yield* isolate(`compress batch of ${batch.length}`, model.generateObject({
+		const synthesis = yield* batchCall(model, `compress batch of ${batch.length}`, {
 			schema: CompressSynthesis,
 			system: COMPRESS_SYSTEM,
-			prompt: compressPrompt(keyed.map((entry) => ({
-				key: entry.key,
-				text: entry.text
-			}))),
+			prompt: compressPrompt(keyed.keyed),
 			modelKey,
 			effort: "high",
 			toolDescription: "Emit the canonical memory and the members whose content it absorbs."
-		}));
+		});
 		if (synthesis === void 0) {
 			skipped += 1;
 			continue;
 		}
-		const absorbed = [...new Set(synthesis.absorbedKeys.flatMap((key) => {
-			const path = pathForKey.get(key);
-			return path === void 0 ? [] : [path];
-		}))];
+		/** A key the batch never offered resolves to nothing, so a fold reaches only offered files. */
+		const absorbed = resolveKeys(keyed, synthesis.absorbedKeys).map((entry) => entry.row.path);
 		if (absorbed.length < 2 || synthesis.title.trim() === "" || synthesis.claim.trim() === "") {
 			skipped += 1;
 			continue;
@@ -9976,190 +10803,190 @@ const confidenceDecay = (env) => Effect.gen(function* () {
 	};
 });
 
-//#endregion
-//#region packages/sleep/dist/phases/conflict-detection.js
-/**
-* Phase 6, conflict detection. An NLI stance judge over embedding-near same-entity pairs; a
-* corroborated contradiction is promoted into BOTH files and committed.
-*
-* Three stages, and keeping them separate is what makes the phase safe:
-*
-* 1. **Scan (SQL, no model).** Same-entity active pairs above {@link CONFLICT_COSINE_FLOOR} carrying
-*    no edge in either direction, capped at {@link CONFLICT_CANDIDATE_LIMIT}.
-* 2. **Judge (one model call per pair, isolated).** Each call is wrapped so one malformed tool
-*    payload skips its pair and is counted. A night that judged 199 pairs and lost the 200th has
-*    done 199 pairs of work; failing the phase would discard all of it.
-* 3. **Assert (deterministic, decided here and not by the model).** Only `verdict: "contradicts"` above
-*    the confidence floor bumps the corroboration counter, and only `detections >= 2` promotes the edge
-*    into the files. A single machine detection therefore cannot reach the retention penalty. The
-*    counter lives in the state plane and the penalty counts only `derived = 0` file-borne edges.
-*
-* **Detection only.** The phase asserts the contradiction and stops. It does not supersede, close a
-* `memhtml-valid-until`, or archive either side. Choosing the winner of a contradiction is a one-way
-* door on stored belief, and it belongs to an agent or a human, not to a nightly job.
-*/
-/** The moderate similarity floor a pair must clear to be worth a model call. */
-const CONFLICT_COSINE_FLOOR = .8;
-/** Nearest same-entity neighbors considered per source. */
-const CONFLICT_PER_SOURCE_K = 5;
-/** Pairs judged per cycle. The model-cost guard. */
-const CONFLICT_CANDIDATE_LIMIT = 200;
-/** Detections a machine-found contradiction needs before it is written into the files. */
-const PROMOTION_DETECTIONS = 2;
-const conflictDetection = (env) => Effect.gen(function* () {
-	const model = env.deps.model;
-	if (model === void 0) return {
-		...emptyOutcome({
-			candidates: 0,
-			judged: 0
-		}),
-		detail: "no model bound"
-	};
-	/**
-	* Tasks are out of the candidate set. "These two contradict" is a judgment about asserted
-	* facts, and a task asserts nothing. A model asked about two tasks would answer a question
-	* that has no true answer, and a promoted `contradicts` between them would be a memory-class
-	* edge with task endpoints written into both files.
-	*/
-	const candidates = yield* conflictCandidates(env.deps.db, {
-		floor: CONFLICT_COSINE_FLOOR,
-		perSourceK: 5,
-		limit: 200,
-		excludeTypes: SLEEP_EXCLUDED_TYPES
-	});
-	if (candidates.length === 0) return emptyOutcome({
-		candidates: 0,
-		judged: 0,
-		contradictions: 0,
-		promoted: 0,
-		skipped: 0
-	});
-	if (env.dryRun) return emptyOutcome({
-		candidates: candidates.length,
-		judged: 0,
-		contradictions: 0,
-		promoted: 0,
-		skipped: 0
-	});
-	const corpus = yield* activeCorpus(env.deps.db);
-	const textOf = new Map(corpus.map((row) => [row.path, `${row.gist}\n${row.body_text}`]));
-	const modelKey = modelFor(env.deps, "conflict-detection");
-	let judged = 0;
-	let contradictions = 0;
-	let promoted = 0;
-	let skipped = 0;
-	let llmCalls = 0;
-	for (const candidate of candidates) {
-		const textA = textOf.get(candidate.src);
-		const textB = textOf.get(candidate.dst);
-		if (textA === void 0 || textB === void 0) {
-			skipped += 1;
-			continue;
-		}
-		llmCalls += 1;
-		const judgment = yield* isolate(`conflict-detection pair ${judged + skipped}`, model.generateObject({
-			schema: StanceJudgment,
-			system: STANCE_SYSTEM,
-			prompt: stancePrompt(textA, textB),
-			modelKey,
-			effort: "medium",
-			toolDescription: "Emit the stance of memory B relative to memory A."
-		}));
-		if (judgment === void 0) {
-			skipped += 1;
-			continue;
-		}
-		judged += 1;
-		if (!assertsContradiction(judgment)) continue;
-		contradictions += 1;
-		const row = (yield* bumpCorroboration(env.deps.db, {
-			srcPath: candidate.src,
-			rel: "contradicts",
-			dstPath: candidate.dst,
-			at: env.at
-		}))[0];
-		if (row === void 0 || row.detections < 2 || row.promoted === 1) continue;
-		yield* stampFile(env, candidate.src, [link("contradicts", hrefFor(candidate.dst)), meta("memhtml-updated", env.at)]);
-		yield* stampFile(env, candidate.dst, [link("contradicts", hrefFor(candidate.src)), meta("memhtml-updated", env.at)]);
-		yield* markPromoted(env.deps.db, {
-			srcPath: candidate.src,
-			rel: "contradicts",
-			dstPath: candidate.dst,
-			at: env.at
-		});
-		promoted += 1;
-	}
-	const counts = {
-		candidates: candidates.length,
-		judged,
-		contradictions,
-		promoted,
-		skipped
-	};
-	if (promoted === 0) return {
-		counts,
-		commitSha: null,
-		llmCalls
-	};
-	return {
-		counts,
-		commitSha: yield* commitPhase(env, "conflict-detection", `promote ${promoted} corroborated contradictions`, counts),
-		llmCalls
-	};
-});
-
 //#endregion
 //#region packages/sleep/dist/phases/dedup-merge.js
 /**
 * Phase 2, dedup-merge. Fold near-duplicates: the keeper gains `memhtml-supersedes`, the dropped
 * files `git mv` into the archive. ONE commit.
 *
+* ## The model partitions; code decides
+*
+* With a model bound the phase mines a RECALL-oriented candidate set at {@link DEDUP_COMPONENT_FLOOR},
+* unions it with the frame-key exact matches, builds connected components over the union, and asks the
+* model to partition each component into merge groups. The model answers one question: which of these
+* memories are the same memory. It does not choose the canonical, it does not name a write target, and
+* it is never asked an n² pair question — a component of five is one entry in one batch's member list,
+* not ten pair calls.
+*
+* Everything the fold writes is derived afterwards. Orientation is arithmetic over corpus order, and
+* every pair a group implies is routed through `mergeCandidates`, which applies the divergence veto,
+* the self-merge check, the both-roles guard, and the per-night cap. So the set of pairs that CAN be
+* committed does not widen when a model is bound: it is the same predicate over a different candidate
+* set.
+*
 * **Orientation keeps the OLDER file.** That is why the divergence veto changes outcomes instead of
 * being cosmetic. A blind high-cosine merge of a newer correction into an older wrong memory does not
 * merely lose information, it restores the error the correction was written to fix. `activeCorpus`
 * reads oldest-first, so the older path is the keeper by construction and the choice is reproducible.
+* Inside a model-proposed group the keeper is the member with the lowest corpus offset, which is the
+* same rule applied to more than two files at once.
 *
 * **The veto and the in-batch role guard both live in `@memhtml/domain`.** `mergeCandidates` claims BOTH
 * roles for every committed pair. A path that was a keeper cannot later be dropped, and a path that
 * was dropped cannot later become a keeper. The predecessor memory system recorded only the drop side, so given
 * `(gf → a)` then `(b → gf)` both decisions committed: `gf` absorbed `a` and was then archived into
-* `b`, superseding `a`'s content into a file the same batch destroyed.
+* `b`, superseding `a`'s content into a file the same batch destroyed. Batching makes that guard carry
+* MORE, not less: one model answer names several groups, and two groups overlapping on one path is
+* exactly that chain, arriving from one call instead of from two nights.
+*
+* **With no model bound the phase is the deterministic floor, unchanged.** It mines at
+* {@link NEAR_DUPLICATE_THRESHOLD}, orients, and hands the pairs to `mergeCandidates`. That is not a
+* degraded mode to be repaired later: a night with no credentials still folds every duplicate a cosine
+* can prove, and every count it reports is what this phase reported before it could call a model.
+*
+* ## Precedence between the two candidate sets
+*
+* Model groups are offered to `mergeCandidates` FIRST, then the mined pairs above the deterministic
+* floor that no group already claimed. Two properties follow, and both are the reason for the order:
+*
+* - The deterministic floor never regresses. Every pair the no-model path would have merged is still
+*   in the list, so binding a model cannot make a night fold less than it did.
+* - Where the two disagree the semantic answer wins the path. A pair above 0.92 whose two files the
+*   model instead grouped with a third folds as the model's group, because the both-roles guard gives
+*   a path to whichever decision claims it first. The model read both files; the cosine read neither.
+*
+* Within each half the order is fixed: groups follow the batch, component, and group order they were
+* packed and answered in, and mined pairs stay in the kernel's `sim` DESC ordering.
 *
 * One commit for the whole batch, not one per pair. A keeper's `memhtml-supersedes` points at its
 * dropped file's ARCHIVE path, which is where that file lives only after this commit lands.
 * Splitting them would create a dangling href in the commit that made it dangle.
 */
+/**
+* The mining floor when a model is bound. RECALL-oriented, and deliberately below the merge floor.
+*
+* A pair between this and {@link NEAR_DUPLICATE_THRESHOLD} is one no cosine can settle: high enough
+* that the two memories are about one thing, not high enough that they are provably one claim. That
+* band is what a semantic reader is for, and the deterministic path cannot see into it at all. Issue
+* #43 measured ~800 pairs at 0.86 on the 2,907-memory production corpus against 77 at 0.92, and those
+* 800 collapse into components small enough that {@link DEDUP_MAX_COMPONENTS} bounds the night at tens
+* of calls rather than hundreds.
+*
+* The floor is only a floor. A pair that clears it still has to survive the model's partition and then
+* the veto, so more recall here cannot lower the bar on what gets written.
+*/
+const DEDUP_COMPONENT_FLOOR = .86;
+/**
+* Mined pairs considered per night at the recall floor.
+*
+* `MAX_MERGE_PAIRS * 8`, twice the deterministic path's `* 4`, because the floor moved down and the
+* pair count grows with the band while the commit cap does not move: no more than `MAX_MERGE_PAIRS`
+* folds land whatever this admits, so the multiplier buys candidate COVERAGE and cannot buy extra
+* writes. Issue #43's measurement is the sizing — ~800 pairs at 0.86 against 800 here — so a corpus of
+* that shape is mined whole and a larger one is truncated at a bound that is stated rather than
+* emergent.
+*/
+const DEDUP_PAIR_LIMIT = 100 * 8;
+/**
+* Files of one component that reach a model call. A larger component is TRUNCATED to its lowest paths.
+*
+* Eight is above the size a real near-duplicate family reaches — a fact restated eight times is
+* already pathological — so a component past it is almost always the recall floor having chained
+* several distinct facts through shared vocabulary. Handing all of it over would spend one call's whole
+* attention budget on the component least likely to hold a clean duplicate, and a model asked to
+* partition thirty loosely-related memories answers with a few large groups, which is the answer shape
+* the veto is least able to correct.
+*
+* Truncation keeps the LOWEST PATHS rather than the highest cosines, so which members are considered
+* is a property of the corpus and not of the floor. The remainder is deferred, not lost: the night's
+* folds change the graph, so tomorrow's components over the same corpus are smaller.
+*/
+const DEDUP_MAX_COMPONENT = 8;
+/**
+* Components handed to a model per night. The cost bound.
+*
+* Set so a night lands in issue #43's measured envelope of ~15-25 calls: at
+* {@link DEDUP_BATCH_MEMBERS} members per call and a typical component of two, 300 components pack
+* into roughly 15 calls, and the per-call character budget closes some earlier. Components are taken
+* in component order, which is lowest-path first, so which ones a capped night considers is
+* reproducible.
+*/
+const DEDUP_MAX_COMPONENTS = 300;
+/**
+* Members per dedup call. Wider than compress's 8 because the question is cheaper per member.
+*
+* compress asks the model to WRITE one canonical carrying every member's facts, so each member has to
+* fit the answer's generative attention. Dedup asks only which members restate each other and the
+* answer is a list of keys, so one batch can hold several components' worth.
+*/
+const DEDUP_BATCH_MEMBERS = 40;
+/** Characters of each member shown. The house member budget, the same 1200 compress uses. */
+const DEDUP_MEMBER_CHARS = 1200;
+/**
+* Characters per dedup call: the member budget times the member cap.
+*
+* Derived rather than chosen, so the two caps cannot drift into a call that honors one and breaches
+* the other. It is a CEILING and normally slack, because most members are far shorter than their
+* budget, which is why `packGroups` takes both bounds and closes on whichever binds first.
+*/
+const DEDUP_BATCH_CHARS = DEDUP_MEMBER_CHARS * 40;
+/**
+* The threshold the batched arm hands `mergeCandidates`, which must NOT re-gate on similarity.
+*
+* Admission on that arm is already decided when the filter runs. A group pair got there because the
+* model grouped it, and a mined pair got there because it cleared {@link NEAR_DUPLICATE_THRESHOLD} in
+* the phase's own filter. What is left for `mergeCandidates` to apply is the veto, the self check, the
+* both-roles guard, and the cap — the four that are about safety rather than about a number.
+*
+* Zero rather than {@link DEDUP_COMPONENT_FLOOR} because that comparison is STRICT (`<= threshold`
+* skips), and a group pair the corpus never mined carries the floor itself as its similarity. A
+* threshold of the floor would drop exactly the frame-seeded pairs that seeding exists to find, and it
+* would do it silently: the count would read as a veto. Nothing negative can reach here, since every
+* mined similarity is at or above the floor and the synthetic value IS the floor.
+*/
+const DEDUP_ADMIT_FLOOR = 0;
+/** The text a member is offered under: its claim and its body, the same join compress uses. */
+const textFor = (row) => `${row.gist}\n${row.body_text}`;
+/**
+* `arc` is excluded from the candidate set. An arc is a synthesis of many memories, so it is
+* embedding-near everything it summarizes, and merging one into a member would replace the
+* conclusion with one of its premises.
+*
+* `task` is excluded for the opposite reason: two open tasks with the same body are two things
+* to do, not one fact stored twice. Folding them would archive real work an agent still owes.
+* The `files_content_hash_active` index carves tasks out for the same reason, so structural and
+* semantic dedup agree about them.
+*/
+const EXCLUDED_TYPES = ["arc", ...SLEEP_EXCLUDED_TYPES];
 const dedupMerge = (env) => Effect.gen(function* () {
 	const corpus = yield* activeCorpus(env.deps.db);
 	const order = new Map(corpus.map((row, offset) => [row.path, offset]));
-	const textOf = new Map(corpus.map((row) => [row.path, `${row.gist}\n${row.body_text}`]));
-	/**
-	* `arc` is excluded from the candidate set. An arc is a synthesis of many memories, so it is
-	* embedding-near everything it summarizes, and merging one into a member would replace the
-	* conclusion with one of its premises.
-	*
-	* `task` is excluded for the opposite reason: two open tasks with the same body are two things
-	* to do, not one fact stored twice. Folding them would archive real work an agent still owes.
-	* The `files_content_hash_active` index carves tasks out for the same reason, so structural and
-	* semantic dedup agree about them.
-	*/
+	const rowFor = new Map(corpus.map((row) => [row.path, row]));
+	const textOf = new Map(corpus.map((row) => [row.path, textFor(row)]));
+	const model = env.deps.model;
 	const pairs = yield* neighborPairs(env.deps.db, {
-		floor: NEAR_DUPLICATE_THRESHOLD,
+		floor: model === void 0 ? NEAR_DUPLICATE_THRESHOLD : DEDUP_COMPONENT_FLOOR,
 		perSourceK: 5,
-		limit: 100 * 4,
-		excludeTypes: ["arc", ...SLEEP_EXCLUDED_TYPES]
+		limit: model === void 0 ? 100 * 4 : DEDUP_PAIR_LIMIT,
+		excludeTypes: EXCLUDED_TYPES
 	});
-	/** Orient each unordered pair once, older path as keeper, and drop the mirrored duplicate. */
+	/**
+	* Orient each unordered pair once, older path as keeper, and drop the mirrored duplicate. The
+	* kernel offers each pair to BOTH endpoints' neighborhoods, so `(a, b)` and `(b, a)` both arrive.
+	*/
 	const seen = /* @__PURE__ */ new Set();
 	const oriented = [];
+	/** `keepPath dropPath` -> the mined similarity, so a group can report a measured value. */
+	const simFor = /* @__PURE__ */ new Map();
 	for (const pair of pairs) {
 		const left = order.get(pair.src);
 		const right = order.get(pair.dst);
 		if (left === void 0 || right === void 0) continue;
 		const [keepPath, dropPath] = left <= right ? [pair.src, pair.dst] : [pair.dst, pair.src];
-		const key = `${keepPath}${dropPath}`;
+		const key = `${keepPath} ${dropPath}`;
 		if (seen.has(key)) continue;
 		seen.add(key);
+		simFor.set(key, pair.sim);
 		oriented.push({
 			keepPath,
 			dropPath,
@@ -10168,18 +10995,180 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			dropText: textOf.get(dropPath)
 		});
 	}
-	const decisions = mergeCandidates(oriented);
-	const vetoed = oriented.length - decisions.length;
+	if (model === void 0) {
+		/**
+		* The deterministic path: the mined pairs at 0.92, oriented, through the same filter under its
+		* own default threshold. Every count and every write here is what this phase produced before it
+		* could call a model, which is what makes the existing dedup tests an oracle for the rest.
+		*/
+		const decisions = mergeCandidates(oriented);
+		return yield* commitMerges(env, decisions, {
+			candidates: oriented.length,
+			components: 0,
+			llmGroups: 0,
+			vetoed: oriented.length - decisions.length
+		});
+	}
+	/**
+	* The component graph: the mined edges at the recall floor, unioned with the frame-key exact
+	* matches. A frame seed is an edge no cosine produced, so the union is what puts a slot collision
+	* in front of the model even when the two bodies share little vocabulary.
+	*/
+	const frameSeeds = yield* frameKeyPairs(env.deps.db);
+	const edges = [...oriented.map((pair) => [pair.keepPath, pair.dropPath]), ...frameSeeds.flatMap((pair) => {
+		/**
+		* A seed is filtered by the SAME type exclusion the mining arm passes to SQL. The frame index
+		* already carves out tasks, but not `arc` — and an arc shares a slot with any member it
+		* summarizes, so an unfiltered seed would put the conclusion in a component with its premise
+		* and invite the model to fold one into the other.
+		*/
+		const src = rowFor.get(pair.src);
+		const dst = rowFor.get(pair.dst);
+		if (src === void 0 || dst === void 0) return [];
+		if (EXCLUDED_TYPES.includes(src.memory_type) || EXCLUDED_TYPES.includes(dst.memory_type)) return [];
+		return [[pair.src, pair.dst]];
+	})];
+	/**
+	* Components of two or more are the units of work, truncated to {@link DEDUP_MAX_COMPONENT} at
+	* their lowest paths and capped at {@link DEDUP_MAX_COMPONENTS} per night. `connectedComponents`
+	* returns members sorted and components ordered by their smallest member, so both cuts are a
+	* function of the corpus rather than of how the edges were enumerated.
+	*/
+	const components = connectedComponents(edges).filter((members) => members.length >= 2).slice(0, 300).map((members) => members.slice(0, 8).flatMap((path) => {
+		const row = rowFor.get(path);
+		return row === void 0 ? [] : [row];
+	})).filter((members) => members.length >= 2);
+	/**
+	* Whole components per call, so no group's members are split across two answers. Splitting one
+	* would ask each half whether it holds a duplicate having hidden the other half.
+	*/
+	const batches = packGroups(components, {
+		maxMembers: 40,
+		maxChars: DEDUP_BATCH_CHARS,
+		charsOf: (row) => Math.min(textFor(row).length, DEDUP_MEMBER_CHARS)
+	});
+	const modelKey = modelFor(env.deps, "dedup-merge");
+	let llmCalls = 0;
+	let llmGroups = 0;
+	let skipped = 0;
+	/** Group-implied pairs, in batch then component then group order. */
+	const groupPairs = [];
+	/** Every path a surviving group claimed, so the mined arm cannot re-propose one. */
+	const grouped = /* @__PURE__ */ new Set();
+	for (const batch of batches) {
+		/**
+		* ONE keying across the whole batch, not one per component. Keys have to be unique inside the
+		* answer's namespace, and per-component keying would mint `m1` several times over — so a model
+		* naming `m1` would name several files and `resolveKeys` could not say which.
+		*/
+		const keyed = keyMembers(batch.flat(), textFor, { charBudget: DEDUP_MEMBER_CHARS });
+		/** Which component each offered key sits in. The containment check below reads this. */
+		const componentOfKey = /* @__PURE__ */ new Map();
+		const framed = [];
+		let cursor = 0;
+		for (const [offset, members] of batch.entries()) {
+			const slice = keyed.keyed.slice(cursor, cursor + members.length);
+			for (const member of slice) componentOfKey.set(member.key, offset);
+			framed.push(slice);
+			cursor += members.length;
+		}
+		llmCalls += 1;
+		const partition = yield* batchCall(model, `dedup batch of ${batch.length} components`, {
+			schema: MergePartition,
+			system: DEDUP_SYSTEM,
+			prompt: dedupPrompt(framed),
+			modelKey,
+			effort: "high",
+			toolDescription: "Emit the merge groups: within each component, the members that are the same memory."
+		});
+		if (partition === void 0) {
+			/**
+			* One call's failure costs its own components and nothing else. `dedup-merge` is a HARD
+			* prerequisite of compress and retention-triage, so failing the phase over one malformed tool
+			* payload would cancel two later phases as well as this one's whole night.
+			*/
+			skipped += 1;
+			continue;
+		}
+		for (const group of partition.groups) {
+			const members = resolveKeys(keyed, group.memberKeys);
+			if (members.length < 2) continue;
+			if (new Set(group.memberKeys.flatMap((key) => {
+				const id = componentOfKey.get(key);
+				return id === void 0 ? [] : [id];
+			})).size !== 1) continue;
+			/** The keeper is the OLDEST member: the lowest corpus offset, the same rule a pair uses. */
+			const sorted = [...members].sort((left, right) => (order.get(left.path) ?? 0) - (order.get(right.path) ?? 0));
+			const keeper = sorted[0];
+			if (keeper === void 0) continue;
+			llmGroups += 1;
+			for (const member of sorted.slice(1)) {
+				groupPairs.push({
+					keepPath: keeper.path,
+					dropPath: member.path,
+					/**
+					* The mined similarity when this pair was itself mined, else the floor. A frame-seeded
+					* pair and a transitive pair inside a component were never scored, and the floor is the
+					* honest value for "at least this near, never measured closer" — see
+					* {@link DEDUP_ADMIT_FLOOR} for why the filter must not compare against it.
+					*/
+					similarity: simFor.get(`${keeper.path} ${member.path}`) ?? .86,
+					keepText: textOf.get(keeper.path),
+					dropText: textOf.get(member.path)
+				});
+				grouped.add(member.path);
+			}
+			grouped.add(keeper.path);
+		}
+	}
+	/**
+	* Groups first, then the mined pairs above the DETERMINISTIC floor that no group claimed. The
+	* comparison is against 0.92 and not against the recall floor, so a pair in the recall band the
+	* model declined to group is not folded: the model's silence about it is the answer, and folding it
+	* anyway would make the recall floor the merge floor.
+	*/
+	const remaining = oriented.filter((pair) => pair.similarity > .92 && !grouped.has(pair.keepPath) && !grouped.has(pair.dropPath));
+	const proposed = [...groupPairs, ...remaining];
+	const decisions = mergeCandidates(proposed, { threshold: 0 });
+	return {
+		...yield* commitMerges(env, decisions, {
+			candidates: proposed.length,
+			components: components.length,
+			llmGroups,
+			vetoed: proposed.length - decisions.length,
+			skipped
+		}),
+		llmCalls
+	};
+});
+/**
+* Archive each drop, stamp each keeper, and commit once.
+*
+* Shared by both arms so the WRITES do not fork on whether a model was bound: the two differ in how
+* they choose pairs and in nothing else. A pair that reached here has already passed the veto, the self
+* check, the both-roles guard, and the cap, whichever arm proposed it.
+*
+* The counts are real on a dry run — including the veto — because an operator sizing a night needs to
+* know what it would have folded. Only the writes are withheld.
+*
+* **A dry run here DOES spend model calls, and `entity-resolution`'s deliberately does not.** The two
+* choices differ because what a preview is worth differs. The number an operator wants from this phase
+* is how many folds a real night would make, and the model's partition is what decides that — a dry run
+* that skipped the call would report only the deterministic floor's folds and understate the night it is
+* previewing. `entity-resolution` refuses because its writes are identity rewrites, the one-way door
+* this codebase guards hardest: its dry run would have to bump `entity_corroboration` to be honest about
+* night two, and a counter bumped by a run that wrote nothing is a night of evidence the corpus never
+* saw.
+*/
+const commitMerges = (env, decisions, base) => Effect.gen(function* () {
 	if (decisions.length === 0) return emptyOutcome({
-		candidates: oriented.length,
+		...base,
 		merged: 0,
-		vetoed,
 		vanished: 0
 	});
 	if (env.dryRun) return emptyOutcome({
-		candidates: oriented.length,
+		...base,
 		merged: decisions.length,
-		vetoed,
 		vanished: 0
 	});
 	let merged = 0;
@@ -10193,45 +11182,528 @@ const dedupMerge = (env) => Effect.gen(function* () {
 		yield* stampFile(env, decision.keepPath, [link("supersedes", hrefFor(archived)), meta("memhtml-updated", env.at)]);
 		merged += 1;
 	}
-	const counts = {
-		candidates: oriented.length,
+	const final = {
+		...base,
 		merged,
-		vetoed,
 		vanished
 	};
 	return {
-		counts,
-		commitSha: yield* commitPhase(env, "dedup-merge", `fold ${merged} near-duplicates into canonicals`, counts),
+		counts: final,
+		commitSha: yield* commitPhase(env, "dedup-merge", `fold ${merged} near-duplicates into canonicals`, final),
 		llmCalls: 0
 	};
 });
 
 //#endregion
-//#region packages/sleep/dist/phases/entity-resolution.js
+//#region packages/sleep/dist/phases/edge-typing.js
+/**
+* Phase 6, edge typing. Candidate pairs grouped and BATCHED, one structured verdict list per call
+* over the whole memory-rel vocabulary, then a deterministic promotion. One commit for the night's
+* promotions.
+*
+* Four stages, and keeping them separate is what makes the phase safe:
+*
+* 1. **Scan (SQL, no model).** The union of two candidate arms, deduplicated by unordered pair and
+*    RANKED BY SIMILARITY before the cap: relationship mining's derived `relates_to` edges
+*    ({@link minedPairs}) and the shared-entity scan ({@link sharedEntityPairs}). Neither arm
+*    subsumes the other — two memories about one incident naming no common entity are invisible to
+*    the join and obvious to the embedder, and a same-entity pair below the mining floor is the
+*    reverse — so recall is the union rather than whichever signal happens to be stronger in a
+*    corpus. Both arms exclude tasks and anti-join pairs that already carry an AUTHORED edge either
+*    way.
+* 2. **Batch (deterministic).** Pairs sorted by the directory both endpoints share, then sliced at
+*    {@link EDGE_PAIRS_PER_CALL} on the shared kernel, so topically related pairs land in one call.
+*    One call per batch, never one per pair: at the measured 1,498 mined pairs a night, per-pair
+*    judging is 1,498 calls and does not scale.
+* 3. **Judge (one model call per batch, isolated).** Each call is wrapped so one malformed tool
+*    payload skips its BATCH and is counted. A night that typed nine batches and lost the tenth has
+*    done nine batches of work; failing the phase would discard all of it.
+* 4. **Promote (deterministic, decided here and not by the model).** The model proposes a rel, a
+*    direction, and a confidence; code decides what is written:
+*    - `contradicts` above `EDGE_CONFIDENCE_FLOOR` bumps the corroboration counter and is
+*      written into BOTH files only at `detections >= 2`. A single machine detection therefore
+*      cannot reach the retention penalty, which counts only `derived = 0` file-borne edges. Both
+*      endpoints must still be in the TREE, checked before either write, and the counter is marked
+*      promoted only when both sides actually gained the link — otherwise the pair is left
+*      re-eligible for a later night rather than recorded as half done.
+*    - A DIRECTIONAL rel above the floor is written into the SUBJECT's file alone, per the
+*      direction the model named. No corroboration gate: a `part_of` carries no penalty and is
+*      cheap for a reviewer to delete, so a second night's wait would buy nothing.
+*    - `none`, or anything below the floor, writes nothing at all and leaves the pair a mined
+*      `relates_to`. That is the safe outcome and the one an unsure model is told to pick.
+*    - A verdict naming a key the batch never offered resolves to nothing and is dropped, so a
+*      hallucinated key cannot become a write. A pair the model omits is simply not typed tonight.
+*
+* **Determinism is the phase's, not the kernel's.** Both sorts below fix the batch boundaries and
+* the `m1`..`mN` keys, and the kernel preserves the order it is handed. Two runs over an unchanged
+* corpus therefore send the same prompt bytes in the same order.
+*
+* **Deferred: a `none` pair is re-judged on every later night, bounded by the candidate cap.** Neither
+* arm records that a pair was judged and answered `none`, so the pair stays a mined `relates_to` and
+* re-enters the union tomorrow. The cap is what bounds that cost — a night judges
+* {@link EDGE_TYPING_CANDIDATE_LIMIT} pairs whatever their history — and a judged-`none` watermark is
+* new durable state-plane surface, so it stays out of this change.
+*
+* **Detection only, still.** A promoted `contradicts` asserts the conflict and stops: nothing is
+* superseded, no `memhtml-valid-until` is closed, neither side is archived. Choosing the winner of a
+* contradiction is a one-way door on stored belief, and it belongs to an agent or a human, not to a
+* nightly job.
+*
+* This phase replaced `conflict-detection`, which asked one `generateObject` per pair for a stance
+* verdict over `{contradicts, entails, neutral}`. Contradiction is now one more verdict in the same
+* list, with the same corroboration gate. A run whose commits predate the rename carries
+* `Memhtml-Phase: conflict-detection` trailers, and `memhtml sleep resume` matches trailers by name,
+* so resuming a pre-rename run re-executes this phase; that is out of scope and costs a re-judge, not
+* a wrong write, because every write below is idempotent on its pair.
+*/
+/**
+* Pairs offered per model call.
+*
+* Sized for the answer's attention rather than for the context window: thirty pairs is sixty
+* memories, each sliced to {@link EDGE_PAIR_SIDE_CHARS}, and the model has to hold a distinct
+* judgment for each one. A batch twice this size buys half the calls and invites the model to answer
+* the first ten pairs carefully and the rest by pattern.
+*/
+const EDGE_PAIRS_PER_CALL = 30;
+/** The similarity floor a shared-entity pair must clear to be worth including. */
+const EDGE_COSINE_FLOOR = .8;
+/** Nearest same-entity neighbors considered per source, on the shared-entity arm. */
+const EDGE_PER_SOURCE_K = 5;
+/**
+* Pairs typed per cycle. The model-cost guard, unchanged from the per-pair phase's 200 even though
+* the calls are now ~7 instead of 200: the cap bounds how many AUTHORED EDGES one night can write
+* into the corpus, and that budget did not get cheaper because the judging did.
+*/
+const EDGE_TYPING_CANDIDATE_LIMIT = 200;
+/**
+* Characters of EACH SIDE of a pair shown. The house per-member budget, applied per side.
+*
+* A pair's member text holds two memories, so the kernel's per-member slice would cut the whole
+* `src` + `dst` block at one budget and could truncate `dst` away entirely on a long `src` — a
+* verdict about a pair whose second half the model never saw. Slicing each side first bounds the
+* pair at twice this and guarantees both halves are present.
+*/
+const EDGE_PAIR_SIDE_CHARS = 1200;
+/** Detections a machine-found contradiction needs before it is written into the files. */
+const PROMOTION_DETECTIONS = 2;
 /**
-* Phase 3, entity resolution. Normalize entity names, then fuzzy-merge transitive alias clusters.
-* ONE commit rewriting `memhtml-entity` values in place.
+* Authored edges one night may promote, across every batch and both kinds.
 *
-* Two passes. The first lowercases and collapses whitespace, and is idempotent, so a second run
-* touches nothing. The second is a union-find over pairs above {@link AUTO_MERGE_THRESHOLD}, so
-* `A~B` and `B~C` land in one cluster; the name held by the most active files wins the root, ties
-* broken lexicographically so a corpus that did not change resolves the same way twice.
+* The candidate cap bounds what is JUDGED and this bounds what is WRITTEN, and they are different
+* guards: a model that answered `caused_by` at confidence 1.0 for all 200 candidates would otherwise
+* add 200 `<link>` lines to the corpus in one commit, which is not a diff a human reviews. Hitting
+* the cap is visible as `capped` in the counts.
+*/
+const EDGE_PROMOTION_CAP = 50;
+/**
+* The union of both candidate arms, deduplicated by UNORDERED pair and ranked `sim` DESC.
 *
-* **Similarity is a normalized-string ratio, not an embedding cosine.** Entity names are short
-* identifiers such as `checkout-api`, `checkout_api`, and `Checkout API`, where the whole signal is
-* character overlap. An embedding of a two-token name is dominated by whatever domain the tokens evoke:
-* `checkout-api` and `payments-api` sit high in vector space because both are payment services, and
-* merging them would fuse two services' memories permanently. A character ratio cannot make that
-* mistake. This is the packet's documented choice between the two options it offered.
+* The two arms orient their pairs differently — the shared-entity join emits `dst < src` and a mined
+* edge carries whichever orientation mining wrote — so the dedup key sorts the endpoints. Without
+* that, one pair reaching both arms would be typed twice in one night, and the two verdicts could
+* disagree.
 *
-* The 0.75-0.85 band is COUNTED, not merged. A review candidate is a human's call, because entity
-* merges are a one-way door on stored identity and the failure mode of an over-eager threshold is
-* silent and permanent.
+* The kept row is the FIRST one seen, and the mined arm is walked first, so a pair in both arms
+* carries mining's own orientation AND mining's own `sim`. That choice is arbitrary, because the
+* direction the phase writes comes from the model's `direction` field relative to this orientation,
+* so it must only be STABLE, which the sort makes it.
+*
+* **`sim` DESC is what makes the candidate cap select rather than truncate.** Both arms carry a
+* similarity on one scale — `sharedEntityPairs` reports the cosine `rankCandidatePairs` computed and
+* `minedPairs` reports the mined edge's own clamped cosine — so the union is rankable without
+* re-decoding a vector. A path-ordered union capped at {@link EDGE_TYPING_CANDIDATE_LIMIT} would spend
+* the whole night's model budget on whichever pairs sort alphabetically first, so a corpus whose
+* strongest candidates live under `services/` or `team/` would never have them judged at all, however
+* many nights ran. The tie-break is `src` ASC then `dst` ASC, which is `collectRanked`'s ordering in
+* `@memhtml/domain` — the house rule every other pair consumer already follows, so two runs over an
+* unchanged corpus select and batch the same pairs.
 */
-/** At or above this ratio two names are the same entity. Auto-merged. */
+const unionPairs$1 = (arms) => {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const arm of arms) for (const pair of arm) {
+		const key = pair.src < pair.dst ? `${pair.src} ${pair.dst}` : `${pair.dst} ${pair.src}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(pair);
+	}
+	return out.sort((left, right) => {
+		if (left.sim !== right.sim) return left.sim < right.sim ? 1 : -1;
+		if (left.src !== right.src) return left.src < right.src ? -1 : 1;
+		return left.dst < right.dst ? -1 : left.dst > right.dst ? 1 : 0;
+	});
+};
+/**
+* The night's candidate pairs: the union of both arms, ranked `sim` DESC, then capped.
+*
+* The rank is {@link unionPairs}' and the cap is applied AFTER it, so the cap selects the strongest
+* {@link EDGE_TYPING_CANDIDATE_LIMIT} pairs the corpus offers rather than the alphabetically first
+* ones. That ordering is also the batch order's first input, so a night's strongest pairs are judged
+* even when the cap bites.
+*
+* Its own function so the SCAN is separable from the judging, and exported so a test asserting on a
+* batch boundary, a cap, or a skip count reads the same set the phase will type instead of
+* reconstructing it. A test that rebuilt this by hand would be a second implementation free to
+* disagree, and every count below is stated relative to it. The scan's own correctness has an
+* independent all-SQL oracle in `tests/neighbor-pairs.test.ts`; this is the composition of two
+* already-tested reads.
+*/
+const edgeTypingCandidates = (db) => Effect.gen(function* () {
+	const mined = yield* minedPairs(db, {
+		rel: "relates_to",
+		excludeTypes: SLEEP_EXCLUDED_TYPES
+	});
+	const shared = yield* sharedEntityPairs(db, {
+		floor: EDGE_COSINE_FLOOR,
+		perSourceK: 5,
+		limit: 200,
+		excludeTypes: SLEEP_EXCLUDED_TYPES
+	});
+	return unionPairs$1([mined, shared]).slice(0, 200);
+});
+/**
+* The grouping key for batching: the deepest directory both endpoints share, or `""` when they share
+* none.
+*
+* Deliberately NOT the graph community. `runRetentionPass` computes label propagation over the whole
+* memory-edge list plus PageRank plus the access plane, and this phase needs none of that — it would
+* be a second corpus-wide pass for a grouping hint, and it answers `undefined` for every pair in a
+* community below the size floor, which is most pairs in a small corpus. The shared directory is
+* already the corpus's own topical partition (`areas/deploy`, `areas/oncall`), it is a pure function
+* of two paths, and it puts related pairs in one call, which is all the batching needs from it. A
+* model shown thirty pairs from one area also has the area's context, which is the substantive half
+* of what community grouping was for.
+*/
+const pairGroupKey = (pair) => {
+	const left = pair.src.split("/");
+	const right = pair.dst.split("/");
+	const shared = [];
+	for (let at = 0; at < Math.min(left.length, right.length) - 1; at += 1) {
+		if (left[at] !== right[at]) break;
+		shared.push(left[at]);
+	}
+	return shared.join("/");
+};
+const edgeTyping = (env) => Effect.gen(function* () {
+	const model = env.deps.model;
+	if (model === void 0) return {
+		...emptyOutcome({
+			candidates: 0,
+			judged: 0
+		}),
+		detail: "no model bound"
+	};
+	/**
+	* Tasks are out of both candidate arms, inside {@link edgeTypingCandidates}. Every rel in the
+	* vocabulary is a judgment about asserted facts, and a task asserts nothing: "these two
+	* contradict" and "this one caused that one" have no true answer about intended work. A promoted
+	* edge between two tasks would also be a memory-class edge with task endpoints written into both
+	* files.
+	*/
+	const candidates = yield* edgeTypingCandidates(env.deps.db);
+	/**
+	* The full path's count SHAPE, at zero. Every key the phase can report is present, because a
+	* report reader comparing two nights reads a missing key as a phase that does not have that
+	* concept rather than as a night that did none of it.
+	*/
+	const zero = {
+		candidates: 0,
+		judged: 0,
+		typed: 0,
+		contradictions: 0,
+		promoted: 0,
+		skipped: 0,
+		capped: 0,
+		duplicates: 0
+	};
+	if (candidates.length === 0) return emptyOutcome(zero);
+	if (env.dryRun) return emptyOutcome({
+		...zero,
+		candidates: candidates.length
+	});
+	const corpus = yield* activeCorpus(env.deps.db);
+	const textOf = new Map(corpus.map((row) => [row.path, `${row.gist}\n${row.body_text}`]));
+	/**
+	* A pair whose endpoint the corpus no longer holds is dropped before batching rather than inside
+	* the loop. An earlier phase's archive is the normal case here (the index is refreshed once, in
+	* preflight), and dropping it later would leave a hole in the numbered list the model is asked
+	* about.
+	*/
+	const withText = [];
+	let skipped = 0;
+	for (const pair of candidates) {
+		const srcText = textOf.get(pair.src);
+		const dstText = textOf.get(pair.dst);
+		if (srcText === void 0 || dstText === void 0) {
+			skipped += 1;
+			continue;
+		}
+		withText.push({
+			pair,
+			srcText,
+			dstText
+		});
+	}
+	/**
+	* The group is a SORT KEY, not a batch boundary, and that distinction is the phase's cost model.
+	*
+	* `dedup-merge` packs whole groups with the boundaries preserved because there a boundary is
+	* EVIDENCE: two members in different components are known not to be near-duplicates. Here every
+	* pair is judged on its own two memories, so a boundary carries no information the verdict needs —
+	* and honoring it would cost a model call per group. On a corpus whose pairs spread over a dozen
+	* directories that is a dozen calls for thirty pairs, which is the per-pair shape this phase
+	* exists to replace. Sorting by the group instead keeps related pairs ADJACENT, so they land in
+	* one call whenever they fit, and the call count is `ceil(pairs / EDGE_PAIRS_PER_CALL)`.
+	*
+	* The sort is this phase's and the kernel keeps the order it produces: group key first, then the
+	* `src`/`dst` order `unionPairs` already fixed, so a night's batch boundaries and `m1`..`mN` keys
+	* are a function of the corpus alone.
+	*/
+	const sorted = [...withText].sort((left, right) => {
+		const leftKey = pairGroupKey(left.pair);
+		const rightKey = pairGroupKey(right.pair);
+		if (leftKey !== rightKey) return leftKey < rightKey ? -1 : 1;
+		if (left.pair.src !== right.pair.src) return left.pair.src < right.pair.src ? -1 : 1;
+		return left.pair.dst < right.pair.dst ? -1 : left.pair.dst > right.pair.dst ? 1 : 0;
+	});
+	const batches = assembleBatches([sorted], { maxMembers: 30 });
+	const modelKey = modelFor(env.deps, "edge-typing");
+	let judged = 0;
+	let typed = 0;
+	let contradictions = 0;
+	let promoted = 0;
+	let capped = 0;
+	/** Second-and-later verdicts naming a key their batch had already answered for. */
+	let duplicates = 0;
+	let llmCalls = 0;
+	for (const batch of batches) {
+		/** Opaque keys again, so a verdict cannot name a path. Each SIDE is sliced to its budget. */
+		const keyed = keyMembers(batch, (candidate) => pairText(candidate.srcText.slice(0, EDGE_PAIR_SIDE_CHARS), candidate.dstText.slice(0, EDGE_PAIR_SIDE_CHARS)));
+		llmCalls += 1;
+		const answer = yield* batchCall(model, `edge-typing batch of ${batch.length}`, {
+			schema: EdgeTyping,
+			system: EDGE_TYPING_SYSTEM,
+			prompt: edgeTypingPrompt(keyed.keyed),
+			modelKey,
+			effort: "medium",
+			toolDescription: "Emit one relationship verdict per candidate pair."
+		});
+		if (answer === void 0) {
+			skipped += batch.length;
+			continue;
+		}
+		/**
+		* The keys this batch has already answered for, so a SECOND verdict naming one is dropped.
+		*
+		* A verdict is one pair's answer, and nothing in the schema stops a model from emitting two for
+		* one key. Acting on both would write two authored edges from one relationship — and since the
+		* two are free to disagree about `direction`, `caused_by` could land in BOTH files, which says
+		* each memory caused the other. `resolveKeys` does not help: it is called one key at a time
+		* here, because a verdict names one pair, so its own repeat-collapsing never sees the pair.
+		*
+		* FIRST wins rather than last, and the choice is the same one {@link unionPairs} makes: the
+		* batch's order is deterministic, so which verdict is first is reproducible, and a later verdict
+		* cannot revise a write already committed to the tree. Repeats are counted in `duplicates`
+		* rather than silently swallowed, so a model doing this is visible in a night's report.
+		*/
+		const answered = /* @__PURE__ */ new Set();
+		for (const verdict of answer.verdicts) {
+			/**
+			* The key is resolved through the kernel, so an invented key yields no candidate and no
+			* write.
+			*/
+			const [candidate] = resolveKeys(keyed, [verdict.pairKey]);
+			if (candidate === void 0) continue;
+			if (answered.has(verdict.pairKey)) {
+				duplicates += 1;
+				continue;
+			}
+			answered.add(verdict.pairKey);
+			judged += 1;
+			if (!assertsEdge(verdict)) continue;
+			if (assertsContradiction(verdict)) {
+				contradictions += 1;
+				const row = (yield* bumpCorroboration(env.deps.db, {
+					srcPath: candidate.pair.src,
+					rel: "contradicts",
+					dstPath: candidate.pair.dst,
+					at: env.at
+				}))[0];
+				if (row === void 0 || row.detections < 2 || row.promoted === 1) continue;
+				if (promoted + typed >= 50) {
+					capped += 1;
+					continue;
+				}
+				/**
+				* **BOTH endpoints, or nothing at all — checked BEFORE either write.**
+				*
+				* A `contradicts` is symmetric, and the phase's own promotion rule is that a reader arriving
+				* at either file sees it. So the pair is all-or-nothing, and the check has to come first
+				* because the alternative is not recoverable: stamping `src` and then finding `dst` gone
+				* leaves a `<link>` pointing at a path the tree does not hold — a dangling href committed by
+				* the commit that created it — while the other half of the conflict is invisible.
+				*
+				* A missing endpoint is ORDINARY here, not exceptional. Every phase reads its candidates from
+				* an index refreshed once in preflight and not again, so a file an earlier phase archived is
+				* still listed active at its old path when this phase reads it. `readFileBytes` answers
+				* `undefined` for exactly that case, and the TREE is the system of record.
+				*/
+				/**
+				* **BOTH endpoints, or nothing at all — checked BEFORE either write.**
+				*
+				* A `contradicts` is symmetric, and the phase's own promotion rule is that a reader arriving
+				* at either file sees it. So the pair is all-or-nothing, and the check has to come first
+				* because the alternative is not recoverable: stamping `src` and then finding `dst` gone
+				* leaves a `<link>` pointing at a path the tree does not hold — a dangling href committed by
+				* the commit that created it — while the other half of the conflict is invisible.
+				*
+				* A missing endpoint is ORDINARY here, not exceptional. Every phase reads its candidates from
+				* an index refreshed once in preflight and not again, so a file an earlier phase archived is
+				* still listed active at its old path when this phase reads it. `readFileBytes` answers
+				* `undefined` for exactly that case, and the TREE is the system of record.
+				*/
+				const haveSrc = yield* readFileBytes(env, candidate.pair.src);
+				const haveDst = yield* readFileBytes(env, candidate.pair.dst);
+				if (haveSrc === void 0 || haveDst === void 0) continue;
+				const wroteSrc = yield* stampFile(env, candidate.pair.src, [link("contradicts", hrefFor(candidate.pair.dst)), meta("memhtml-updated", env.at)]);
+				const wroteDst = yield* stampFile(env, candidate.pair.dst, [link("contradicts", hrefFor(candidate.pair.src)), meta("memhtml-updated", env.at)]);
+				/**
+				* The counter is promoted only when BOTH sides gained the edge on this run. `stampFile`'s
+				* `false` also covers "the head already said this", so a pair whose files were somehow
+				* stamped without the counter being promoted stays un-promoted — and therefore RE-ELIGIBLE,
+				* which is the outcome that lets a later night with a refreshed index finish the job rather
+				* than record a half-written edge as done.
+				*/
+				/**
+				* The counter is promoted only when BOTH sides gained the edge on this run. `stampFile`'s
+				* `false` also covers "the head already said this", so a pair whose files were somehow
+				* stamped without the counter being promoted stays un-promoted — and therefore RE-ELIGIBLE,
+				* which is the outcome that lets a later night with a refreshed index finish the job rather
+				* than record a half-written edge as done.
+				*/
+				if (!wroteSrc || !wroteDst) continue;
+				yield* markPromoted(env.deps.db, {
+					srcPath: candidate.pair.src,
+					rel: "contradicts",
+					dstPath: candidate.pair.dst,
+					at: env.at
+				});
+				promoted += 1;
+				continue;
+			}
+			if (!isDirectionalRel(verdict.rel)) continue;
+			if (promoted + typed >= 50) {
+				capped += 1;
+				continue;
+			}
+			/**
+			* ONE file, the subject's. A directional rel read from the wrong end inverts its meaning —
+			* `caused_by` written into the cause instead of the effect says the opposite of what the
+			* model answered — so the direction decides the file and the href together, from one
+			* statement, and cannot disagree with itself.
+			*/
+			const [subject, object] = verdict.direction === "src_to_dst" ? [candidate.pair.src, candidate.pair.dst] : [candidate.pair.dst, candidate.pair.src];
+			if (yield* stampFile(env, subject, [link(verdict.rel, hrefFor(object)), meta("memhtml-updated", env.at)])) typed += 1;
+		}
+	}
+	const counts = {
+		candidates: candidates.length,
+		judged,
+		typed,
+		contradictions,
+		promoted,
+		skipped,
+		capped,
+		duplicates
+	};
+	if (promoted === 0 && typed === 0) return {
+		counts,
+		commitSha: null,
+		llmCalls
+	};
+	return {
+		counts,
+		commitSha: yield* commitPhase(env, "edge-typing", `promote ${typed} typed edges and ${promoted} corroborated contradictions`, counts),
+		llmCalls
+	};
+});
+
+//#endregion
+//#region packages/sleep/dist/phases/entity-resolution.js
+/**
+* Phase 3, entity resolution. Cluster one entity type's names into subjects, then rewrite each alias
+* onto its canonical. ONE commit rewriting `memhtml-entity` values in place.
+*
+* Three stages, and the separation is what makes the phase safe:
+*
+* 1. **Pre (deterministic, cheap).** Normalize every name, exact-merge the ones that normalize
+*    together, auto-merge pairs at or above {@link AUTO_MERGE_THRESHOLD} character overlap, and merge
+*    every pair a person file DECLARES ({@link aliasPairs}). This pass alone is the whole phase when no
+*    model is bound, so a credential-free run still collapses `Checkout API` onto `checkout api` and
+*    still applies a seeded declaration. The same pass computes one MEMORY CENTROID per name, in
+*    O(files) and never per pair.
+* 2. **Core (one model call per entity type, sharded at {@link ENTITY_BATCH_SIZE}).** The model sees
+*    every name of one type as a numbered member list and returns a PARTITION into subjects. Never one
+*    call per pair: 59 entities on the measured corpus is one call, and the pair space is 1,711.
+* 3. **Post (deterministic, the one-way-door guards).** Which name survives a merge is decided by
+*    {@link unionPairs}'s weight-then-lexicographic rule and never by the model. All THREE pair sources
+*    — the character pass, the declarations, and the model — feed that ONE union-find, so no two of them
+*    can disagree about a canonical. A merge backed by a DECLARED alias applies at once and is never
+*    counted; a merge the model alone proposes is counted in `state.entity_corroboration` and applies
+*    only once {@link ENTITY_PROMOTION_DETECTIONS} different nights have reached it.
+*
+* **Why the model, and why centroids as its evidence.** Character overlap is measurably wrong on the
+* case this phase exists for. Measured on the live corpus: `laith` against `laith al-saadoon` scores
+* 0.476 and `sanju` against `sanju kumar` 0.625 — below even the 0.75 review band — so a short name and
+* its full form are structurally invisible to a character ratio, and the phase minted two person files
+* for one person. The signal that does separate them is not the name string but WHAT IS WRITTEN under
+* each name: the centroid of the vectors of every memory claiming a name. Two spellings of one person
+* have near-identical centroids; `checkout-api` and `payments-api` do not, however close their strings
+* or their domain.
+*
+* The centroid is EVIDENCE HANDED TO THE MODEL, not a threshold. A cosine floor over centroids would
+* make exactly the mistake a bare character ratio avoids, because two services in one domain are
+* written about in the same terms. What the deterministic code keeps is the part a threshold is good
+* at: the confidence floor, the corroboration count, and the choice of which name survives.
+*
+* **Every band that does not merge is COUNTED, not merged.** The 0.75-0.85 character band the model did
+* not cluster, and a cluster below {@link ENTITY_CONFIDENCE_FLOOR}, both land in `reviewCandidates`. An
+* entity merge is a one-way door on stored identity: no later commit separates two subjects whose
+* memories were fused, and the failure mode of an over-eager gate is silent and permanent.
+*/
+/** At or above this ratio two names are the same entity. Auto-merged with no model call. */
 const AUTO_MERGE_THRESHOLD = .85;
 /** At or above this ratio, below the auto threshold: counted for review, left unmerged. */
 const REVIEW_THRESHOLD = .75;
+/**
+* Confidence a model-proposed cluster must clear before it is even counted toward a merge.
+*
+* The same floor {@link STANCE_CONFIDENCE_FLOOR} sets for a contradiction, for the same reason: a false
+* merge is worse than a missed one, and this floor and the corroboration gate are two independent
+* guards on one door. A cluster below it is reported as a review candidate and nothing else.
+*/
+const ENTITY_CONFIDENCE_FLOOR = .7;
+/** Nights a model-only merge must be proposed on before it is written into the files. */
+const ENTITY_PROMOTION_DETECTIONS = 2;
+/**
+* Names offered per model call. One type's whole name list fits one call at the measured corpus size
+* (59 entities); this is the shard boundary for a corpus that outgrows that.
+*/
+const ENTITY_BATCH_SIZE = 500;
+/** Memory titles shown per name. Enough to say what a name is about, few enough to stay cheap. */
+const ENTITY_SAMPLE_TITLES = 3;
+/** Centroid neighbors shown per name, nearest first. */
+const ENTITY_NEIGHBORS = 3;
+/** Characters of each member's evidence block shown. A name plus three titles fits comfortably. */
+const ENTITY_MEMBER_CHARS = 600;
+/**
+* The one entity type the alias oracle speaks for, derived from the prefix rather than retyped.
+*
+* A declaration lives in a person file, and `resources/people/` is the only directory the format gives
+* a hand-edited identity surface. A service has no equivalent file to declare from, so offering an
+* `aliases` line for one would show the model a field that is always empty.
+*/
+const PERSON_TYPE = PERSON_ENTITY_PREFIX.slice(0, -1);
 /** Lowercase, NFC-normalize, collapse internal whitespace, trim. The pre-compare form. */
 const normalizeEntityName = (name) => name.normalize("NFC").toLowerCase().replace(/\s+/g, " ").trim();
 /**
@@ -10241,6 +11713,9 @@ const normalizeEntityName = (name) => name.normalize("NFC").toLowerCase().replac
 * separator or casing change actually is. `checkout-api` against `checkout api` differs in one
 * character and scores 0.92, while `checkout-api` against `payments-api` shares only the suffix and
 * scores 0.67. That sits below both thresholds, so two distinct services stay separate.
+*
+* It is the pre-pass and not the decision core. Its blind spot is short-name-against-full-name, which
+* is what the model call exists for.
 */
 const nameSimilarity = (left, right) => {
 	if (left === right) return 1;
@@ -10258,14 +11733,24 @@ const nameSimilarity = (left, right) => {
 	}
 	return 2 * (previous[columns - 1] ?? 0) / (left.length + right.length);
 };
+/** A pair as a stable key, so a set of pairs is order-independent. */
+const pairKey = (left, right) => left < right ? `${left}\u0000${right}` : `${right}\u0000${left}`;
 /**
-* Union-find over the auto-merge pairs. The higher-count name wins the root; a tie goes to the
-* lexicographically smaller name, so the partition is a function of the input alone.
+* Union-find over an explicit pair list. The higher-count name wins the root; a tie goes to the
+* lexicographically smaller name.
+*
+* **This is the one place a canonical name is chosen, and every merge routes through it.** The
+* character pass, the alias oracle, and the model all contribute PAIRS to one call, so `A~B` from the
+* character ratio and `B~C` from the model land in one cluster with one root. Two separate union-finds
+* would let the two passes disagree about which name survives, and the rewrite would then depend on
+* which pass ran first.
+*
+* `names` is walked in sorted order and the pairs in the order given, so the partition is a function of
+* the input alone and a corpus that did not change resolves the same way twice.
 */
-const resolveClusters = (counts) => {
+const unionPairs = (counts, pairs) => {
 	const names = [...counts.keys()].sort();
 	const parent = /* @__PURE__ */ new Map();
-	let reviewCandidates = 0;
 	const find = (name) => {
 		let current = name;
 		while ((parent.get(current) ?? current) !== current) {
@@ -10275,33 +11760,262 @@ const resolveClusters = (counts) => {
 		}
 		return current;
 	};
-	const union = (left, right) => {
+	for (const [left, right] of pairs) {
 		const rootLeft = find(left);
 		const rootRight = find(right);
-		if (rootLeft === rootRight) return;
+		if (rootLeft === rootRight) continue;
 		const weightLeft = counts.get(rootLeft) ?? 0;
 		const weightRight = counts.get(rootRight) ?? 0;
 		if (weightLeft > weightRight || weightLeft === weightRight && rootLeft < rootRight) parent.set(rootRight, rootLeft);
 		else parent.set(rootLeft, rootRight);
-	};
-	for (let outer = 0; outer < names.length; outer += 1) for (let inner = outer + 1; inner < names.length; inner += 1) {
-		const left = names[outer];
-		const right = names[inner];
-		if (left === void 0 || right === void 0) continue;
-		const similarity = nameSimilarity(left, right);
-		if (similarity >= .85) union(left, right);
-		else if (similarity >= .75) reviewCandidates += 1;
 	}
 	const aliasToCanonical = /* @__PURE__ */ new Map();
 	for (const name of names) {
 		const root = find(name);
 		if (root !== name) aliasToCanonical.set(name, root);
 	}
+	return aliasToCanonical;
+};
+/**
+* Every pair of one type's names, split at the two thresholds. Names are walked in sorted order, so
+* the pair list is a function of the name set alone.
+*/
+const characterPairs = (names) => {
+	const sorted = [...names].sort();
+	const auto = [];
+	const review = [];
+	for (let outer = 0; outer < sorted.length; outer += 1) for (let inner = outer + 1; inner < sorted.length; inner += 1) {
+		const left = sorted[outer];
+		const right = sorted[inner];
+		if (left === void 0 || right === void 0) continue;
+		const similarity = nameSimilarity(left, right);
+		if (similarity >= .85) auto.push([left, right]);
+		else if (similarity >= .75) review.push([left, right]);
+	}
 	return {
-		aliasToCanonical,
-		reviewCandidates
+		auto,
+		review
 	};
 };
+/**
+* One memory centroid per normalized name, per entity type, in ONE pass over the claims.
+*
+* **Members are summed in SORTED PATH order, and that is a determinism requirement rather than tidiness.**
+* Floating-point addition is not associative — `1 + 1e-16 + 1e-16` is `1` and `1e-16 + 1e-16 + 1` is
+* `1.0000000000000002` (probed on node 24.19.0, in float64) — so a centroid summed in a different order
+* is different bytes, and different bytes reorder the nearest-neighbor list the model is shown. Two
+* nights over an unchanged corpus have to produce the same prompt, so the order is fixed here rather
+* than inherited from whatever order the rows arrived in.
+*
+* **A path claiming one name twice contributes its vector ONCE.** A file may carry both
+* `Service:Checkout-API` and `service:checkout-api`, two `file_entities` rows that normalize together,
+* and summing that memory twice would let one file's authoring quirk double its own weight in the
+* centroid.
+*
+* Accumulated in float64 over float32 inputs, because the sum of n unit vectors is not a unit vector
+* and float32 would round each partial sum. Cost is O(files), never O(names²).
+*/
+const entityCentroids = (claims, vectorForPath, options) => {
+	const sampleTitles = options?.sampleTitles ?? 3;
+	/** `type` -> normalized name -> its distinct claiming paths, and each path's title. */
+	const byType = /* @__PURE__ */ new Map();
+	for (const claim of claims) {
+		const name = normalizeEntityName(claim.entity_name);
+		if (name === "") continue;
+		let names = byType.get(claim.entity_type);
+		if (names === void 0) {
+			names = /* @__PURE__ */ new Map();
+			byType.set(claim.entity_type, names);
+		}
+		let paths = names.get(name);
+		if (paths === void 0) {
+			paths = /* @__PURE__ */ new Map();
+			names.set(name, paths);
+		}
+		paths.set(claim.path, claim.title);
+	}
+	const out = /* @__PURE__ */ new Map();
+	for (const [entityType, names] of byType) {
+		const centroids = [];
+		for (const name of [...names.keys()].sort()) {
+			const paths = names.get(name);
+			if (paths === void 0) continue;
+			const sorted = [...paths.keys()].sort();
+			centroids.push({
+				name,
+				memories: sorted.length,
+				titles: sorted.slice(0, sampleTitles).flatMap((path) => {
+					const title = paths.get(path);
+					return title === void 0 || title.trim() === "" ? [] : [title.trim()];
+				}),
+				vec: meanVector(sorted.flatMap((path) => vectorForPath.get(path) ?? []))
+			});
+		}
+		out.set(entityType, centroids);
+	}
+	return out;
+};
+/**
+* The L2-normalized mean of vectors summed in the order given, or absent for an empty or zero set.
+*
+* Normalized so a cosine between two centroids does not depend on how many memories each was built
+* from, and so a one-memory name and a fifty-memory name are comparable at all.
+*/
+const meanVector = (vectors) => {
+	const first = vectors[0];
+	if (first === void 0) return void 0;
+	const sum = new Float64Array(first.length);
+	for (const vector of vectors) {
+		const width = Math.min(sum.length, vector.length);
+		for (let at = 0; at < width; at += 1) sum[at] = sum[at] + vector[at];
+	}
+	let norm = 0;
+	for (const component of sum) norm += component * component;
+	if (norm === 0) return void 0;
+	const scale = 1 / Math.sqrt(norm);
+	for (let at = 0; at < sum.length; at += 1) sum[at] = sum[at] * scale;
+	return sum;
+};
+/**
+* The `k` nearest same-type centroids to `of`, ordered `sim` DESC then `name` ASC.
+*
+* The tie-break matches the pair kernel's (`sim` DESC, then the other key ASC), so two names whose
+* centroids are equidistant are listed in one fixed order and the prompt's bytes do not depend on the
+* input order. A name with no centroid has no neighbors, and a candidate with no centroid is not one.
+*
+* `cosine` from the domain rather than a dot product over the already-normalized vectors, so this
+* similarity is the same arithmetic every other reader of this vector space performs. Cost is O(n²) per
+* type, bounded by {@link ENTITY_BATCH_SIZE} being the point at which a type is sharded for the CALL —
+* at the measured 59 entities the pair space is 1,711 dot products, which is the work the phase used to
+* do with character ratios.
+*/
+const nearestCentroids = (centroids, of, k) => {
+	const subjectVec = centroids.find((candidate) => candidate.name === of)?.vec;
+	if (subjectVec === void 0) return [];
+	const scored = [];
+	for (const candidate of centroids) {
+		if (candidate.name === of || candidate.vec === void 0) continue;
+		scored.push({
+			name: candidate.name,
+			sim: cosine(subjectVec, candidate.vec)
+		});
+	}
+	scored.sort((left, right) => left.sim !== right.sim ? left.sim < right.sim ? 1 : -1 : left.name < right.name ? -1 : 1);
+	return scored.slice(0, k);
+};
+/**
+* One name's evidence block, as the model reads it.
+*
+* Neighbors are named by NAME and not by member key. A key names a member of THIS batch, and a
+* centroid neighbor may sit in another shard, so offering its key would invite an answer referencing a
+* member the batch never contained. The similarity is rendered at two decimals so a corpus whose
+* vectors moved in the sixteenth place does not change the prompt's bytes.
+*/
+const entityMemberText = (input) => {
+	const lines = [`name: ${input.centroid.name}`, `memories: ${input.centroid.memories}`];
+	if (input.centroid.titles.length > 0) lines.push("titles:", ...input.centroid.titles.map((title) => `- ${title}`));
+	if (input.neighbors.length > 0) lines.push("nearest by memory centroid:", ...input.neighbors.map((one) => `- ${one.name} (${one.sim.toFixed(2)})`));
+	if (input.aliases.length > 0) lines.push(`declared aliases: ${input.aliases.join(", ")}`);
+	return lines.join("\n");
+};
+/**
+* Decompose one cluster of member names into oriented merges: the highest-count name survives, ties
+* broken lexicographically, and every other member rewrites onto it.
+*
+* **The model's `canonicalKey` does not decide this**, and the reason is worth stating. The canonical
+* name is what every `memhtml-entity` meta in the corpus is rewritten TO, and it becomes a person file's
+* path once person-links runs. Letting the model choose it would make a nightly job's write target a
+* model's answer. What `canonicalKey` is for is validation: a cluster whose canonical is not one of its
+* own members is a self-contradicting answer, and the caller drops it.
+*
+* A cluster of fewer than two names produces no merges, which is how a model refuses.
+*/
+const decomposeCluster = (members, counts) => {
+	const distinct = [...new Set(members)].sort();
+	if (distinct.length < 2) return [];
+	let canonical = distinct[0];
+	for (const name of distinct.slice(1)) {
+		const held = counts.get(canonical) ?? 0;
+		const weight = counts.get(name) ?? 0;
+		if (weight > held || weight === held && name < canonical) canonical = name;
+	}
+	return distinct.flatMap((name) => name === canonical ? [] : [{
+		alias: name,
+		canonical
+	}]);
+};
+/** True when some declaration names both. The alias oracle's whole question. */
+const aliasBacked = (groups, left, right) => groups.some((group) => group.has(left) && group.has(right));
+/**
+* Every pair of one type's names that a DECLARATION backs: the alias oracle as a pair source of its
+* own, answerable with no model and no corroboration.
+*
+* **This is what makes the oracle an oracle.** Issue #43 states that entity resolution consults
+* declared aliases FIRST and that an alias-backed merge auto-commits regardless of string distance. A
+* declaration read only where the model core reads it would deliver neither half: a credential-free
+* night would leave `laith` and `laith al-saadoon` split with a person file sitting in the corpus
+* saying they are one person, and even a night WITH credentials would apply the declaration only if
+* the model happened to propose that pair — so the operator surface the format invites someone to
+* hand-edit would work or not work depending on a model's attention.
+*
+* A pair the character pass already merges is left out, because counting it as an alias merge as well
+* would report one merge twice. Names are walked in sorted order, so the pair list is a function of the
+* name set and the declarations alone.
+*/
+const aliasPairs = (groups, counts) => {
+	const names = [...counts.keys()].sort();
+	const out = [];
+	for (let outer = 0; outer < names.length; outer += 1) for (let inner = outer + 1; inner < names.length; inner += 1) {
+		const left = names[outer];
+		const right = names[inner];
+		if (left === void 0 || right === void 0) continue;
+		if (!aliasBacked(groups, left, right)) continue;
+		if (nameSimilarity(left, right) >= .85) continue;
+		out.push([left, right]);
+	}
+	return out;
+};
+/**
+* Read the alias declarations out of the person files.
+*
+* Parsed with the production parser rather than scanned for meta lines, because `memhtml-alias` is
+* repeatable and the surgical `readMeta` reads only the first of a name. A file that does not parse is
+* skipped: it is not indexed either, so it has no entities for a merge to be about.
+*
+* **Read from the FILES at phase time, and deliberately not projected to SQL.** The whole point of the
+* oracle is that a person file is hand-editable and operator-seedable — someone with an authoritative
+* directory writes the aliases in and the phase converges to auto-merge. A projection would put the
+* declaration behind an index refresh, so an alias written and committed during a session would not be
+* evidence until the next rebuild, and the one surface an operator is invited to edit would be the one
+* with a stale read. There are as many person files as there are people, and the phase reads each once.
+*
+* Read on EVERY run, including a credential-free one and a dry run, because the declarations are a
+* deterministic pair source rather than the model core's evidence. Reading them is pure, so a dry run
+* can count what they would merge without writing anything.
+*/
+const readAliasGroups = (env) => Effect.gen(function* () {
+	const paths = yield* peoplePaths(env.deps.db).pipe(Effect.orElseSucceed(() => []));
+	const groups = [];
+	for (const row of paths) {
+		const html = yield* readFileBytes(env, row.path).pipe(Effect.orElseSucceed(() => void 0));
+		if (html === void 0) continue;
+		const doc = yield* parseMemory(html).pipe(Effect.orElseSucceed(() => void 0));
+		if (doc === void 0) continue;
+		const group = /* @__PURE__ */ new Set();
+		for (const entity of doc.entities) {
+			if (!entity.startsWith(PERSON_ENTITY_PREFIX)) continue;
+			const name = normalizeEntityName(entity.slice(PERSON_ENTITY_PREFIX.length));
+			if (name !== "") group.add(name);
+		}
+		if (group.size === 0) continue;
+		for (const alias of doc.aliases) {
+			const name = normalizeEntityName(alias);
+			if (name !== "") group.add(name);
+		}
+		if (group.size > 1) groups.push(group);
+	}
+	return groups;
+});
 /** The `type:name` form a `memhtml-entity` meta carries. */
 const entityRef = (entityType, entityName) => `${entityType}:${entityName}`;
 const entityResolution = (env) => Effect.gen(function* () {
@@ -10316,7 +12030,7 @@ const entityResolution = (env) => Effect.gen(function* () {
 		if (bucket === void 0) byType.set(entity.entity_type, [entity]);
 		else bucket.push(entity);
 	}
-	/** `path -> [(oldRef, newRef)]`, accumulated across the normalize and merge passes. */
+	/** `path -> [(oldRef, newRef)]`, accumulated across every pass. */
 	const rewrites = /* @__PURE__ */ new Map();
 	const addRewrite = (path, from, to) => {
 		if (from === to) return;
@@ -10326,7 +12040,44 @@ const entityResolution = (env) => Effect.gen(function* () {
 	};
 	let normalized = 0;
 	let fuzzyMerges = 0;
+	let llmMerges = 0;
+	let aliasMerges = 0;
+	let pendingCorroboration = 0;
 	let reviewCandidates = 0;
+	let llmCalls = 0;
+	/**
+	* The model core is skipped entirely on a dry run and when no model is bound, and both leave the
+	* deterministic passes running. A dry run must make no model call and bump no counter, because a
+	* counter bumped by a run that wrote nothing would be a night of corroboration the corpus never
+	* saw. An absent model is a credential-free run, not a broken one.
+	*
+	* **`dedup-merge`'s dry run makes the opposite choice and DOES spend its calls**, because there the
+	* model's partition is the number an operator is asking for and a call costs nothing but money. Here
+	* an honest preview would have to bump the corroboration counter — the merge count for night two
+	* depends on it — and this phase's writes are identity rewrites, which is the one-way door where
+	* manufacturing a night of evidence is worse than declining to preview.
+	*/
+	const model = env.dryRun ? void 0 : env.deps.model;
+	const modelKey = modelFor(env.deps, "entity-resolution");
+	/**
+	* The declarations, read UNCONDITIONALLY — before the model core, and whether or not one exists.
+	*
+	* The oracle is a deterministic pair source like the character pass, not evidence the model core
+	* owns. Reading it here is what makes a person file an operator surface: seed one, and the merge it
+	* declares lands on the next night with no credentials, no cosine, and no second night. Gathering it
+	* under `model !== undefined` made the declaration effective only where a model had already proposed
+	* the same pair, which is the narrower behavior issue #43 names as the defect.
+	*
+	* It is also the model core's evidence, unchanged: `aliasesFor` reads these same groups to render
+	* the `declared aliases` line, so the model sees what the code already decided rather than being
+	* asked about it.
+	*
+	* A read, never a write, so a DRY RUN performs it too. Its merges are counted like every other dry
+	* run count and nothing is written, which is what an operator sizing a night needs.
+	*/
+	const aliasGroups = yield* readAliasGroups(env);
+	/** The centroids the model core needs, gathered once for every type rather than per type. */
+	const centroidsByType = model === void 0 ? void 0 : yield* Effect.all([entityClaims(env.deps.db), entityVectors(env.deps.db)]).pipe(Effect.map(([claims, vectors]) => entityCentroids(claims, new Map(vectors.map((entry) => [entry.key, entry.vec])), { sampleTitles: 3 })));
 	for (const [entityType, bucket] of [...byType.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
 		/** Pass one: normalization, folding counts of names that normalize together. */
 		const counts = /* @__PURE__ */ new Map();
@@ -10337,12 +12088,124 @@ const entityResolution = (env) => Effect.gen(function* () {
 			counts.set(canonical, (counts.get(canonical) ?? 0) + entity.files);
 			if (canonical !== entity.entity_name) normalized += 1;
 		}
-		/** Pass two: the fuzzy clusters over the normalized names. */
-		const clusters = resolveClusters(counts);
-		reviewCandidates += clusters.reviewCandidates;
+		/** Pass two: the character pass. Its auto pairs merge; its band pairs await a later stage. */
+		const character = characterPairs([...counts.keys()]);
+		const accepted = [...character.auto];
+		/**
+		* Pass two-and-a-half: the DECLARED aliases, accepted straight into the union.
+		*
+		* Only for {@link PERSON_TYPE}, because that is the only type the format gives a declaration
+		* surface — `resources/people/` — so an alias group can only ever be about a person, and running
+		* this for `service` would compare names against groups that cannot hold them.
+		*
+		* These merges are recorded in `aliasMerges` and never in `entity_corroboration`. A declaration is
+		* a human's assertion of identity rather than a machine's suspicion, so a second night would add no
+		* evidence, and a counter row for it would tell a reader of that table there is a decision still
+		* waiting.
+		*/
+		const declared = entityType === PERSON_TYPE ? aliasPairs(aliasGroups, counts) : [];
+		accepted.push(...declared);
+		aliasMerges += declared.length;
+		/** So the model core does not count a declared pair a second time. */
+		const declaredKeys = new Set(declared.map(([left, right]) => pairKey(left, right)));
+		/**
+		* Pass three: the model core. One call per shard of one type, then a deterministic decision per
+		* proposed merge. Every merge the model contributes is either alias-backed and immediate, or
+		* corroborated across nights, or counted for review — the model never writes.
+		*/
+		const clusteredPairs = /* @__PURE__ */ new Set();
+		if (model !== void 0 && centroidsByType !== void 0) {
+			const centroids = centroidsByType.get(entityType) ?? [];
+			const members = centroids.filter((centroid) => counts.has(centroid.name));
+			const aliasesFor = (name) => entityType === PERSON_TYPE ? [...new Set(aliasGroups.filter((group) => group.has(name)).flatMap((group) => [...group].filter((other) => other !== name)))].sort() : [];
+			for (const shard of assembleBatches([members], {
+				maxMembers: 500,
+				minMembers: 2
+			})) {
+				const keyed = keyMembers(shard, (centroid) => entityMemberText({
+					centroid,
+					neighbors: nearestCentroids(centroids, centroid.name, 3),
+					aliases: aliasesFor(centroid.name)
+				}), { charBudget: 600 });
+				llmCalls += 1;
+				const clustering = yield* batchCall(model, `entity-resolution ${entityType} batch of ${shard.length}`, {
+					schema: EntityClustering,
+					system: ENTITY_CLUSTER_SYSTEM,
+					prompt: entityClusterPrompt(keyed.keyed),
+					modelKey,
+					effort: "medium",
+					toolDescription: "Emit one cluster per subject, naming the members that are the same subject."
+				});
+				if (clustering === void 0) continue;
+				for (const cluster of clustering.clusters) {
+					/**
+					* A key the batch never offered resolves to nothing, so an invented member cannot become a
+					* rewrite. The canonical must be one of the cluster's own members: a cluster whose stated
+					* canonical is outside it contradicts itself, and guessing which half was meant would be
+					* the caller inventing a merge.
+					*/
+					const memberNames = resolveKeys(keyed, cluster.memberKeys).map((centroid) => centroid.name);
+					const [canonicalMember] = resolveKeys(keyed, [cluster.canonicalKey]);
+					if (canonicalMember === void 0 || !memberNames.includes(canonicalMember.name)) continue;
+					for (const merge of decomposeCluster(memberNames, counts)) {
+						const key = pairKey(merge.alias, merge.canonical);
+						clusteredPairs.add(key);
+						if (nameSimilarity(merge.alias, merge.canonical) >= .85) continue;
+						/**
+						* Already accepted by the declaration pass above, so the merge is happening and only the
+						* counting is at stake: adding it again would report one merge as two, and corroborating
+						* it would count a night of evidence toward a decision already made. The model agreeing
+						* with a declaration is not new information — the declaration is the stronger evidence.
+						*/
+						if (declaredKeys.has(key)) continue;
+						/**
+						* A declaration the pass above could not have seen: the model named a pair whose two names
+						* are in one alias group, but at least one of them is not in `counts` for this type — a
+						* name the batch offered whose entity rows this type's bucket does not hold. Rare, and the
+						* rule is the same one, so it is applied here rather than left to the corroboration path.
+						*/
+						if (aliasBacked(aliasGroups, merge.alias, merge.canonical)) {
+							accepted.push([merge.alias, merge.canonical]);
+							aliasMerges += 1;
+							continue;
+						}
+						if (cluster.confidence < .7) {
+							reviewCandidates += 1;
+							continue;
+						}
+						const row = (yield* bumpEntityCorroboration(env.deps.db, {
+							entityType,
+							aliasName: merge.alias,
+							canonicalName: merge.canonical,
+							at: env.at
+						}))[0];
+						if (row === void 0 || row.detections < 2) {
+							pendingCorroboration += 1;
+							continue;
+						}
+						accepted.push([merge.alias, merge.canonical]);
+						llmMerges += 1;
+						if (row.promoted === 0) yield* markEntityPromoted(env.deps.db, {
+							entityType,
+							aliasName: merge.alias,
+							canonicalName: merge.canonical,
+							at: env.at
+						});
+					}
+				}
+			}
+		}
+		/**
+		* A band pair the model went on to cluster is no longer awaiting a human: it was decided, and
+		* the decision is recorded either as a merge or as a below-floor review candidate already counted
+		* above. Counting it here as well would report one pair twice.
+		*/
+		reviewCandidates += character.review.filter(([left, right]) => !clusteredPairs.has(pairKey(left, right))).length;
+		/** One union-find over every accepted pair, so the three sources cannot disagree on a root. */
+		const aliasToCanonical = unionPairs(counts, accepted);
 		for (const entity of bucket) {
 			const afterNormalize = normalizedOf.get(entity.entity_name) ?? entity.entity_name;
-			const afterMerge = clusters.aliasToCanonical.get(afterNormalize) ?? afterNormalize;
+			const afterMerge = aliasToCanonical.get(afterNormalize) ?? afterNormalize;
 			if (afterMerge === entity.entity_name) continue;
 			if (afterMerge !== afterNormalize) fuzzyMerges += 1;
 			const paths = yield* pathsForEntity(env.deps.db, entityType, entity.entity_name);
@@ -10353,10 +12216,16 @@ const entityResolution = (env) => Effect.gen(function* () {
 		entities: entities.length,
 		namesNormalized: normalized,
 		fuzzyMerges,
+		llmMerges,
+		aliasMerges,
+		pendingCorroboration,
 		reviewCandidates,
 		filesRewritten: rewrites.size
 	};
-	if (rewrites.size === 0 || env.dryRun) return emptyOutcome(counts);
+	if (rewrites.size === 0 || env.dryRun) return {
+		...emptyOutcome(counts),
+		llmCalls
+	};
 	let rewritten = 0;
 	for (const [path, pairs] of [...rewrites.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
 		const html = yield* readFileBytes(env, path);
@@ -10376,7 +12245,7 @@ const entityResolution = (env) => Effect.gen(function* () {
 	return {
 		counts: final,
 		commitSha: yield* commitPhase(env, "entity-resolution", `normalize ${normalized} entity names, merge ${fuzzyMerges} aliases`, final),
-		llmCalls: 0
+		llmCalls
 	};
 });
 
@@ -10716,7 +12585,11 @@ const preflight = (env) => Effect.gen(function* () {
 const MINING_COSINE_FLOOR = .85;
 /** Nearest neighbors considered per source file. */
 const MINING_PER_SOURCE_K = 5;
-/** Pairs mined per cycle. The cost guard on a corpus whose pair space is quadratic. */
+/**
+* Pairs mined per cycle: a cap on what {@link replaceMinedEdges} writes, not on the scan — the
+* kernel's arithmetic is O(n²·d) whatever this says, and it bounds the edge table so one dense
+* neighborhood cannot flood the graph the lateral arm and PageRank read.
+*/
 const MINING_SAMPLE_LIMIT = 2e3;
 const relationshipMining = (env) => Effect.gen(function* () {
 	/**
@@ -11426,8 +13299,8 @@ const traceConsolidation = (env) => Effect.gen(function* () {
 		* change.
 		*
 		* Nor does the conflict become an authored `<link>`, and the reason is mechanical. Any authored
-		* edge between two paths permanently closes that pair to the NLI phase's scan: `derived = 0` is
-		* the anti-join in `conflictCandidates` (`sql.ts:176-181`), so stamping one here would silence
+		* edge between two paths permanently closes that pair to edge typing's scans: `derived = 0` is
+		* the anti-join in BOTH `sharedEntityPairs` and `minedPairs`, so stamping one here would silence
 		* the very disagreement this lookup surfaced. The conflict lives in the counts, in the
 		* `Memhtml-Counts` trailer, and in the commit message's context, where a reviewer sees it at merge
 		* review and decides.
@@ -11683,7 +13556,7 @@ const PHASE_BODIES = {
 	"entity-resolution": entityResolution,
 	"person-links": personLinks,
 	"relationship-mining": relationshipMining,
-	"conflict-detection": conflictDetection,
+	"edge-typing": edgeTyping,
 	"confidence-decay": confidenceDecay,
 	"arc-synthesis": arcSynthesis,
 	"retention-triage": retentionTriage,
@@ -12847,4 +14720,4 @@ const latest = (left, right) => left === null ? right : right === null ? left :
 
 //#endregion
 export { STATE_SIDECAR_PATH as $, makeIndexRecorder as A, makeGitPort as B, ModelClientLive as C, EMBED_DIM as D, EmbeddingsLive as E, reinforce as F, STATE_MIGRATIONS_DIR as G, DatabaseService as H, Indexer as I, expandRoot as J, STATE_SCHEMA as K, makeIndexer as L, readWatermark as M, Retrieval as N, EMBED_WATERMARK as O, makeRetrieval as P, STATE_DB_PATH as Q, readIndexState as R, ModelClient as S, Embeddings as T, makeDatabase as U, sanitizeFtsQuery as V, MIGRATIONS_DIR as W, INDEX_DB_PATH as X, makeStore as Y, SLEEP_REPORTS_DIR as Z, unlink as _, parseSidecar as a, commitSubject as at, discriminationGate as b, generateArtifacts as c, isValidDatetime as ct, danglingEdges as d, REINFORCE_SIGNALS as dt, attemptIo as et, publishRows as f, frameKeyOf as ft, meta as g, link as h, makeSleep as i, makeGit as it, persistScanned as j, IndexRecorder as k, accessRows as l, closesFence as lt, hrefFor as m, scanTraceRoot as n, readFileOrNull as nt, renderSidecar as o, checkMemory as ot, applyHeadEdits as p, Store as q, Sleep as r, Git as rt, archivedFormOf as s, setMeta as st, mergeTailExtract as t, initRepo as tt, allPaths as u, fenceOpeningOf as ut, SLEEP_PHASES as v, wrapAsData as w, runDiscrimination as x, isSleepPhase as y, IndexGit as z };
-//# sourceMappingURL=dist-dfrcDFad.mjs.map
+//# sourceMappingURL=dist-B3yDga97.mjs.map