@contentrain/mcp 3.0.3 → 3.1.0

package/dist/reconcile-D5FTVW5z.mjs

@@ -0,0 +1,1704 @@
+import { t as buildContextChange } from "./context-CxpTATh4.mjs";
+import { D as contentDirPath, O as contentFilePath, k as documentFilePath } from "./model-manager-DqwL8ptm.mjs";
+import { t as OverlayReader } from "./overlay-reader-Bx1YxGXq.mjs";
+import { t as validateProject } from "./validator-B2GhPM3L.mjs";
+import { dirname, join } from "node:path";
+import { MODEL_FIELD_ORDER, canonicalStringify, conflictId, parseMarkdownFrontmatter, serializeMarkdownFrontmatter, sortKeys, stableHash } from "@contentrain/types";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+//#region src/core/ops/apply-to-worktree.ts
+/**
+* Phase 2 shim — applies a `FileChange[]` to a local worktree directory.
+*
+* Phase 3 replaces this with `LocalProvider.applyPlan` (same logic, owned by
+* the provider) while a `GitHubProvider.applyPlan` produces the equivalent
+* commit through the Git Data API. Until then, tool handlers call this shim
+* inside the existing `createTransaction` flow so Phase 2 gets plan/apply
+* semantics without rewriting the transaction machinery.
+*
+* - `content: string` → `writeFile` (creates parent dirs).
+* - `content: null` → `rm`; missing files are tolerated.
+* - Changes are applied in their given order; callers should sort for
+*   determinism.
+*/
+async function applyChangesToWorktree(worktree, changes) {
+	for (const change of changes) {
+		const absolute = join(worktree, change.path);
+		if (change.content === null) {
+			await rm(absolute, { force: true }).catch(() => {});
+			continue;
+		}
+		await mkdir(dirname(absolute), { recursive: true });
+		await writeFile(absolute, change.content, "utf-8");
+	}
+}
+//#endregion
+//#region src/core/ops/reconcile/read.ts
+/**
+* Per-side promise-memo over a `RepoReader`: every `(path)` read and listing
+* happens at most once for the whole plan, and concurrent duplicate requests
+* coalesce onto the same promise instead of racing. On a GitHub-backed
+* reader this is the difference between one API call per file and one per
+* phase that touches it.
+*
+* The `RepoReader` contract is preserved (`readFile` throws on a missing
+* file) so a `CachedReader` can be handed to `OverlayReader`,
+* `validateProject` and `buildContextChange` unchanged; the planner's own
+* code uses the null-tolerant extras.
+*/
+var CachedReader = class {
+	files = /* @__PURE__ */ new Map();
+	dirs = /* @__PURE__ */ new Map();
+	exists = /* @__PURE__ */ new Map();
+	constructor(inner) {
+		this.inner = inner;
+	}
+	/** Contract-shaped read: throws when missing. */
+	async readFile(path, _ref) {
+		const content = await this.readOrNull(path);
+		if (content === null) throw new Error(`ENOENT: no such file, open '${path}'`);
+		return content;
+	}
+	/** Planner-shaped read: `null` when missing, cached either way. */
+	readOrNull(path) {
+		let cached = this.files.get(path);
+		if (!cached) {
+			cached = this.inner.readFile(path).then((content) => content, () => null);
+			this.files.set(path, cached);
+		}
+		return cached;
+	}
+	listDirectory(path, _ref) {
+		let cached = this.dirs.get(path);
+		if (!cached) {
+			cached = this.inner.listDirectory(path).then((entries) => entries, () => []);
+			this.dirs.set(path, cached);
+		}
+		return cached;
+	}
+	fileExists(path, _ref) {
+		let cached = this.exists.get(path);
+		if (!cached) {
+			cached = this.inner.fileExists(path).then((v) => v, () => false);
+			this.exists.set(path, cached);
+		}
+		return cached;
+	}
+};
+/** Parse a JSON file, `null` when missing or unparseable. */
+async function readJsonOrNull(reader, path) {
+	const raw = await reader.readOrNull(path);
+	if (raw === null) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/core/ops/reconcile/resolutions.ts
+/**
+* The decisions carried into a second reconcile round, indexed by conflict
+* id. Merge functions call `consume` at the exact point they would create a
+* `ConflictItem`; a hit turns the conflict into a mechanical outcome, a
+* miss reports it. After planning, `unconsumed()` names the stale
+* resolutions — values changed between rounds, so the decision no longer
+* applies and the conflict reappears with a fresh id.
+*/
+var ResolutionIndex = class {
+	byId = /* @__PURE__ */ new Map();
+	consumed = /* @__PURE__ */ new Set();
+	constructor(resolutions = []) {
+		for (const resolution of resolutions) this.byId.set(resolution.id, resolution);
+	}
+	consume(candidate) {
+		const id = conflictId(candidate);
+		const resolution = this.byId.get(id);
+		if (!resolution) return null;
+		this.consumed.add(id);
+		return resolution;
+	}
+	unconsumed() {
+		return [...this.byId.values()].filter((r) => !this.consumed.has(r.id));
+	}
+};
+/**
+* Apply a consumed resolution to the candidate's values. `choose` picks a
+* side (absence on that side means deletion → `undefined`); `value`
+* supplies a replacement outright.
+*/
+function resolvedValue(resolution, candidate) {
+	if ("choose" in resolution) return resolution.choose === "ours" ? candidate.ours : candidate.theirs;
+	return resolution.value;
+}
+//#endregion
+//#region src/core/ops/reconcile/types.ts
+const EMPTY_STATS = {
+	takenOurs: 0,
+	takenTheirs: 0,
+	fieldMerged: 0
+};
+function addStats(a, b) {
+	return {
+		takenOurs: a.takenOurs + b.takenOurs,
+		takenTheirs: a.takenTheirs + b.takenTheirs,
+		fieldMerged: a.fieldMerged + b.fieldMerged
+	};
+}
+//#endregion
+//#region src/core/ops/reconcile/three-way.ts
+/**
+* Canonical equality: both values normalized through `sortKeys` (which drops
+* `null`/`undefined` values and sorts keys recursively — the same normal
+* form `canonicalStringify` writes to disk), then compared as JSON. So
+* `{ a: null }` equals `{}`, key order never matters, and absent equals
+* null — exactly the distinctions the storage layer cannot represent.
+*/
+function eqCanonical(a, b) {
+	const na = sortKeys(a);
+	const nb = sortKeys(b);
+	if (na === void 0 || nb === void 0) return na === nb;
+	return JSON.stringify(na) === JSON.stringify(nb);
+}
+/**
+* The three-way rule every policy row reduces to: a side that did not
+* change keeps no vote; identical changes converge; a lone change wins;
+* two different changes are a conflict — with delete-vs-edit split out
+* because it needs a different question ("keep or drop?" instead of
+* "which value?").
+*/
+function mergeLeaf3(base, ours, theirs) {
+	const oursSame = eqCanonical(ours, base);
+	const theirsSame = eqCanonical(theirs, base);
+	if (oursSame && theirsSame) return {
+		ok: true,
+		value: base,
+		from: "base"
+	};
+	if (eqCanonical(ours, theirs)) return {
+		ok: true,
+		value: ours,
+		from: "both"
+	};
+	if (oursSame) return {
+		ok: true,
+		value: theirs,
+		from: "theirs"
+	};
+	if (theirsSame) return {
+		ok: true,
+		value: ours,
+		from: "ours"
+	};
+	const baseAbsent = sortKeys(base) === void 0;
+	const oursAbsent = sortKeys(ours) === void 0;
+	const theirsAbsent = sortKeys(theirs) === void 0;
+	if (!baseAbsent && oursAbsent !== theirsAbsent) return {
+		ok: false,
+		reason: "delete_edit",
+		deletedBy: oursAbsent ? "ours" : "theirs"
+	};
+	return {
+		ok: false,
+		reason: "both_changed"
+	};
+}
+/**
+* Three-way merge of a keyed record (entries by ID, dictionary by key,
+* terms by slug, schema by property name): iterate the sorted union of
+* keys, delegate each item to `mergeItem`, assemble the output map.
+*/
+function mergeKeyedRecord3(three, mergeItem) {
+	const keys = [...new Set([
+		...Object.keys(three.base ?? {}),
+		...Object.keys(three.ours ?? {}),
+		...Object.keys(three.theirs ?? {})
+	])].toSorted();
+	const merged = {};
+	const conflicts = [];
+	let stats = EMPTY_STATS;
+	for (const key of keys) {
+		const outcome = mergeItem(key, {
+			base: three.base?.[key],
+			ours: three.ours?.[key],
+			theirs: three.theirs?.[key]
+		});
+		if (outcome.value !== void 0) merged[key] = outcome.value;
+		conflicts.push(...outcome.conflicts);
+		stats = addStats(stats, outcome.stats);
+	}
+	return {
+		merged,
+		conflicts,
+		stats
+	};
+}
+/** Attach the value-derived id — the only way a ConflictItem is ever built. */
+function makeConflict(input) {
+	return {
+		id: conflictId(input),
+		...input
+	};
+}
+/** Stats bucket for a clean leaf outcome; `base`/`both` count nowhere. */
+function statsFor(from) {
+	if (from === "ours") return {
+		takenOurs: 1,
+		takenTheirs: 0,
+		fieldMerged: 0
+	};
+	if (from === "theirs") return {
+		takenOurs: 0,
+		takenTheirs: 1,
+		fieldMerged: 0
+	};
+	return EMPTY_STATS;
+}
+//#endregion
+//#region src/core/ops/reconcile/merge-content.ts
+/**
+* Three-way merge of one entry's fields. Called when the entry as a whole
+* changed on BOTH sides: different fields both win (the union), the same
+* field with two values is a conflict, and a field deleted on one side but
+* edited on the other asks a different question and gets its own code.
+* An unresolved conflict keeps ours' value in the output — the plan is not
+* applied while conflicts remain, so nothing is ever silently overwritten.
+*/
+function mergeEntryFields(three, ctx, entryKey) {
+	const fields = [...new Set([
+		...Object.keys(three.base ?? {}),
+		...Object.keys(three.ours ?? {}),
+		...Object.keys(three.theirs ?? {})
+	])].toSorted();
+	const merged = {};
+	const conflicts = [];
+	for (const field of fields) {
+		const candidate = {
+			path: ctx.outPath,
+			key: entryKey,
+			field,
+			locale: ctx.locale,
+			base: three.base?.[field],
+			ours: three.ours?.[field],
+			theirs: three.theirs?.[field]
+		};
+		const leaf = mergeLeaf3(candidate.base, candidate.ours, candidate.theirs);
+		if (leaf.ok) {
+			if (leaf.value !== void 0) merged[field] = leaf.value;
+			continue;
+		}
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) {
+			const value = resolvedValue(resolution, candidate);
+			if (value !== void 0) merged[field] = value;
+			continue;
+		}
+		if (candidate.ours !== void 0) merged[field] = candidate.ours;
+		const label = entryKey ? `"${entryKey}" field "${field}"` : `field "${field}"`;
+		conflicts.push(makeConflict({
+			...candidate,
+			kind: ctx.kind,
+			model: ctx.model,
+			code: leaf.reason === "delete_edit" ? "delete_edit_conflict" : "field_value_conflict",
+			message: leaf.reason === "delete_edit" ? `${label} was deleted on one side and edited on the other in ${ctx.outPath}.` : `${label} was changed to different values on both sides in ${ctx.outPath}.`
+		}));
+	}
+	return {
+		merged,
+		conflicts
+	};
+}
+/**
+* Collection file: entry-level three-way over the object-map, field-level
+* union when both sides touched the same entry.
+*/
+function mergeCollectionFile(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from)
+	};
+	return mergeKeyedRecord3(three, (entryId, entry) => {
+		const leaf = mergeLeaf3(entry.base, entry.ours, entry.theirs);
+		if (leaf.ok) return {
+			value: leaf.value,
+			conflicts: [],
+			stats: statsFor(leaf.from)
+		};
+		if (leaf.reason === "delete_edit") {
+			const candidate = {
+				path: ctx.outPath,
+				key: entryId,
+				locale: ctx.locale,
+				base: entry.base,
+				ours: entry.ours,
+				theirs: entry.theirs
+			};
+			const resolution = ctx.resolutions.consume(candidate);
+			if (resolution) return {
+				value: resolvedValue(resolution, candidate),
+				conflicts: [],
+				stats: EMPTY_STATS
+			};
+			return {
+				value: entry.ours,
+				conflicts: [makeConflict({
+					...candidate,
+					kind: ctx.kind,
+					model: ctx.model,
+					code: "delete_edit_conflict",
+					message: `Entry "${entryId}" was deleted on one side and edited on the other in ${ctx.outPath}.`
+				})],
+				stats: EMPTY_STATS
+			};
+		}
+		const fieldMerge = mergeEntryFields(entry, ctx, entryId);
+		return {
+			value: fieldMerge.merged,
+			conflicts: fieldMerge.conflicts,
+			stats: fieldMerge.conflicts.length === 0 ? {
+				takenOurs: 0,
+				takenTheirs: 0,
+				fieldMerged: 1
+			} : EMPTY_STATS
+		};
+	});
+}
+/** Singleton file: one record — straight field-level three-way. */
+function mergeSingletonFile(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from)
+	};
+	if (fileLeaf.reason === "delete_edit") {
+		const candidate = {
+			path: ctx.outPath,
+			locale: ctx.locale,
+			base: three.base,
+			ours: three.ours,
+			theirs: three.theirs
+		};
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) return {
+			merged: resolvedValue(resolution, candidate),
+			conflicts: [],
+			stats: EMPTY_STATS
+		};
+		return {
+			merged: three.ours,
+			conflicts: [makeConflict({
+				...candidate,
+				kind: ctx.kind,
+				model: ctx.model,
+				code: "delete_edit_conflict",
+				message: `${ctx.outPath} was deleted on one side and edited on the other.`
+			})],
+			stats: EMPTY_STATS
+		};
+	}
+	const fieldMerge = mergeEntryFields(three, ctx);
+	return {
+		merged: fieldMerge.merged,
+		conflicts: fieldMerge.conflicts,
+		stats: fieldMerge.conflicts.length === 0 ? {
+			takenOurs: 0,
+			takenTheirs: 0,
+			fieldMerged: 1
+		} : EMPTY_STATS
+	};
+}
+/**
+* Dictionary file: keys are the identities, values are string leaves. The
+* three-way generalization of the inline upsert semantics: with an author
+* present (a save), the incoming value wins and is reported; with no
+* author (reconcile), two changed values are a question, not a pick.
+*/
+function mergeDictionaryFile(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from)
+	};
+	return mergeKeyedRecord3(three, (key, item) => {
+		const leaf = mergeLeaf3(item.base, item.ours, item.theirs);
+		if (leaf.ok) return {
+			value: leaf.value,
+			conflicts: [],
+			stats: statsFor(leaf.from)
+		};
+		const candidate = {
+			path: ctx.outPath,
+			key,
+			locale: ctx.locale,
+			base: item.base,
+			ours: item.ours,
+			theirs: item.theirs
+		};
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) return {
+			value: resolvedValue(resolution, candidate),
+			conflicts: [],
+			stats: EMPTY_STATS
+		};
+		return {
+			value: item.ours,
+			conflicts: [makeConflict({
+				...candidate,
+				kind: "dictionary",
+				model: ctx.model,
+				code: leaf.reason === "delete_edit" ? "delete_edit_conflict" : "dictionary_value_conflict",
+				message: leaf.reason === "delete_edit" ? `Dictionary key "${key}" was deleted on one side and edited on the other in ${ctx.outPath}.` : `Dictionary key "${key}" has two different values in ${ctx.outPath}.`
+			})],
+			stats: EMPTY_STATS
+		};
+	});
+}
+/**
+* `normalize-sources.json`: keyed tooling metadata — merged with the
+* dictionary rule, values compared canonically whatever their shape.
+*/
+function mergeKeyedJson(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from)
+	};
+	const result = mergeKeyedRecord3(three, (key, item) => {
+		const leaf = mergeLeaf3(item.base, item.ours, item.theirs);
+		if (leaf.ok) return {
+			value: leaf.value,
+			conflicts: [],
+			stats: statsFor(leaf.from)
+		};
+		const candidate = {
+			path: ctx.outPath,
+			key,
+			base: item.base,
+			ours: item.ours,
+			theirs: item.theirs
+		};
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) return {
+			value: resolvedValue(resolution, candidate),
+			conflicts: [],
+			stats: EMPTY_STATS
+		};
+		return {
+			value: item.ours,
+			conflicts: [makeConflict({
+				...candidate,
+				kind: "file",
+				code: "file_conflict",
+				message: `Key "${key}" of ${ctx.outPath} was changed differently on both sides.`
+			})],
+			stats: EMPTY_STATS
+		};
+	});
+	return {
+		merged: result.merged,
+		conflicts: result.conflicts,
+		stats: result.stats
+	};
+}
+//#endregion
+//#region src/core/ops/reconcile/merge-document.ts
+/**
+* Document (.md) three-way merge: frontmatter key-by-key, body as one leaf.
+*
+* The body is deliberately never text-merged. Interleaving two prose edits
+* line-by-line produces syntactically plausible, editorially wrong hybrids —
+* choosing between two versions of prose is a content decision, and MCP
+* does not make those.
+*
+* The frontmatter parser round-trips only scalars and scalar arrays
+* (nested maps serialize but do not parse back). A side whose frontmatter
+* does not survive parse→serialize is not safe to rewrite, so the merge
+* falls back to whole-file resolution for that document instead of
+* silently destroying nested data.
+*/
+function mergeDocumentFile(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from),
+		advisories: []
+	};
+	if (fileLeaf.reason === "delete_edit") {
+		const candidate = {
+			path: ctx.outPath,
+			key: ctx.slug,
+			locale: ctx.locale,
+			base: three.base,
+			ours: three.ours,
+			theirs: three.theirs
+		};
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) return {
+			merged: resolvedValue(resolution, candidate),
+			conflicts: [],
+			stats: EMPTY_STATS,
+			advisories: []
+		};
+		return {
+			merged: three.ours,
+			conflicts: [makeConflict({
+				...candidate,
+				kind: "document",
+				model: ctx.model,
+				code: "delete_edit_conflict",
+				message: `Document "${ctx.slug}" was deleted on one side and edited on the other (${ctx.outPath}).`
+			})],
+			stats: EMPTY_STATS,
+			advisories: []
+		};
+	}
+	const parsed = {
+		base: three.base === void 0 ? void 0 : parseMarkdownFrontmatter(three.base),
+		ours: three.ours === void 0 ? void 0 : parseMarkdownFrontmatter(three.ours),
+		theirs: three.theirs === void 0 ? void 0 : parseMarkdownFrontmatter(three.theirs)
+	};
+	if (["ours", "theirs"].some((side) => {
+		const doc = parsed[side];
+		if (!doc) return false;
+		const reserialized = parseMarkdownFrontmatter(serializeMarkdownFrontmatter(doc.frontmatter, doc.body));
+		return !eqCanonical(reserialized.frontmatter, doc.frontmatter) || reserialized.body !== doc.body;
+	})) {
+		const candidate = {
+			path: ctx.outPath,
+			key: ctx.slug,
+			locale: ctx.locale,
+			base: three.base,
+			ours: three.ours,
+			theirs: three.theirs
+		};
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) return {
+			merged: resolvedValue(resolution, candidate),
+			conflicts: [],
+			stats: EMPTY_STATS,
+			advisories: []
+		};
+		return {
+			merged: three.ours,
+			conflicts: [makeConflict({
+				...candidate,
+				kind: "document",
+				model: ctx.model,
+				code: "file_conflict",
+				message: `Document "${ctx.slug}" (${ctx.outPath}) changed on both sides and carries frontmatter the structured merge cannot round-trip — choose a side.`
+			})],
+			stats: EMPTY_STATS,
+			advisories: [`Document "${ctx.slug}": fell back to whole-file resolution (nested frontmatter does not round-trip).`]
+		};
+	}
+	const conflicts = [];
+	const fmKeys = [...new Set([
+		...Object.keys(parsed.base?.frontmatter ?? {}),
+		...Object.keys(parsed.ours?.frontmatter ?? {}),
+		...Object.keys(parsed.theirs?.frontmatter ?? {})
+	])].toSorted();
+	const mergedFm = {};
+	for (const key of fmKeys) {
+		const candidate = {
+			path: ctx.outPath,
+			key: ctx.slug,
+			field: key,
+			locale: ctx.locale,
+			base: parsed.base?.frontmatter[key],
+			ours: parsed.ours?.frontmatter[key],
+			theirs: parsed.theirs?.frontmatter[key]
+		};
+		const leaf = mergeLeaf3(candidate.base, candidate.ours, candidate.theirs);
+		if (leaf.ok) {
+			if (leaf.value !== void 0) mergedFm[key] = leaf.value;
+			continue;
+		}
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) {
+			const value = resolvedValue(resolution, candidate);
+			if (value !== void 0) mergedFm[key] = value;
+			continue;
+		}
+		if (candidate.ours !== void 0) mergedFm[key] = candidate.ours;
+		conflicts.push(makeConflict({
+			...candidate,
+			kind: "document",
+			model: ctx.model,
+			code: leaf.reason === "delete_edit" ? "delete_edit_conflict" : "frontmatter_value_conflict",
+			message: `Frontmatter key "${key}" of document "${ctx.slug}" differs on both sides (${ctx.outPath}).`
+		}));
+	}
+	let mergedBody;
+	const bodyCandidate = {
+		path: ctx.outPath,
+		key: ctx.slug,
+		field: "body",
+		locale: ctx.locale,
+		base: parsed.base?.body,
+		ours: parsed.ours?.body,
+		theirs: parsed.theirs?.body
+	};
+	const bodyLeaf = mergeLeaf3(bodyCandidate.base, bodyCandidate.ours, bodyCandidate.theirs);
+	if (bodyLeaf.ok) mergedBody = bodyLeaf.value ?? "";
+	else {
+		const resolution = ctx.resolutions.consume(bodyCandidate);
+		if (resolution) mergedBody = resolvedValue(resolution, bodyCandidate) ?? "";
+		else {
+			mergedBody = bodyCandidate.ours ?? "";
+			conflicts.push(makeConflict({
+				...bodyCandidate,
+				kind: "document",
+				model: ctx.model,
+				code: "document_body_conflict",
+				message: `Body of document "${ctx.slug}" was edited on both sides (${ctx.outPath}) — bodies are never text-merged.`
+			}));
+		}
+	}
+	return {
+		merged: serializeMarkdownFrontmatter(mergedFm, mergedBody),
+		conflicts,
+		stats: conflicts.length === 0 ? {
+			takenOurs: 0,
+			takenTheirs: 0,
+			fieldMerged: 1
+		} : EMPTY_STATS,
+		advisories: []
+	};
+}
+//#endregion
+//#region src/core/ops/reconcile/merge-meta.ts
+/**
+* Three-way merge of one entry's meta. Special fields:
+*
+* - `updated_at`: the later timestamp wins (ISO strings compare lexically);
+*   a present value beats an absent one.
+* - `updated_by`: follows the side that supplied the winning `updated_at`;
+*   with no timestamps to arbitrate, ours is kept and an advisory says so.
+* - `status`: a publish decision belongs to whoever made it — one side's
+*   change wins mechanically, but two different decisions are a question
+*   for a human, never a pick.
+*
+* Entry-level delete-vs-edit resolves mechanically to the edited side with
+* an advisory: meta is bookkeeping that trails content, and the CONTENT
+* delete-vs-edit conflict (reported separately) is the real question. The
+* orphan-meta validator catches any residue once that resolves.
+*/
+function mergeEntryMeta3(three, ctx, entryKey) {
+	const leaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (leaf.ok) return {
+		merged: leaf.value,
+		conflicts: [],
+		advisories: []
+	};
+	if (leaf.reason === "delete_edit") return {
+		merged: leaf.deletedBy === "ours" ? three.theirs : three.ours,
+		conflicts: [],
+		advisories: [`Kept the edited side of ${entryKey ? `meta of "${entryKey}"` : `meta ${ctx.outPath}`} (deleted on the other) — bookkeeping follows the content decision.`]
+	};
+	const conflicts = [];
+	const advisories = [];
+	const merged = {};
+	const oursAt = typeof three.ours?.["updated_at"] === "string" ? three.ours["updated_at"] : void 0;
+	const theirsAt = typeof three.theirs?.["updated_at"] === "string" ? three.theirs["updated_at"] : void 0;
+	let byWinner = null;
+	if (oursAt !== void 0 || theirsAt !== void 0) {
+		if (oursAt === void 0) byWinner = "theirs";
+		else if (theirsAt === void 0) byWinner = "ours";
+		else byWinner = theirsAt > oursAt ? "theirs" : "ours";
+		const winnerAt = byWinner === "theirs" ? theirsAt : oursAt;
+		if (winnerAt !== void 0) merged["updated_at"] = winnerAt;
+	}
+	const fields = [...new Set([
+		...Object.keys(three.base ?? {}),
+		...Object.keys(three.ours ?? {}),
+		...Object.keys(three.theirs ?? {})
+	])].toSorted().filter((f) => f !== "updated_at");
+	for (const field of fields) {
+		const candidate = {
+			path: ctx.outPath,
+			key: entryKey,
+			field,
+			locale: ctx.locale,
+			base: three.base?.[field],
+			ours: three.ours?.[field],
+			theirs: three.theirs?.[field]
+		};
+		if (field === "updated_by" && byWinner !== null) {
+			const value = byWinner === "theirs" ? candidate.theirs ?? candidate.ours : candidate.ours ?? candidate.theirs;
+			if (value !== void 0) merged[field] = value;
+			continue;
+		}
+		const fieldLeaf = mergeLeaf3(candidate.base, candidate.ours, candidate.theirs);
+		if (fieldLeaf.ok) {
+			if (fieldLeaf.value !== void 0) merged[field] = fieldLeaf.value;
+			continue;
+		}
+		if (field === "updated_by") {
+			if (candidate.ours !== void 0) merged[field] = candidate.ours;
+			advisories.push(`${entryKey ? `"${entryKey}": ` : ""}updated_by differed with no updated_at to arbitrate — kept ours.`);
+			continue;
+		}
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) {
+			const value = resolvedValue(resolution, candidate);
+			if (value !== void 0) merged[field] = value;
+			continue;
+		}
+		if (candidate.ours !== void 0) merged[field] = candidate.ours;
+		conflicts.push(makeConflict({
+			...candidate,
+			kind: "meta",
+			model: ctx.model,
+			code: field === "status" ? "meta_status_conflict" : "field_value_conflict",
+			message: field === "status" ? `Publish status of ${entryKey ? `entry "${entryKey}"` : ctx.outPath} was changed differently on both sides.` : `Meta field "${field}" of ${entryKey ? `entry "${entryKey}"` : ctx.outPath} differs on both sides.`
+		}));
+	}
+	return {
+		merged,
+		conflicts,
+		advisories
+	};
+}
+/**
+* A meta file: keyed by entry ID for collections, a single record
+* otherwise. Dispatch comes from the winning model definition — shapes are
+* never sniffed, because a dictionary meta record is indistinguishable
+* from a small collection map.
+*/
+function mergeMetaFile(three, ctx, perEntry) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from),
+		advisories: []
+	};
+	if (!perEntry) {
+		const single = mergeEntryMeta3(three, ctx);
+		return {
+			merged: single.merged,
+			conflicts: single.conflicts,
+			stats: EMPTY_STATS,
+			advisories: single.advisories
+		};
+	}
+	const advisories = [];
+	const result = mergeKeyedRecord3(three, (entryId, entry) => {
+		const entryLeaf = mergeLeaf3(entry.base, entry.ours, entry.theirs);
+		if (entryLeaf.ok) return {
+			value: entryLeaf.value,
+			conflicts: [],
+			stats: statsFor(entryLeaf.from)
+		};
+		const entryMerge = mergeEntryMeta3(entry, ctx, entryId);
+		advisories.push(...entryMerge.advisories);
+		return {
+			value: entryMerge.merged,
+			conflicts: entryMerge.conflicts,
+			stats: EMPTY_STATS
+		};
+	});
+	return {
+		merged: result.merged,
+		conflicts: result.conflicts,
+		stats: result.stats,
+		advisories
+	};
+}
+//#endregion
+//#region src/core/ops/reconcile/merge-model.ts
+/**
+* Schema keys that decide where a model's files live and how they are
+* keyed. When one of THESE is itself in conflict, the content of the model
+* cannot be located or merged safely — the orchestrator blocks the model's
+* content phase and surfaces only the model-level conflict.
+*/
+const STRUCTURAL_MODEL_KEYS = [
+	"kind",
+	"i18n",
+	"locale_strategy",
+	"content_path"
+];
+/**
+* Model definition three-way: top-level keys are leaves, except `fields`,
+* which recurses one level so two sides adding different fields both win.
+* A key changed differently on both sides is a conflict with
+* `suggested: 'theirs'` — the policy table's "the schema belongs to the
+* developer" carried as a suggestion, never auto-applied.
+*/
+function mergeModelFile(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from),
+		structurallyBlocked: false
+	};
+	if (fileLeaf.reason === "delete_edit") return {
+		merged: three.ours,
+		conflicts: [],
+		stats: EMPTY_STATS,
+		deleteEdit: { deletedBy: fileLeaf.deletedBy },
+		structurallyBlocked: false
+	};
+	const conflicts = [];
+	const merged = {};
+	const keys = [...new Set([
+		...Object.keys(three.base ?? {}),
+		...Object.keys(three.ours ?? {}),
+		...Object.keys(three.theirs ?? {})
+	])].toSorted();
+	for (const key of keys) {
+		if (key === "fields") continue;
+		const candidate = {
+			path: ctx.outPath,
+			key,
+			base: three.base?.[key],
+			ours: three.ours?.[key],
+			theirs: three.theirs?.[key]
+		};
+		const leaf = mergeLeaf3(candidate.base, candidate.ours, candidate.theirs);
+		if (leaf.ok) {
+			if (leaf.value !== void 0) merged[key] = leaf.value;
+			continue;
+		}
+		const resolution = ctx.resolutions.consume(candidate);
+		if (resolution) {
+			const value = resolvedValue(resolution, candidate);
+			if (value !== void 0) merged[key] = value;
+			continue;
+		}
+		if (candidate.ours !== void 0) merged[key] = candidate.ours;
+		conflicts.push(makeConflict({
+			...candidate,
+			kind: "model",
+			model: ctx.model,
+			code: "model_key_conflict",
+			message: `Model "${ctx.model}": schema key "${key}" was changed differently on both sides.`,
+			suggested: "theirs"
+		}));
+	}
+	const fieldNames = [...new Set([
+		...Object.keys(three.base?.["fields"] ?? {}),
+		...Object.keys(three.ours?.["fields"] ?? {}),
+		...Object.keys(three.theirs?.["fields"] ?? {})
+	])].toSorted();
+	if (fieldNames.length > 0) {
+		const mergedFields = {};
+		for (const name of fieldNames) {
+			const candidate = {
+				path: ctx.outPath,
+				key: `fields.${name}`,
+				base: (three.base?.["fields"])?.[name],
+				ours: (three.ours?.["fields"])?.[name],
+				theirs: (three.theirs?.["fields"])?.[name]
+			};
+			const leaf = mergeLeaf3(candidate.base, candidate.ours, candidate.theirs);
+			if (leaf.ok) {
+				if (leaf.value !== void 0) mergedFields[name] = leaf.value;
+				continue;
+			}
+			const resolution = ctx.resolutions.consume(candidate);
+			if (resolution) {
+				const value = resolvedValue(resolution, candidate);
+				if (value !== void 0) mergedFields[name] = value;
+				continue;
+			}
+			if (candidate.ours !== void 0) mergedFields[name] = candidate.ours;
+			conflicts.push(makeConflict({
+				...candidate,
+				kind: "model",
+				model: ctx.model,
+				code: leaf.reason === "delete_edit" ? "delete_edit_conflict" : "model_key_conflict",
+				message: `Model "${ctx.model}": field "${name}" was changed differently on both sides.`,
+				suggested: "theirs"
+			}));
+		}
+		if (Object.keys(mergedFields).length > 0) merged["fields"] = mergedFields;
+	}
+	const structurallyBlocked = conflicts.some((c) => STRUCTURAL_MODEL_KEYS.includes(c.key ?? ""));
+	return {
+		merged,
+		conflicts,
+		stats: conflicts.length === 0 ? {
+			takenOurs: 0,
+			takenTheirs: 0,
+			fieldMerged: 1
+		} : EMPTY_STATS,
+		structurallyBlocked
+	};
+}
+//#endregion
+//#region src/core/ops/reconcile/merge-vocabulary.ts
+/**
+* Vocabulary three-way at TERM + LOCALE granularity — finer than the brief
+* asked for, and the reason the collabers scenario resolves with zero
+* human input: one side adding a term's Turkish while the other fixes its
+* English are different leaves, both win. Only the same term in the same
+* locale with two different translations is a question.
+*
+* Matches the inline save semantics (`planVocabularySave` merges
+* per-locale) — one policy family, two doors.
+*/
+function mergeVocabulary(three, ctx) {
+	const fileLeaf = mergeLeaf3(three.base, three.ours, three.theirs);
+	if (fileLeaf.ok) return {
+		merged: fileLeaf.value,
+		conflicts: [],
+		stats: statsFor(fileLeaf.from)
+	};
+	const version = Math.max(three.base?.version ?? 1, three.ours?.version ?? 1, three.theirs?.version ?? 1);
+	const termResult = mergeKeyedRecord3({
+		base: three.base?.terms,
+		ours: three.ours?.terms,
+		theirs: three.theirs?.terms
+	}, (term, item) => {
+		const termLeaf = mergeLeaf3(item.base, item.ours, item.theirs);
+		if (termLeaf.ok) return {
+			value: termLeaf.value,
+			conflicts: [],
+			stats: statsFor(termLeaf.from)
+		};
+		if (termLeaf.reason === "delete_edit") {
+			const candidate = {
+				path: ctx.outPath,
+				key: term,
+				base: item.base,
+				ours: item.ours,
+				theirs: item.theirs
+			};
+			const resolution = ctx.resolutions.consume(candidate);
+			if (resolution) return {
+				value: resolvedValue(resolution, candidate),
+				conflicts: [],
+				stats: EMPTY_STATS
+			};
+			return {
+				value: item.ours,
+				conflicts: [makeConflict({
+					...candidate,
+					kind: "vocabulary",
+					code: "delete_edit_conflict",
+					message: `Vocabulary term "${term}" was deleted on one side and edited on the other.`
+				})],
+				stats: EMPTY_STATS
+			};
+		}
+		const inner = mergeKeyedRecord3(item, (locale, translation) => {
+			const leaf = mergeLeaf3(translation.base, translation.ours, translation.theirs);
+			if (leaf.ok) return {
+				value: leaf.value,
+				conflicts: [],
+				stats: statsFor(leaf.from)
+			};
+			const candidate = {
+				path: ctx.outPath,
+				key: term,
+				locale,
+				base: translation.base,
+				ours: translation.ours,
+				theirs: translation.theirs
+			};
+			const resolution = ctx.resolutions.consume(candidate);
+			if (resolution) return {
+				value: resolvedValue(resolution, candidate),
+				conflicts: [],
+				stats: EMPTY_STATS
+			};
+			return {
+				value: translation.ours,
+				conflicts: [makeConflict({
+					...candidate,
+					kind: "vocabulary",
+					code: leaf.reason === "delete_edit" ? "delete_edit_conflict" : "vocabulary_value_conflict",
+					message: `Term "${term}" has two different "${locale}" translations.`
+				})],
+				stats: EMPTY_STATS
+			};
+		});
+		return {
+			value: Object.keys(inner.merged).length > 0 ? inner.merged : void 0,
+			conflicts: inner.conflicts,
+			stats: inner.conflicts.length === 0 ? addStats(inner.stats, {
+				takenOurs: 0,
+				takenTheirs: 0,
+				fieldMerged: 1
+			}) : inner.stats
+		};
+	});
+	return {
+		merged: {
+			version,
+			terms: termResult.merged
+		},
+		conflicts: termResult.conflicts,
+		stats: termResult.stats
+	};
+}
+//#endregion
+//#region src/core/ops/reconcile/walk.ts
+const SIDES = [
+	"base",
+	"ours",
+	"theirs"
+];
+/** Union of model ids across the three trees, sorted. */
+async function listModelIds(readers) {
+	const listings = await Promise.all(SIDES.map((side) => readers[side].listDirectory(".contentrain/models")));
+	const ids = /* @__PURE__ */ new Set();
+	for (const listing of listings) for (const entry of listing) if (entry.endsWith(".json")) ids.add(entry.slice(0, -5));
+	return [...ids].toSorted();
+}
+/**
+* Enumerate a model's content files on one side, using THAT side's model
+* definition — `content_path` and `locale_strategy` may differ between
+* sides, so each side's files are found where that side actually keeps
+* them. Filenames are mapped back to (locale, slug) by inverting the
+* `paths.ts` layout for the declared strategy; nothing is guessed from
+* config.
+*/
+async function enumerateSideUnits(reader, def, defaultLocale) {
+	const dir = contentDirPath(def);
+	const strategy = def.locale_strategy ?? "file";
+	const units = [];
+	if (def.kind === "document") {
+		if (!def.i18n || strategy === "none") {
+			const entries = await reader.listDirectory(dir);
+			for (const entry of entries) if (entry.endsWith(".md")) units.push({
+				locale: defaultLocale,
+				slug: entry.slice(0, -3),
+				path: `${dir}/${entry}`
+			});
+			return units;
+		}
+		if (strategy === "suffix") {
+			const entries = await reader.listDirectory(dir);
+			for (const entry of entries) {
+				const match = /^(.+)\.([a-z]{2}(?:-[A-Za-z]{2})?)\.md$/.exec(entry);
+				if (match) units.push({
+					slug: match[1],
+					locale: match[2],
+					path: `${dir}/${entry}`
+				});
+			}
+			return units;
+		}
+		if (strategy === "directory") {
+			const locales = await reader.listDirectory(dir);
+			const listings = await Promise.all(locales.map(async (locale) => ({
+				locale,
+				entries: locale.includes(".") ? [] : await reader.listDirectory(`${dir}/${locale}`)
+			})));
+			for (const { locale, entries } of listings) for (const entry of entries) if (entry.endsWith(".md")) units.push({
+				locale,
+				slug: entry.slice(0, -3),
+				path: `${dir}/${locale}/${entry}`
+			});
+			return units;
+		}
+		const slugs = await reader.listDirectory(dir);
+		const listings = await Promise.all(slugs.map(async (slug) => ({
+			slug,
+			entries: slug.includes(".") ? [] : await reader.listDirectory(`${dir}/${slug}`)
+		})));
+		for (const { slug, entries } of listings) for (const entry of entries) if (entry.endsWith(".md")) units.push({
+			slug,
+			locale: entry.slice(0, -3),
+			path: `${dir}/${slug}/${entry}`
+		});
+		return units;
+	}
+	if (!def.i18n) {
+		if (await reader.fileExists(`${dir}/data.json`)) units.push({
+			locale: defaultLocale,
+			path: `${dir}/data.json`
+		});
+		return units;
+	}
+	if (strategy === "none") {
+		if (await reader.fileExists(`${dir}/${def.id}.json`)) units.push({
+			locale: defaultLocale,
+			path: `${dir}/${def.id}.json`
+		});
+		return units;
+	}
+	if (strategy === "suffix") {
+		const entries = await reader.listDirectory(dir);
+		const prefix = `${def.id}.`;
+		for (const entry of entries) if (entry.startsWith(prefix) && entry.endsWith(".json")) {
+			const locale = entry.slice(prefix.length, -5);
+			if (locale && !locale.includes(".")) units.push({
+				locale,
+				path: `${dir}/${entry}`
+			});
+		}
+		return units;
+	}
+	if (strategy === "directory") {
+		const locales = await reader.listDirectory(dir);
+		const checks = await Promise.all(locales.map(async (locale) => ({
+			locale,
+			exists: locale.includes(".") ? false : await reader.fileExists(`${dir}/${locale}/${def.id}.json`)
+		})));
+		for (const { locale, exists } of checks) if (exists) units.push({
+			locale,
+			path: `${dir}/${locale}/${def.id}.json`
+		});
+		return units;
+	}
+	const entries = await reader.listDirectory(dir);
+	for (const entry of entries) if (entry.endsWith(".json") && entry !== "data.json") units.push({
+		locale: entry.slice(0, -5),
+		path: `${dir}/${entry}`
+	});
+	return units;
+}
+/** Resolve the output path of a logical unit under the WINNING definition. */
+function unitOutPath(winning, defaultLocale, locale, slug) {
+	if (winning.kind === "document") return documentFilePath(winning, locale ?? defaultLocale, slug ?? "");
+	return contentFilePath(winning, locale ?? defaultLocale);
+}
+/**
+* Enumerate a model's meta files on one side. The meta layout is fixed
+* (`.contentrain/meta/{id}/[{slug}/]{locale}.json`) regardless of
+* `content_path` or locale strategy, so this stays definition-light and
+* works even while the definitions disagree.
+*/
+async function enumerateMetaUnits(reader, modelId) {
+	const dir = `.contentrain/meta/${modelId}`;
+	const entries = await reader.listDirectory(dir);
+	const units = [];
+	const slugDirs = [];
+	for (const entry of entries) if (entry.endsWith(".json")) units.push({
+		locale: entry.slice(0, -5),
+		path: `${dir}/${entry}`
+	});
+	else if (!entry.includes(".")) slugDirs.push(entry);
+	const nested = await Promise.all(slugDirs.map(async (slug) => ({
+		slug,
+		entries: await reader.listDirectory(`${dir}/${slug}`)
+	})));
+	for (const { slug, entries: files } of nested) for (const file of files) if (file.endsWith(".json")) units.push({
+		locale: file.slice(0, -5),
+		slug,
+		path: `${dir}/${slug}/${file}`
+	});
+	return units;
+}
+const SCAN_MAX_DEPTH = 6;
+const SCAN_SKIP = new Set([".contentrain/client", ".contentrain/context.json"]);
+/**
+* Recursively list candidate text files (`.json` / `.md`) under `root` on
+* one side. The generated client and context.json are never candidates;
+* depth is bounded as a runaway guard. Anything that is not a candidate
+* extension is treated as a possible directory — listing a file yields an
+* empty array on every reader, so the probe is safe.
+*/
+async function listTextFiles(reader, root, depth = 0) {
+	if (depth > SCAN_MAX_DEPTH) return [];
+	const entries = await reader.listDirectory(root);
+	return (await Promise.all(entries.map(async (entry) => {
+		const path = root === "" ? entry : `${root}/${entry}`;
+		if (SCAN_SKIP.has(path)) return [];
+		if (entry.endsWith(".json") || entry.endsWith(".md")) return [path];
+		return listTextFiles(reader, path, depth + 1);
+	}))).flat();
+}
+//#endregion
+//#region src/core/ops/reconcile/plan.ts
+const CONTEXT_PATH = ".contentrain/context.json";
+const VOCABULARY_PATH = ".contentrain/vocabulary.json";
+const SOURCES_PATH = ".contentrain/normalize-sources.json";
+const MAX_VALIDATION_ADVISORIES = 15;
+/**
+* Content-aware three-way merge of `.contentrain/**` (plus `content_path`
+* roots) between a merge-base, the content branch (ours) and the base
+* branch (theirs). Pure planning: reads through the three bound readers,
+* writes nothing, and returns `FileChange[]` to apply ON TOP OF OURS,
+* `ConflictItem[]` for whatever the policy table cannot decide, and a
+* regenerated context.json whenever the plan is not a no-op.
+*
+* Determinism: the same three trees with the same resolutions produce the
+* same changes and the same conflict ids — context.json's embedded
+* timestamp is the sole documented exception.
+*/
+async function planReconcile(input) {
+	const readers = {
+		base: new CachedReader(input.base),
+		ours: new CachedReader(input.ours),
+		theirs: new CachedReader(input.theirs)
+	};
+	const resolutions = new ResolutionIndex(input.resolutions ?? []);
+	const conflicts = [];
+	const advisories = [];
+	const outputs = [];
+	const claimed = /* @__PURE__ */ new Set();
+	let stats = EMPTY_STATS;
+	const defaultLocale = (await readJsonOrNull(readers.ours, ".contentrain/config.json"))?.locales?.default ?? "en";
+	const modelIds = await listModelIds(readers);
+	const modelStates = (await Promise.all(modelIds.map(async (id) => {
+		const path = `.contentrain/models/${id}.json`;
+		const [base, ours, theirs] = await Promise.all(SIDES.map((side) => readJsonOrNull(readers[side], path)));
+		return {
+			id,
+			path,
+			three: {
+				base: base ?? void 0,
+				ours: ours ?? void 0,
+				theirs: theirs ?? void 0
+			}
+		};
+	}))).map((m) => {
+		claimed.add(m.path);
+		const result = mergeModelFile(m.three, {
+			outPath: m.path,
+			kind: "model",
+			model: m.id,
+			resolutions
+		});
+		return {
+			id: m.id,
+			path: m.path,
+			three: m.three,
+			result
+		};
+	});
+	await Promise.all(modelStates.map(async (state) => {
+		const { id, path, three, result } = state;
+		const oursAbsent = three.ours === void 0;
+		const theirsAbsent = three.theirs === void 0;
+		const oneSideDeleted = three.base !== void 0 && oursAbsent !== theirsAbsent;
+		if (result.deleteEdit || result.merged === void 0 && oneSideDeleted) {
+			const deletedBy = result.deleteEdit?.deletedBy ?? (oursAbsent ? "ours" : "theirs");
+			const survivor = deletedBy === "ours" ? "theirs" : "ours";
+			await collapseModelDeletion(state.id, path, three, deletedBy, survivor, !!result.deleteEdit);
+			return;
+		}
+		conflicts.push(...result.conflicts);
+		stats = addStats(stats, result.stats);
+		if (result.merged === void 0) {
+			await claimModelFiles(id, three);
+			return;
+		}
+		if (result.structurallyBlocked) {
+			advisories.push(`Model "${id}": structural schema keys are in conflict — its content was left untouched until they are resolved.`);
+			await claimModelFiles(id, three);
+			return;
+		}
+		const winning = result.merged;
+		if (typeof winning.kind !== "string" || typeof winning.id !== "string") {
+			advisories.push(`Model "${id}": merged definition is structurally incomplete — content left untouched.`);
+			await claimModelFiles(id, three);
+			return;
+		}
+		outputs.push({
+			path,
+			format: "model",
+			value: result.merged
+		});
+		const sideDefs = {};
+		for (const side of SIDES) {
+			const def = three[side];
+			if (def && typeof def.kind === "string") sideDefs[side] = def;
+		}
+		const perSide = await Promise.all(SIDES.map(async (side) => {
+			const def = sideDefs[side];
+			return {
+				side,
+				units: def ? await enumerateSideUnits(readers[side], def, defaultLocale) : []
+			};
+		}));
+		const unitMap = /* @__PURE__ */ new Map();
+		for (const { side, units } of perSide) for (const unit of units) {
+			claimed.add(unit.path);
+			const key = unitKey(unit);
+			const entry = unitMap.get(key) ?? {
+				locale: unit.locale,
+				slug: unit.slug,
+				paths: {}
+			};
+			entry.paths[side] = unit.path;
+			unitMap.set(key, entry);
+		}
+		await Promise.all([...unitMap.values()].map(async (unit) => {
+			const [baseRaw, oursRaw, theirsRaw] = await Promise.all(SIDES.map((side) => unit.paths[side] ? readers[side].readOrNull(unit.paths[side]) : Promise.resolve(null)));
+			const outPath = unitOutPath(winning, defaultLocale, unit.locale, unit.slug);
+			claimed.add(outPath);
+			const ctx = {
+				outPath,
+				kind: winning.kind,
+				model: id,
+				locale: unit.locale,
+				resolutions
+			};
+			if (winning.kind === "document") {
+				const merge = mergeDocumentFile({
+					base: baseRaw ?? void 0,
+					ours: oursRaw ?? void 0,
+					theirs: theirsRaw ?? void 0
+				}, {
+					...ctx,
+					slug: unit.slug ?? ""
+				});
+				conflicts.push(...merge.conflicts);
+				advisories.push(...merge.advisories);
+				stats = addStats(stats, merge.stats);
+				outputs.push({
+					path: outPath,
+					format: "md",
+					value: merge.merged ?? null
+				});
+			} else {
+				const parsed = {
+					base: parseJson(baseRaw ?? null),
+					ours: parseJson(oursRaw ?? null),
+					theirs: parseJson(theirsRaw ?? null)
+				};
+				const merge = winning.kind === "dictionary" ? mergeDictionaryFile(parsed, ctx) : winning.kind === "singleton" ? mergeSingletonFile(parsed, ctx) : mergeCollectionFile(parsed, ctx);
+				conflicts.push(...merge.conflicts);
+				stats = addStats(stats, merge.stats);
+				outputs.push({
+					path: outPath,
+					format: "json",
+					value: merge.merged ?? null
+				});
+			}
+			if (unit.paths.ours && unit.paths.ours !== outPath) outputs.push({
+				path: unit.paths.ours,
+				format: "raw",
+				value: null
+			});
+		}));
+		const metaPerSide = await Promise.all(SIDES.map((side) => enumerateMetaUnits(readers[side], id)));
+		const metaMap = /* @__PURE__ */ new Map();
+		for (const units of metaPerSide) for (const unit of units) {
+			claimed.add(unit.path);
+			metaMap.set(unit.path, unit);
+		}
+		await Promise.all([...metaMap.values()].map(async (unit) => {
+			const [base, ours, theirs] = await Promise.all(SIDES.map((side) => readJsonOrNull(readers[side], unit.path)));
+			const merge = mergeMetaFile({
+				base: base ?? void 0,
+				ours: ours ?? void 0,
+				theirs: theirs ?? void 0
+			}, {
+				outPath: unit.path,
+				kind: "meta",
+				model: id,
+				locale: unit.locale,
+				resolutions
+			}, winning.kind === "collection");
+			conflicts.push(...merge.conflicts);
+			advisories.push(...merge.advisories);
+			stats = addStats(stats, merge.stats);
+			outputs.push({
+				path: unit.path,
+				format: "json",
+				value: merge.merged ?? null
+			});
+		}));
+	}));
+	claimed.add(VOCABULARY_PATH);
+	claimed.add(SOURCES_PATH);
+	{
+		const [base, ours, theirs] = await Promise.all(SIDES.map((side) => readJsonOrNull(readers[side], VOCABULARY_PATH)));
+		if (base !== null || ours !== null || theirs !== null) {
+			const merge = mergeVocabulary({
+				base: base ?? void 0,
+				ours: ours ?? void 0,
+				theirs: theirs ?? void 0
+			}, {
+				outPath: VOCABULARY_PATH,
+				kind: "vocabulary",
+				resolutions
+			});
+			conflicts.push(...merge.conflicts);
+			stats = addStats(stats, merge.stats);
+			outputs.push({
+				path: VOCABULARY_PATH,
+				format: "json",
+				value: merge.merged ?? null
+			});
+		}
+	}
+	{
+		const [base, ours, theirs] = await Promise.all(SIDES.map((side) => readJsonOrNull(readers[side], SOURCES_PATH)));
+		if (base !== null || ours !== null || theirs !== null) {
+			const merge = mergeKeyedJson({
+				base: base ?? void 0,
+				ours: ours ?? void 0,
+				theirs: theirs ?? void 0
+			}, {
+				outPath: SOURCES_PATH,
+				kind: "file",
+				resolutions
+			});
+			conflicts.push(...merge.conflicts);
+			stats = addStats(stats, merge.stats);
+			outputs.push({
+				path: SOURCES_PATH,
+				format: "json",
+				value: merge.merged ?? null
+			});
+		}
+	}
+	const roots = new Set([".contentrain"]);
+	for (const state of modelStates) for (const side of SIDES) {
+		const contentPath = state.three[side]?.content_path;
+		if (typeof contentPath === "string" && contentPath.length > 0) roots.add(contentPath);
+	}
+	const scanned = await Promise.all([...roots].map(async (root) => Promise.all(SIDES.map((side) => listTextFiles(readers[side], root)))));
+	const candidates = /* @__PURE__ */ new Set();
+	for (const perRoot of scanned) for (const files of perRoot) for (const file of files) if (!claimed.has(file)) candidates.add(file);
+	await Promise.all([...candidates].toSorted().map(async (path) => {
+		const [baseRaw, oursRaw, theirsRaw] = await Promise.all(SIDES.map((side) => readers[side].readOrNull(path)));
+		const leaf = mergeLeaf3(baseRaw ?? void 0, oursRaw ?? void 0, theirsRaw ?? void 0);
+		if (leaf.ok) {
+			if (leaf.from === "theirs") outputs.push({
+				path,
+				format: "raw",
+				value: leaf.value ?? null
+			});
+			return;
+		}
+		const digestCandidate = {
+			path,
+			base: baseRaw == null ? void 0 : stableHash(baseRaw),
+			ours: oursRaw == null ? void 0 : stableHash(oursRaw),
+			theirs: theirsRaw == null ? void 0 : stableHash(theirsRaw)
+		};
+		const resolution = resolutions.consume(digestCandidate);
+		if (resolution && "choose" in resolution) {
+			const chosen = resolution.choose === "ours" ? oursRaw : theirsRaw;
+			outputs.push({
+				path,
+				format: "raw",
+				value: chosen
+			});
+			return;
+		}
+		if (resolution) advisories.push(`Resolution for "${path}" supplied a value — file-level conflicts accept only { choose } and the resolution was ignored.`);
+		conflicts.push({
+			id: conflictId(digestCandidate),
+			path,
+			kind: "file",
+			code: "file_conflict",
+			message: `${path} was changed on both sides and is not content this planner understands — choose a side.`
+		});
+	}));
+	const changes = [];
+	await Promise.all(outputs.map(async (out) => {
+		const oursRaw = await readers.ours.readOrNull(out.path);
+		if (out.value === null) {
+			if (oursRaw !== null) changes.push({
+				path: out.path,
+				content: null
+			});
+			return;
+		}
+		if (out.format === "md" || out.format === "raw") {
+			const next = out.value;
+			if (oursRaw === null) {
+				changes.push({
+					path: out.path,
+					content: next
+				});
+				return;
+			}
+			if (out.format === "raw") {
+				if (oursRaw !== next) changes.push({
+					path: out.path,
+					content: next
+				});
+				return;
+			}
+			const a = parseMarkdownFrontmatter(oursRaw);
+			const b = parseMarkdownFrontmatter(next);
+			if (!eqCanonical(a.frontmatter, b.frontmatter) || a.body !== b.body) changes.push({
+				path: out.path,
+				content: next
+			});
+			return;
+		}
+		const oursParsed = parseJson(oursRaw);
+		if (eqCanonical(out.value, oursParsed)) return;
+		const fieldOrder = out.format === "model" ? MODEL_FIELD_ORDER : void 0;
+		changes.push({
+			path: out.path,
+			content: canonicalStringify(out.value, fieldOrder)
+		});
+	}));
+	const filesMerged = changes.length;
+	const regenerated = [];
+	if (changes.length > 0) try {
+		const contextChange = await buildContextChange(new OverlayReader(readers.ours, changes), {
+			tool: "contentrain_reconcile",
+			model: "*"
+		}, input.source);
+		changes.push(contextChange);
+		regenerated.push(CONTEXT_PATH);
+	} catch {
+		advisories.push("context.json could not be regenerated — run contentrain_validate after applying.");
+	}
+	if (changes.length > 0) try {
+		const issues = (await validateProject(new OverlayReader(readers.ours, changes), {})).issues.filter((i) => i.severity !== "notice");
+		const shown = issues.slice(0, MAX_VALIDATION_ADVISORIES);
+		for (const issue of shown) advisories.push(`validation (${issue.severity}): ${issue.model ?? ""}${issue.field ? `.${issue.field}` : ""} — ${issue.message}`);
+		if (issues.length > shown.length) advisories.push(`validation: ${issues.length - shown.length} more issue(s) — run contentrain_validate for the full report.`);
+	} catch {
+		advisories.push("Post-merge validation could not run — validate after applying.");
+	}
+	for (const stale of resolutions.unconsumed()) advisories.push(`Resolution ${stale.id} no longer matches any conflict — values changed since the dry-run; the conflict is re-reported with a new id.`);
+	if (changes.length === 0 && conflicts.length === 0) advisories.push("Trees are already reconciled — nothing to merge.");
+	changes.sort((a, b) => a.path.localeCompare(b.path, "en"));
+	conflicts.sort((a, b) => a.path.localeCompare(b.path, "en") || (a.key ?? "").localeCompare(b.key ?? "", "en") || (a.field ?? "").localeCompare(b.field ?? "", "en") || (a.locale ?? "").localeCompare(b.locale ?? "", "en"));
+	return {
+		changes,
+		conflicts,
+		advisories,
+		result: {
+			files_merged: filesMerged,
+			entries_taken_ours: stats.takenOurs,
+			entries_taken_theirs: stats.takenTheirs,
+			entries_field_merged: stats.fieldMerged,
+			regenerated
+		}
+	};
+	/** Claim every side's files of a model so the scan never double-reports. */
+	async function claimModelFiles(id, three) {
+		await Promise.all(SIDES.map(async (side) => {
+			const def = three[side];
+			if (def && typeof def.kind === "string") {
+				const units = await enumerateSideUnits(readers[side], def, defaultLocale);
+				for (const unit of units) claimed.add(unit.path);
+			}
+			const meta = await enumerateMetaUnits(readers[side], id);
+			for (const unit of meta) claimed.add(unit.path);
+		}));
+	}
+	/**
+	* One side deleted the model. If the surviving side left everything
+	* untouched, the deletion cascades mechanically over content and meta.
+	* The moment the survivor edited anything — the definition or one entry —
+	* the whole model collapses into a SINGLE delete-vs-edit question
+	* instead of one conflict per file.
+	*/
+	async function collapseModelDeletion(id, modelPath, three, deletedBy, survivor, modelFileEdited) {
+		await claimModelFiles(id, three);
+		const survivorDef = three[survivor];
+		const survivorFiles = await modelFileDigestList(survivor, id, survivorDef);
+		const baseFiles = await modelFileDigestList("base", id, three.base);
+		const contentEdited = JSON.stringify(survivorFiles) !== JSON.stringify(baseFiles);
+		if (!modelFileEdited && !contentEdited) {
+			await deleteModelEverywhere(id, three);
+			return;
+		}
+		const digestFor = async (side) => {
+			const def = three[side];
+			if (!def && side !== "base") return void 0;
+			const files = await modelFileDigestList(side, id, def);
+			return {
+				model: three[side] ? stableHash(JSON.stringify(three[side])) : null,
+				files: stableHash(JSON.stringify(files))
+			};
+		};
+		const [baseDigest, oursDigest, theirsDigest] = await Promise.all([
+			digestFor("base"),
+			digestFor("ours"),
+			digestFor("theirs")
+		]);
+		const candidate = {
+			path: modelPath,
+			base: baseDigest,
+			ours: oursDigest,
+			theirs: theirsDigest
+		};
+		const resolution = resolutions.consume(candidate);
+		if (resolution && "choose" in resolution) {
+			if (resolution.choose === deletedBy) await deleteModelEverywhere(id, three);
+			else await keepModelWholesale(id, modelPath, three, survivor);
+			return;
+		}
+		if (resolution) advisories.push(`Resolution for model "${id}" supplied a value — model delete-vs-edit accepts only { choose } and the resolution was ignored.`);
+		conflicts.push(makeConflict({
+			...candidate,
+			kind: "model",
+			model: id,
+			code: "delete_edit_conflict",
+			message: `Model "${id}" was deleted on one side (${deletedBy}) while the other side edited its ${modelFileEdited ? "definition" : "content"} — keep the model or drop it.`
+		}));
+	}
+	/** Digest list of one side's model-owned files (content + meta), sorted. */
+	async function modelFileDigestList(side, id, def) {
+		const units = def && typeof def.kind === "string" ? await enumerateSideUnits(readers[side], def, defaultLocale) : [];
+		const meta = await enumerateMetaUnits(readers[side], id);
+		const paths = [...units.map((u) => u.path), ...meta.map((u) => u.path)].toSorted();
+		const raws = await Promise.all(paths.map((path) => readers[side].readOrNull(path)));
+		return paths.map((path, i) => [path, stableHash(raws[i] ?? "")]);
+	}
+	/** Emit deletions for every model-owned file ours still carries. */
+	async function deleteModelEverywhere(id, three) {
+		outputs.push({
+			path: `.contentrain/models/${id}.json`,
+			format: "raw",
+			value: null
+		});
+		const oursDef = three.ours;
+		const units = oursDef && typeof oursDef.kind === "string" ? await enumerateSideUnits(readers.ours, oursDef, defaultLocale) : [];
+		const meta = await enumerateMetaUnits(readers.ours, id);
+		for (const unit of [...units.map((u) => u.path), ...meta.map((u) => u.path)]) outputs.push({
+			path: unit,
+			format: "raw",
+			value: null
+		});
+	}
+	/** Take the surviving side wholesale: definition, content, meta. */
+	async function keepModelWholesale(id, modelPath, three, survivor) {
+		outputs.push({
+			path: modelPath,
+			format: "model",
+			value: three[survivor]
+		});
+		const survivorDef = three[survivor];
+		const units = survivorDef && typeof survivorDef.kind === "string" ? await enumerateSideUnits(readers[survivor], survivorDef, defaultLocale) : [];
+		const meta = await enumerateMetaUnits(readers[survivor], id);
+		const survivorPaths = [...units.map((u) => u.path), ...meta.map((u) => u.path)];
+		const raws = await Promise.all(survivorPaths.map((path) => readers[survivor].readOrNull(path)));
+		survivorPaths.forEach((path, i) => {
+			outputs.push({
+				path,
+				format: "raw",
+				value: raws[i]
+			});
+		});
+		const oursDef = three.ours;
+		const oursUnits = oursDef && typeof oursDef.kind === "string" ? await enumerateSideUnits(readers.ours, oursDef, defaultLocale) : [];
+		const oursMeta = await enumerateMetaUnits(readers.ours, id);
+		const survivorSet = new Set(survivorPaths);
+		for (const path of [...oursUnits.map((u) => u.path), ...oursMeta.map((u) => u.path)]) if (!survivorSet.has(path)) outputs.push({
+			path,
+			format: "raw",
+			value: null
+		});
+	}
+}
+function unitKey(u) {
+	return `${u.locale ?? ""}::${u.slug ?? ""}`;
+}
+function parseJson(raw) {
+	if (raw === null) return void 0;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { applyChangesToWorktree as n, planReconcile as t };
+
+//# sourceMappingURL=reconcile-D5FTVW5z.mjs.map