@lmzhen/dsh-evolution-merge 0.0.0 → 0.28.0

package/lib/index.js

@@ -0,0 +1,3997 @@
+import z from "@deepseek-ai/schemastery";
+import { DEFAULT_SKILL_LIMITS, affinity, authorityFrom, contentHash, createSubagentChannel, evolutionHome, evolutionIoAdapter, executeUnitUndo, isPresent, newRunRegistry, newSkillLibrary, parseFrontmatter, planUnitUndoAcross, policyStageLimits, probeAbsent, probeList, probePresent, probeText, probeUnknown, scanContentThreats, supportRefs, transactIo, validateFrontmatter, validateSupportPath, vocabulary } from "@lmzhen/dsh-evolution-core";
+import { HOST_ROUTES, json, methodNotAllowed, registerHostRoutes } from "@lmzhen/dsh-evolution-core/http-routes";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+//#region lib/types/contracts.js
+/**
+* Frozen merge-domain vocabulary. No io, no host, no imports from the plugin shell.
+*
+* The data layer keeps four states; the user face collapses verify/fuse into one retry
+* queue and keeps the stage as a chip. The API queue must never expose the raw state.
+*/
+const MERGE_STATE_VERSION = 1;
+const MERGE_PAIR_STATES = [
+	"verify",
+	"pending",
+	"fuse",
+	"skipped"
+];
+const MERGE_QUEUES = [
+	"pending",
+	"retry",
+	"skipped"
+];
+/** User-facing queue of one data state. verify/fuse share retry, not two tabs. */
+function queueOf(state) {
+	switch (state) {
+		case "pending": return "pending";
+		case "verify":
+		case "fuse": return "retry";
+		case "skipped": return "skipped";
+	}
+}
+/** Coarse stage chip; skipped has no active stage. */
+function stageOf(state) {
+	switch (state) {
+		case "verify": return "verify";
+		case "pending": return "decide";
+		case "fuse": return "author";
+		case "skipped": return null;
+	}
+}
+/** Stable pair identity; NUL cannot appear in a skill name. */
+function pairKey(a, b) {
+	return a < b ? a + "\0" + b : b + "\0" + a;
+}
+/** Deterministic, URL-safe id derived from the pair key (FNV-1a 32). */
+function rowIdOf(key) {
+	let hash = 2166136261;
+	for (let index = 0; index < key.length; index += 1) {
+		hash ^= key.charCodeAt(index);
+		hash = Math.imul(hash, 16777619) >>> 0;
+	}
+	return "mr_" + hash.toString(36).padStart(7, "0");
+}
+function emptyMergeState() {
+	return {
+		schemaVersion: 1,
+		rows: []
+	};
+}
+/** One record can be retried only when the failure says so and names a stage. */
+function canRetry(record) {
+	if (record.state === "skipped") return false;
+	if (record.failure === void 0) return record.state !== "pending";
+	return record.failure.retryable && record.failure.retryFrom !== "none";
+}
+//#endregion
+//#region lib/types/state.js
+/**
+* The one merge-state ledger: <home>/merge/merge-state.json.
+*
+* Reads are pure projections (no write, no reconciliation side effect). Every write goes
+* through mutateMergeState and a single transactIo, so there is no second file and no
+* incremental writer. A row's queue is always derived from its state on read; a hand-edited
+* mismatch is repaired by the next write, never by a GET.
+*/
+function mergeStatePath(home) {
+	return join(home, "merge", "merge-state.json");
+}
+function isState(value) {
+	return typeof value === "string" && MERGE_PAIR_STATES.includes(value);
+}
+function parseState(raw) {
+	if (raw === null) return {
+		ok: true,
+		rows: []
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {
+			ok: false,
+			rows: []
+		};
+	}
+	const body = parsed;
+	if (!Array.isArray(body.rows)) return {
+		ok: false,
+		rows: []
+	};
+	const rows = [];
+	let skipped = 0;
+	for (const value of body.rows) {
+		const row = value;
+		if (typeof row.id !== "string" || typeof row.pairKey !== "string" || typeof row.a !== "string" || typeof row.b !== "string") {
+			skipped += 1;
+			continue;
+		}
+		if (!isState(row.state) || typeof row.createdAt !== "string" || typeof row.updatedAt !== "string") {
+			skipped += 1;
+			continue;
+		}
+		const normalized = {
+			id: row.id,
+			pairKey: row.pairKey,
+			a: row.a,
+			b: row.b,
+			state: row.state,
+			queue: queueOf(row.state),
+			createdAt: row.createdAt,
+			updatedAt: row.updatedAt,
+			...row.failure === void 0 ? {} : { failure: row.failure },
+			...row.decision === void 0 ? {} : { decision: row.decision },
+			...typeof row.runId === "string" ? { runId: row.runId } : {},
+			...typeof row.unitId === "string" ? { unitId: row.unitId } : {},
+			...row.origin === "agent" || row.origin === "human" ? { origin: row.origin } : {},
+			...typeof row.attempts === "number" ? { attempts: row.attempts } : {}
+		};
+		rows.push(normalized);
+	}
+	const versionNote = typeof body.schemaVersion === "number" && body.schemaVersion !== 1 ? "the index declares schemaVersion " + String(body.schemaVersion) + " while this build writes " + String(1) : void 0;
+	const note = versionNote === void 0 ? skipped === 0 ? void 0 : String(skipped) + " invalid row(s) skipped" : skipped === 0 ? versionNote : versionNote + "; " + String(skipped) + " invalid row(s) skipped";
+	return {
+		ok: true,
+		rows,
+		...note === void 0 ? {} : { note }
+	};
+}
+/** Pure read: never writes, never deletes a row. */
+async function loadMergeState(io, home) {
+	let raw = null;
+	try {
+		raw = await io.readText(mergeStatePath(home));
+	} catch {
+		return {
+			ok: false,
+			state: {
+				schemaVersion: 1,
+				rows: []
+			}
+		};
+	}
+	const parsed = parseState(raw);
+	return {
+		ok: parsed.ok,
+		state: {
+			schemaVersion: 1,
+			rows: parsed.rows
+		},
+		...parsed.note === void 0 ? {} : { note: parsed.note }
+	};
+}
+/** The ONE write point. The callback returns the whole row set, not a delta. */
+async function mutateMergeState(io, home, now, fn) {
+	let result;
+	await transactIo(io, mergeStatePath(home), (current) => {
+		const out = fn(parseState(current).rows);
+		result = out.result;
+		return JSON.stringify({
+			schemaVersion: 1,
+			rows: out.rows
+		}, null, 2);
+	});
+	return result;
+}
+async function upsertRow(io, home, now, row) {
+	await mutateMergeState(io, home, now, (rows) => {
+		const index = rows.findIndex((item) => item.pairKey === row.pairKey);
+		const normalized = {
+			...row,
+			queue: queueOf(row.state)
+		};
+		const next = [...rows];
+		if (index < 0) next.push(normalized);
+		else next[index] = {
+			...normalized,
+			createdAt: rows[index]?.createdAt ?? normalized.createdAt
+		};
+		return {
+			rows: next,
+			result: void 0
+		};
+	});
+}
+async function moveRow(io, home, now, id, patch) {
+	return await mutateMergeState(io, home, now, (rows) => {
+		const index = rows.findIndex((item) => item.id === id);
+		if (index < 0) return {
+			rows,
+			result: void 0
+		};
+		const current = rows[index];
+		const state = patch.state ?? current.state;
+		const next = {
+			...current,
+			state,
+			queue: queueOf(state),
+			updatedAt: new Date(now()).toISOString(),
+			...patch.failure === void 0 ? {} : { failure: patch.failure },
+			...patch.runId === void 0 ? {} : { runId: patch.runId },
+			...patch.unitId === void 0 ? {} : { unitId: patch.unitId },
+			...patch.origin === void 0 ? {} : { origin: patch.origin },
+			...patch.attempts === void 0 ? {} : { attempts: patch.attempts }
+		};
+		const copy = [...rows];
+		copy[index] = next;
+		return {
+			rows: copy,
+			result: next
+		};
+	});
+}
+async function dropRow(io, home, now, id) {
+	return await mutateMergeState(io, home, now, (rows) => {
+		const next = rows.filter((item) => item.id !== id);
+		return {
+			rows: next,
+			result: next.length !== rows.length
+		};
+	});
+}
+async function rowsOf(io, home, queue) {
+	const loaded = await loadMergeState(io, home);
+	return queue === void 0 ? loaded.state.rows : loaded.state.rows.filter((row) => row.queue === queue);
+}
+//#endregion
+//#region lib/types/status.js
+function countRows(rows) {
+	const counts = {
+		pending: 0,
+		retry: 0,
+		skipped: 0
+	};
+	for (const row of rows) counts[queueOf(row.state)] += 1;
+	return counts;
+}
+function describe(row) {
+	const stage = stageOf(row.state);
+	const target = row.decision?.shouldMerge === true ? " → " + row.decision.target : "";
+	return row.a + " + " + row.b + " [" + row.state + (stage === null ? "" : "/" + stage) + "]" + target + (row.failure === void 0 ? "" : " — " + row.failure.message);
+}
+function formatStatus(rows) {
+	const counts = countRows(rows);
+	const lines = ["merge: pending " + String(counts.pending) + ", retry " + String(counts.retry) + ", skipped " + String(counts.skipped)];
+	for (const row of rows) lines.push("- " + describe(row));
+	return lines.join("\n");
+}
+function formatQueue(rows, queue) {
+	const selected = rows.filter((row) => queueOf(row.state) === queue);
+	if (selected.length === 0) return "merge " + queue + ": empty";
+	return ["merge " + queue + ": " + String(selected.length)].concat(selected.map((row) => "- " + describe(row))).join("\n");
+}
+//#endregion
+//#region lib/types/routes.js
+function toRowView(row) {
+	return {
+		id: row.id,
+		pairKey: row.pairKey,
+		a: row.a,
+		b: row.b,
+		state: row.state,
+		queue: queueOf(row.state),
+		stage: stageOf(row.state),
+		label: row.a + " + " + row.b,
+		updatedAt: row.updatedAt
+	};
+}
+function buildMergeView(rows, commands) {
+	const counts = countRows(rows);
+	return {
+		schemaVersion: 1,
+		counts,
+		tabs: [
+			{
+				queue: "pending",
+				count: counts.pending
+			},
+			{
+				queue: "retry",
+				count: counts.retry
+			},
+			{
+				queue: "skipped",
+				count: counts.skipped
+			}
+		],
+		commands
+	};
+}
+function pageQueue(rows, queue, cursor = 0, limit = 50) {
+	const filtered = rows.filter((row) => queueOf(row.state) === queue);
+	const size = Math.max(1, Math.min(200, limit));
+	const start = Math.max(0, cursor);
+	const items = filtered.slice(start, start + size).map(toRowView);
+	const next = start + size < filtered.length ? String(start + size) : void 0;
+	return {
+		queue,
+		items,
+		...next === void 0 ? {} : { nextCursor: next }
+	};
+}
+function toRunFact(run) {
+	return {
+		id: run.id,
+		state: run.state,
+		...run.command === void 0 ? {} : { command: run.command },
+		...run.stage === void 0 ? {} : { stage: run.stage },
+		...run.progress === void 0 ? {} : { progress: run.progress },
+		startedAt: run.startedAt,
+		...run.endedAt === void 0 ? {} : { endedAt: run.endedAt },
+		...run.resultRef === void 0 ? {} : { resultRef: run.resultRef },
+		...run.failure === void 0 ? {} : { failure: run.failure },
+		...run.supersededAt === void 0 ? {} : { supersededAt: run.supersededAt }
+	};
+}
+//#endregion
+//#region lib/types/merge-routes.js
+const MERGE_ROUTES = HOST_ROUTES.merge;
+function makeMergeRoutes(deps, _audit) {
+	const absent = () => json(503, {
+		ok: false,
+		error: {
+			code: "merge-service-absent",
+			message: "merge service is not mounted"
+		}
+	});
+	const get = (request) => request.method === "GET" ? null : methodNotAllowed(["GET"]);
+	const url = (request) => new URL(request.url, "http://local");
+	return [
+		{
+			path: MERGE_ROUTES.view,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: async (request) => {
+				const denied = get(request);
+				if (denied !== null) return denied;
+				const source = deps.getSource();
+				if (source === void 0) return absent();
+				return json(200, {
+					ok: true,
+					data: buildMergeView(await source.rows(), source.commands())
+				});
+			}
+		},
+		{
+			path: MERGE_ROUTES.rows,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: async (request) => {
+				const denied = get(request);
+				if (denied !== null) return denied;
+				const source = deps.getSource();
+				if (source === void 0) return absent();
+				const query = url(request).searchParams;
+				const queue = query.get("queue") ?? "retry";
+				if (queue !== "pending" && queue !== "retry" && queue !== "skipped") return json(400, {
+					ok: false,
+					error: {
+						code: "bad-queue",
+						message: "queue must be pending/retry/skipped"
+					}
+				});
+				const cursor = Number.parseInt(query.get("cursor") ?? "0", 10);
+				const limit = Number.parseInt(query.get("limit") ?? "50", 10);
+				return json(200, {
+					ok: true,
+					data: pageQueue(await source.rows(), queue, Number.isFinite(cursor) ? cursor : 0, Number.isFinite(limit) ? limit : 50)
+				});
+			}
+		},
+		{
+			path: MERGE_ROUTES.run,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: async (request) => {
+				const denied = get(request);
+				if (denied !== null) return denied;
+				const source = deps.getSource();
+				if (source === void 0) return absent();
+				const id = url(request).searchParams.get("id");
+				if (id === null || id === "") return json(400, {
+					ok: false,
+					error: {
+						code: "missing-id",
+						message: "id is required"
+					}
+				});
+				const run = await source.run(id);
+				return run === void 0 ? json(404, {
+					ok: false,
+					error: {
+						code: "run-not-found",
+						message: "merge run not found: " + id
+					}
+				}) : json(200, {
+					ok: true,
+					data: toRunFact(run)
+				});
+			}
+		},
+		{
+			path: MERGE_ROUTES.runs,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: async (request) => {
+				const denied = get(request);
+				if (denied !== null) return denied;
+				const source = deps.getSource();
+				if (source === void 0) return absent();
+				const query = url(request).searchParams;
+				const limit = Number.parseInt(query.get("limit") ?? "20", 10);
+				return json(200, {
+					ok: true,
+					data: { items: (await source.runs(query.get("cursor") ?? void 0, Number.isFinite(limit) ? limit : 20)).map(toRunFact) }
+				});
+			}
+		}
+	];
+}
+//#endregion
+//#region lib/types/commands.js
+const USAGE = "usage: merge scan | pair <a> <b> | status [id] | report [id] | cancel [id] | runs | doctor | pending | approve <id> | reject <id> | resume [id] [--clear <id>] | skipped [--restore <id>] | undo <target> --run <id>";
+function flags(args, allowed) {
+	const values = /* @__PURE__ */ new Map();
+	for (let index = 0; index < args.length; index += 1) {
+		const token = args[index];
+		if (!token.startsWith("--")) continue;
+		const name = token.slice(2);
+		if (!allowed.includes(name)) return {
+			values,
+			error: "unknown flag: --" + name
+		};
+		const value = args[index + 1];
+		if (value === void 0 || value.startsWith("--")) return {
+			values,
+			error: "missing value for --" + name
+		};
+		values.set(name, value);
+		index += 1;
+	}
+	return { values };
+}
+function positional(args) {
+	return args.filter((token, index) => !token.startsWith("--") && !(index > 0 && args[index - 1].startsWith("--")));
+}
+function parseMergeCommand(argv) {
+	const [verb, ...rest] = argv;
+	if (verb === void 0 || verb === "help" || verb === "--help" || verb === "-h") return {
+		ok: true,
+		command: { verb: "scan" },
+		help: true
+	};
+	const pos = positional(rest);
+	switch (verb) {
+		case "scan": return pos.length === 0 ? {
+			ok: true,
+			command: { verb: "scan" }
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "pair": return pos.length === 2 ? {
+			ok: true,
+			command: {
+				verb: "pair",
+				a: pos[0],
+				b: pos[1]
+			}
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "status": return pos.length <= 1 ? {
+			ok: true,
+			command: {
+				verb: "status",
+				...pos[0] === void 0 ? {} : { id: pos[0] }
+			}
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "report": return pos.length <= 1 ? {
+			ok: true,
+			command: {
+				verb: "report",
+				...pos[0] === void 0 ? {} : { id: pos[0] }
+			}
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "cancel": return pos.length <= 1 ? {
+			ok: true,
+			command: {
+				verb: "cancel",
+				...pos[0] === void 0 ? {} : { id: pos[0] }
+			}
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "runs": return pos.length === 0 ? {
+			ok: true,
+			command: { verb: "runs" }
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "doctor": return pos.length === 0 ? {
+			ok: true,
+			command: { verb: "doctor" }
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "pending": return pos.length === 0 ? {
+			ok: true,
+			command: { verb: "pending" }
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "approve": return pos.length === 1 ? {
+			ok: true,
+			command: {
+				verb: "approve",
+				id: pos[0]
+			}
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "reject": return pos.length === 1 ? {
+			ok: true,
+			command: {
+				verb: "reject",
+				id: pos[0]
+			}
+		} : {
+			ok: false,
+			code: "usage",
+			message: USAGE
+		};
+		case "resume": {
+			const parsed = flags(rest, ["clear"]);
+			if (parsed.error !== void 0) return {
+				ok: false,
+				code: "usage",
+				message: parsed.error
+			};
+			const clear = parsed.values.get("clear");
+			if (pos.length > 1) return {
+				ok: false,
+				code: "usage",
+				message: USAGE
+			};
+			return {
+				ok: true,
+				command: {
+					verb: "resume",
+					...pos[0] === void 0 ? {} : { id: pos[0] },
+					...clear === void 0 ? {} : { clear }
+				}
+			};
+		}
+		case "skipped": {
+			const parsed = flags(rest, ["restore"]);
+			if (parsed.error !== void 0) return {
+				ok: false,
+				code: "usage",
+				message: parsed.error
+			};
+			if (pos.length > 0) return {
+				ok: false,
+				code: "usage",
+				message: USAGE
+			};
+			const restore = parsed.values.get("restore");
+			return {
+				ok: true,
+				command: {
+					verb: "skipped",
+					...restore === void 0 ? {} : { restore }
+				}
+			};
+		}
+		case "undo": {
+			const parsed = flags(rest, ["run"]);
+			if (parsed.error !== void 0) return {
+				ok: false,
+				code: "usage",
+				message: parsed.error
+			};
+			const target = pos[0];
+			const run = parsed.values.get("run");
+			if (target === void 0 || run === void 0 || pos.length !== 1) return {
+				ok: false,
+				code: "usage",
+				message: USAGE
+			};
+			return {
+				ok: true,
+				command: {
+					verb: "undo",
+					target,
+					run
+				}
+			};
+		}
+		default: return {
+			ok: false,
+			code: "usage",
+			message: "unknown merge command: " + verb + "\nusage: merge scan | pair <a> <b> | status [id] | report [id] | cancel [id] | runs | doctor | pending | approve <id> | reject <id> | resume [id] [--clear <id>] | skipped [--restore <id>] | undo <target> --run <id>"
+		};
+	}
+}
+function mergeUsage() {
+	return USAGE;
+}
+//#endregion
+//#region lib/types/read-commands.js
+async function handleReadOnlyMergeCommand(command, io, home) {
+	if (command.verb === "status") {
+		const loaded = await loadMergeState(io, home);
+		if (command.id !== void 0) {
+			const row = loaded.state.rows.find((item) => item.id === command.id);
+			return row === void 0 ? "merge row not found: " + command.id : formatStatus([row]);
+		}
+		return formatStatus(loaded.state.rows);
+	}
+	if (command.verb === "pending") return formatQueue((await loadMergeState(io, home)).state.rows, "pending");
+	if (command.verb === "skipped") return formatQueue((await loadMergeState(io, home)).state.rows, "skipped");
+	return null;
+}
+function mergeCommandHelp() {
+	return mergeUsage();
+}
+//#endregion
+//#region lib/types/merge-command.js
+function createReadOnlyMergeService(io, home) {
+	return { async execute(command) {
+		const text = await handleReadOnlyMergeCommand(command, io, home);
+		return text === null ? {
+			ok: false,
+			text: "merge " + command.verb + " 需要运行引擎（当前只挂载了只读命令）"
+		} : {
+			ok: true,
+			text
+		};
+	} };
+}
+function createMergeCommand(service) {
+	return {
+		name: "merge",
+		description: "技能自动合并：扫描、待批准、重跑、报告与 undo",
+		input: { hint: mergeUsage() },
+		async handler(invocation) {
+			const tokens = invocation.rawInput.trim().split(/\s+/).filter(Boolean);
+			if (tokens[0] === "merge" || tokens[0] === "/merge") tokens.shift();
+			const parsed = parseMergeCommand(tokens);
+			if (!parsed.ok) return {
+				kind: "error",
+				text: parsed.message
+			};
+			if (parsed.help === true) return {
+				kind: "success",
+				text: mergeUsage()
+			};
+			try {
+				const result = await service.execute(parsed.command, { ...invocation.agent === void 0 ? {} : { parent: invocation.agent } });
+				return {
+					kind: result.ok ? "success" : "error",
+					text: result.text
+				};
+			} catch (error) {
+				return {
+					kind: "error",
+					text: "merge 命令失败：" + (error instanceof Error ? error.message : String(error)) + "\n运行 /merge status 查看状态。"
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region lib/types/skipped.js
+/**
+* Skipped filtering: a pair the operator marked as not-worth-merging stays out of automatic
+* screening until mergeSkippedTtlDays expires. Explicit /merge pair ignores this set.
+*/
+function skippedPairKeys(rows, ttlDays, now) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		if (row.state !== "skipped") continue;
+		if (ttlDays <= 0) {
+			keys.add(row.pairKey);
+			continue;
+		}
+		const createdAt = Date.parse(row.createdAt);
+		if (!Number.isFinite(createdAt) || now - createdAt < ttlDays * 864e5) keys.add(row.pairKey);
+	}
+	return keys;
+}
+function isSkippedPair(keys, a, b) {
+	return keys.has(pairKey(a, b));
+}
+//#endregion
+//#region lib/types/coordinator.js
+/**
+* Pure merge transition table. No io, no run shell, no subagents.
+*
+* Every transition returns the whole next row (or a drop), so the caller can persist it
+* through mutateMergeState in one transaction. Invalid transitions are refused by name;
+* a caller never "repairs" a row by guessing which state the operator meant.
+*/
+function invalid(event, state) {
+	return {
+		ok: false,
+		code: "invalid-transition",
+		message: "cannot apply " + event.type + " to " + (state ?? "no row")
+	};
+}
+/** Drop fields that must not survive a transition; optional fields stay absent. */
+function base(row, at) {
+	return {
+		id: row.id,
+		pairKey: row.pairKey,
+		a: row.a,
+		b: row.b,
+		state: row.state,
+		queue: row.queue,
+		createdAt: row.createdAt,
+		updatedAt: at,
+		...row.runId === void 0 ? {} : { runId: row.runId },
+		...row.unitId === void 0 ? {} : { unitId: row.unitId },
+		...row.origin === void 0 ? {} : { origin: row.origin },
+		...row.decision === void 0 ? {} : { decision: row.decision },
+		...row.attempts === void 0 ? {} : { attempts: row.attempts }
+	};
+}
+function next(row, at, state, patch = {}) {
+	return {
+		ok: true,
+		row: {
+			...base(row, at),
+			state,
+			queue: queueOf(state),
+			...patch
+		}
+	};
+}
+function transition(current, event) {
+	if (event.type === "candidate") {
+		if (current !== void 0) return {
+			ok: true,
+			row: current
+		};
+		const key = pairKey(event.a, event.b);
+		return {
+			ok: true,
+			row: {
+				id: rowIdOf(key),
+				pairKey: key,
+				a: event.a,
+				b: event.b,
+				state: "verify",
+				queue: "retry",
+				createdAt: event.at,
+				updatedAt: event.at
+			}
+		};
+	}
+	if (event.type === "source-gone") return {
+		ok: true,
+		row: null
+	};
+	if (current === void 0) return invalid(event, void 0);
+	switch (event.type) {
+		case "round1-keep": return current.state === "verify" ? next(current, event.at, "skipped", { origin: "agent" }) : invalid(event, current.state);
+		case "round1-merge":
+			if (current.state !== "verify") return invalid(event, current.state);
+			return event.approval === "on" ? next(current, event.at, "pending", event.decision === void 0 ? {} : { decision: event.decision }) : next(current, event.at, "fuse", event.decision === void 0 ? {} : { decision: event.decision });
+		case "round1-fail": return current.state === "verify" ? next(current, event.at, "verify", {
+			failure: event.failure,
+			attempts: (current.attempts ?? 0) + 1
+		}) : invalid(event, current.state);
+		case "approve": return current.state === "pending" ? next(current, event.at, "fuse", { ...event.runId === void 0 ? {} : { runId: event.runId } }) : invalid(event, current.state);
+		case "reject": return current.state === "pending" ? next(current, event.at, "skipped", { origin: "human" }) : invalid(event, current.state);
+		case "round2-fail": return current.state === "fuse" ? next(current, event.at, "fuse", {
+			failure: event.failure,
+			attempts: (current.attempts ?? 0) + 1
+		}) : invalid(event, current.state);
+		case "round2-success": return current.state === "fuse" ? {
+			ok: true,
+			row: null
+		} : invalid(event, current.state);
+		case "restore": return current.state === "skipped" ? next(current, event.at, "verify") : invalid(event, current.state);
+	}
+}
+//#endregion
+//#region lib/types/scan-run.js
+/**
+* The scan pair loop. Registry/report lifecycle stays in withMergeRun; this module owns
+* candidate → round1 → pending/fuse → commit transitions and returns the report draft.
+*/
+function at(now) {
+	return new Date(now()).toISOString();
+}
+function failureOf(stage, error) {
+	return {
+		stage,
+		code: "merge-failed",
+		message: error instanceof Error ? error.message : String(error),
+		retryable: true,
+		retryFrom: stage === "decide" ? "agent1" : "agent2"
+	};
+}
+function pairOf(row, candidate, outcome, extra = {}) {
+	return {
+		id: row.id,
+		pairKey: row.pairKey,
+		a: row.a,
+		b: row.b,
+		queue: row.queue,
+		candidate,
+		...candidate.gate === void 0 ? {} : { gate: candidate.gate },
+		outcome,
+		archived: [],
+		...extra
+	};
+}
+async function runScan(options) {
+	const stage = options.stage ?? (async () => {});
+	const before = await loadMergeState(options.io, options.home);
+	const queueBefore = {
+		pending: 0,
+		retry: 0,
+		skipped: 0
+	};
+	for (const row of before.state.rows) queueBefore[row.queue] += 1;
+	const candidates = await options.ports.screening(options.signal);
+	const startedAt = options.startedAt ?? options.now();
+	const timeoutMs = (options.timeoutMinutes ?? 0) > 0 ? options.timeoutMinutes * 6e4 : 0;
+	const pairs = [];
+	const totals = {
+		merged: 0,
+		kept: 0,
+		pending: 0,
+		failed: 0
+	};
+	const remaining = [];
+	let stopReason = "completed";
+	for (let index = 0; index < candidates.length; index += 1) {
+		if (options.signal.aborted) {
+			stopReason = "cancelled";
+			remaining.push(...candidates.slice(index).map((candidate) => ({
+				pairKey: pairKey(candidate.a, candidate.b),
+				queue: "retry"
+			})));
+			break;
+		}
+		if (timeoutMs > 0 && options.now() - startedAt >= timeoutMs) {
+			stopReason = "timeout";
+			remaining.push(...candidates.slice(index).map((candidate) => ({
+				pairKey: pairKey(candidate.a, candidate.b),
+				queue: "retry"
+			})));
+			break;
+		}
+		const candidate = candidates[index];
+		await stage("decide", {
+			done: index,
+			total: candidates.length
+		});
+		let row;
+		try {
+			const created = transition(void 0, {
+				type: "candidate",
+				a: candidate.a,
+				b: candidate.b,
+				at: at(options.now)
+			});
+			if (!created.ok || created.row === null) throw new Error(created.ok ? "candidate row missing" : created.message);
+			row = created.row;
+			await upsertRow(options.io, options.home, options.now, row);
+		} catch (error) {
+			totals.failed += 1;
+			pairs.push({
+				id: "",
+				pairKey: pairKey(candidate.a, candidate.b),
+				a: candidate.a,
+				b: candidate.b,
+				queue: "retry",
+				candidate,
+				outcome: "failed",
+				archived: [],
+				failure: failureOf("screening", error)
+			});
+			continue;
+		}
+		let round1;
+		try {
+			round1 = await options.ports.round1(candidate, options.signal);
+		} catch (error) {
+			round1 = {
+				kind: "failed",
+				failure: failureOf("decide", error)
+			};
+		}
+		if (round1.kind === "failed") {
+			const next = transition(row, {
+				type: "round1-fail",
+				failure: round1.failure ?? failureOf("decide", "round1 failed"),
+				at: at(options.now)
+			});
+			if (next.ok && next.row !== null) {
+				row = next.row;
+				await upsertRow(options.io, options.home, options.now, row);
+			}
+			pairs.push(pairOf(row, candidate, "failed", { failure: round1.failure ?? failureOf("decide", "round1 failed") }));
+			totals.failed += 1;
+			continue;
+		}
+		if (round1.kind === "keep") {
+			const next = transition(row, {
+				type: "round1-keep",
+				at: at(options.now)
+			});
+			if (next.ok && next.row !== null) {
+				row = next.row;
+				await upsertRow(options.io, options.home, options.now, row);
+			}
+			pairs.push(pairOf(row, candidate, "kept", round1.decision === void 0 ? {} : { decision: round1.decision }));
+			totals.kept += 1;
+			continue;
+		}
+		if (round1.decision === void 0) {
+			pairs.push(pairOf(row, candidate, "failed", { failure: failureOf("decide", "merge decision missing") }));
+			totals.failed += 1;
+			continue;
+		}
+		if (options.approval) {
+			const next = transition(row, {
+				type: "round1-merge",
+				approval: "on",
+				decision: round1.decision,
+				at: at(options.now)
+			});
+			if (next.ok && next.row !== null) {
+				row = next.row;
+				await upsertRow(options.io, options.home, options.now, row);
+			}
+			pairs.push(pairOf(row, candidate, "pending", { decision: round1.decision }));
+			totals.pending += 1;
+			continue;
+		}
+		const fuse = transition(row, {
+			type: "round1-merge",
+			approval: "off",
+			decision: round1.decision,
+			at: at(options.now)
+		});
+		if (!fuse.ok || fuse.row === null) {
+			pairs.push(pairOf(row, candidate, "failed", {
+				decision: round1.decision,
+				failure: failureOf("decide", "cannot enter fuse")
+			}));
+			totals.failed += 1;
+			continue;
+		}
+		row = fuse.row;
+		await upsertRow(options.io, options.home, options.now, row);
+		await stage("author", {
+			done: index,
+			total: candidates.length
+		});
+		let round2;
+		try {
+			round2 = await options.ports.round2(row, round1.decision, options.signal);
+		} catch (error) {
+			round2 = {
+				kind: "failed",
+				failure: failureOf("author", error)
+			};
+		}
+		if (round2.kind === "merged") {
+			if (transition(row, {
+				type: "round2-success",
+				at: at(options.now)
+			}).ok) await dropRow(options.io, options.home, options.now, row.id);
+			pairs.push(pairOf(row, candidate, "merged", {
+				decision: round1.decision,
+				...round2.unitId === void 0 ? {} : { unitId: round2.unitId },
+				...round2.target === void 0 ? {} : { target: round2.target },
+				archived: round2.archived ?? []
+			}));
+			totals.merged += 1;
+			continue;
+		}
+		const failed = round2.failure ?? failureOf("author", "round2 failed");
+		const next = transition(row, {
+			type: "round2-fail",
+			failure: failed,
+			at: at(options.now)
+		});
+		if (next.ok && next.row !== null) {
+			row = next.row;
+			await upsertRow(options.io, options.home, options.now, row);
+		}
+		pairs.push(pairOf(row, candidate, "failed", {
+			decision: round1.decision,
+			failure: failed
+		}));
+		totals.failed += 1;
+	}
+	return {
+		stopReason,
+		scope: {
+			candidatePairs: candidates.length,
+			queueBefore
+		},
+		pairs,
+		totals,
+		notes: [],
+		...remaining.length === 0 ? {} : { remaining }
+	};
+}
+//#endregion
+//#region lib/types/report.js
+/**
+* Merge run report: JSON is the machine source, Markdown is the human digest.
+*
+* Reports are written before registry.settle, so a settled run's resultRef is readable.
+* readMergeReport uses the three-state probe: absent is not "no pairs", unknown is not empty.
+*/
+function mergeReportPath(home, runId) {
+	return join(home, "reports", "merge-" + runId + ".json");
+}
+function mergeReportDigestPath(home, runId) {
+	return join(home, "reports", "merge-" + runId + ".md");
+}
+function isReport(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const report = value;
+	return report.schemaVersion === 1 && report.kind === "merge" && typeof report.runId === "string" && typeof report.command === "string" && typeof report.startedAt === "number" && typeof report.endedAt === "number" && Array.isArray(report.pairs) && typeof report.totals === "object" && Array.isArray(report.notes);
+}
+function digest(report) {
+	const lines = [];
+	lines.push("# merge " + report.runId);
+	lines.push("");
+	lines.push("- command: " + report.command);
+	lines.push("- stop: " + report.stopReason);
+	lines.push("- pairs: " + String(report.pairs.length));
+	lines.push("- totals: merged " + String(report.totals.merged) + ", kept " + String(report.totals.kept) + ", pending " + String(report.totals.pending) + ", failed " + String(report.totals.failed));
+	for (const pair of report.pairs) lines.push("- " + pair.a + " + " + pair.b + " -> " + pair.outcome + (pair.target === void 0 ? "" : " (" + pair.target.actual + ")"));
+	if (report.remaining !== void 0 && report.remaining.length > 0) {
+		lines.push("");
+		lines.push("- remaining: " + report.remaining.map((item) => item.pairKey).join(", "));
+	}
+	return lines.join("\n") + "\n";
+}
+/** Write JSON first, then the digest; returns the JSON path (the registry resultRef). */
+async function writeMergeReport(io, home, report) {
+	const path = mergeReportPath(home, report.runId);
+	await io.writeText(path, JSON.stringify(report, null, 2) + "\n");
+	await io.writeText(mergeReportDigestPath(home, report.runId), digest(report));
+	return path;
+}
+async function readMergeReport(io, home, runId) {
+	const probe = await probeText(io, mergeReportPath(home, runId));
+	if (!isPresent(probe)) return probe;
+	try {
+		const parsed = JSON.parse(probe.value);
+		return isReport(parsed) ? probePresent(parsed) : probeUnknown("merge report has an unexpected shape");
+	} catch (error) {
+		return probeUnknown("merge report is not JSON: " + (error instanceof Error ? error.message : String(error)));
+	}
+}
+/** Pairs this run actually merged (for merge undo / reports). */
+async function committedPairs(io, home, runId) {
+	const probe = await readMergeReport(io, home, runId);
+	return isPresent(probe) ? probe.value.pairs.filter((pair) => pair.outcome === "merged") : [];
+}
+//#endregion
+//#region lib/types/run-shell.js
+function emptyDraft(reason) {
+	return {
+		stopReason: "failed",
+		scope: {
+			candidatePairs: 0,
+			queueBefore: {
+				pending: 0,
+				retry: 0,
+				skipped: 0
+			}
+		},
+		pairs: [],
+		totals: {
+			merged: 0,
+			kept: 0,
+			pending: 0,
+			failed: 0
+		},
+		notes: [reason]
+	};
+}
+async function withMergeRun(options) {
+	const handle = await options.registry.begin("merge", {
+		command: options.command,
+		...options.total === void 0 ? {} : { total: options.total }
+	});
+	const startedAt = handle.startedAt;
+	const stage = (name, progress) => options.registry.stage(handle.id, name, progress);
+	await stage("screening", options.total === void 0 ? void 0 : {
+		done: 0,
+		total: options.total
+	});
+	let draft;
+	try {
+		draft = await options.body({
+			runId: handle.id,
+			startedAt,
+			signal: handle.signal,
+			stage
+		});
+	} catch (error) {
+		draft = emptyDraft("run body failed: " + (error instanceof Error ? error.message : String(error)));
+	}
+	const report = {
+		schemaVersion: 1,
+		runId: handle.id,
+		kind: "merge",
+		command: options.command,
+		startedAt,
+		endedAt: options.now(),
+		stopReason: draft.stopReason,
+		approval: options.approval,
+		scope: draft.scope,
+		pairs: draft.pairs,
+		totals: draft.totals,
+		notes: draft.notes,
+		...draft.remaining === void 0 ? {} : { remaining: draft.remaining }
+	};
+	let reportPath;
+	try {
+		reportPath = await writeMergeReport(options.io, options.home, report);
+	} catch (error) {
+		await options.registry.settle(handle.id, {
+			state: "failed",
+			failure: "report write failed: " + (error instanceof Error ? error.message : String(error))
+		});
+		return {
+			ok: false,
+			runId: handle.id,
+			message: "report write failed"
+		};
+	}
+	const runState = report.stopReason === "completed" ? "succeeded" : report.stopReason === "cancelled" ? "cancelled" : "failed";
+	await options.registry.settle(handle.id, {
+		state: runState,
+		resultRef: reportPath,
+		...runState === "failed" ? { failure: "merge " + report.stopReason } : {}
+	});
+	if (report.stopReason === "completed") return {
+		ok: true,
+		runId: handle.id,
+		reportPath,
+		report
+	};
+	return {
+		ok: false,
+		runId: handle.id,
+		message: "merge " + report.stopReason,
+		reportPath
+	};
+}
+//#endregion
+//#region lib/types/scan-command.js
+async function runScanCommand(options) {
+	return await withMergeRun({
+		io: options.io,
+		home: options.home,
+		registry: options.registry,
+		command: "scan",
+		approval: {
+			platformWrite: options.platformWrite,
+			mergeApproval: options.approval
+		},
+		now: options.now,
+		async body(ctx) {
+			const ports = options.makePorts === void 0 ? options.ports : options.makePorts(ctx.runId);
+			if (ports === void 0) throw new Error("scan requires ports or makePorts");
+			return await runScan({
+				io: options.io,
+				home: options.home,
+				now: options.now,
+				signal: ctx.signal,
+				approval: options.approval,
+				ports,
+				stage: ctx.stage,
+				startedAt: ctx.startedAt,
+				...options.timeoutMinutes === void 0 ? {} : { timeoutMinutes: options.timeoutMinutes }
+			});
+		}
+	});
+}
+//#endregion
+//#region lib/types/pending-actions.js
+async function act(io, home, now, id, type) {
+	return await mutateMergeState(io, home, now, (rows) => {
+		const index = rows.findIndex((row) => row.id === id);
+		if (index < 0) return {
+			rows,
+			result: {
+				ok: false,
+				reason: "not-found",
+				message: "pending row not found: " + id
+			}
+		};
+		const current = rows[index];
+		if (current.state !== "pending") return {
+			rows,
+			result: {
+				ok: false,
+				reason: "not-pending",
+				message: "row is not pending: " + current.state
+			}
+		};
+		const next = transition(current, type === "approve" ? {
+			type: "approve",
+			at: new Date(now()).toISOString()
+		} : {
+			type: "reject",
+			at: new Date(now()).toISOString()
+		});
+		if (!next.ok || next.row === null) return {
+			rows,
+			result: {
+				ok: false,
+				reason: "invalid",
+				message: next.ok ? "transition produced no row" : next.message
+			}
+		};
+		const copy = [...rows];
+		copy[index] = next.row;
+		return {
+			rows: copy,
+			result: {
+				ok: true,
+				row: next.row
+			}
+		};
+	});
+}
+async function approvePending(io, home, now, id) {
+	return await act(io, home, now, id, "approve");
+}
+async function rejectPending(io, home, now, id) {
+	return await act(io, home, now, id, "reject");
+}
+//#endregion
+//#region lib/types/round2-outcome.js
+async function recordRound2Outcome(io, home, now, row, outcome) {
+	const at = new Date(now()).toISOString();
+	if (outcome.kind === "merged") {
+		if (transition(row, {
+			type: "round2-success",
+			at
+		}).ok) await dropRow(io, home, now, row.id);
+		return {
+			merged: true,
+			pair: {
+				id: row.id,
+				pairKey: row.pairKey,
+				a: row.a,
+				b: row.b,
+				queue: row.queue,
+				...row.decision === void 0 ? {} : { decision: row.decision },
+				outcome: "merged",
+				archived: outcome.archived ?? [],
+				...outcome.unitId === void 0 ? {} : { unitId: outcome.unitId },
+				...outcome.target === void 0 ? {} : { target: outcome.target }
+			}
+		};
+	}
+	const failure = outcome.failure ?? {
+		stage: "author",
+		code: "merge-failed",
+		message: "round2 failed",
+		retryable: true,
+		retryFrom: "agent2"
+	};
+	const next = transition(row, {
+		type: "round2-fail",
+		failure,
+		at
+	});
+	if (next.ok && next.row !== null) await upsertRow(io, home, now, next.row);
+	return {
+		merged: false,
+		pair: {
+			id: row.id,
+			pairKey: row.pairKey,
+			a: row.a,
+			b: row.b,
+			queue: row.queue,
+			...row.decision === void 0 ? {} : { decision: row.decision },
+			outcome: "failed",
+			archived: [],
+			failure
+		}
+	};
+}
+//#endregion
+//#region lib/types/approve-command.js
+async function runApproveCommand(options) {
+	const taken = await approvePending(options.io, options.home, options.now, options.rowId);
+	if (!taken.ok) return {
+		ok: false,
+		message: taken.message
+	};
+	const row = taken.row;
+	const decision = row.decision;
+	if (decision === void 0) return {
+		ok: false,
+		message: "pending row has no decision"
+	};
+	return await withMergeRun({
+		io: options.io,
+		home: options.home,
+		registry: options.registry,
+		command: "approve",
+		approval: {
+			platformWrite: options.platformWrite,
+			mergeApproval: true
+		},
+		now: options.now,
+		async body(ctx) {
+			const stage = (name) => ctx.stage(name, {
+				done: 0,
+				total: 1
+			});
+			await stage("author");
+			let outcome;
+			try {
+				outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
+			} catch (error) {
+				outcome = {
+					kind: "failed",
+					failure: {
+						stage: "author",
+						code: "merge-failed",
+						message: error instanceof Error ? error.message : String(error),
+						retryable: true,
+						retryFrom: "agent2"
+					}
+				};
+			}
+			const base = {
+				scope: {
+					candidatePairs: 1,
+					queueBefore: {
+						pending: 0,
+						retry: 1,
+						skipped: 0
+					}
+				},
+				notes: []
+			};
+			const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
+			return {
+				...base,
+				stopReason: record.merged ? "completed" : "failed",
+				pairs: [record.pair],
+				totals: record.merged ? {
+					merged: 1,
+					kept: 0,
+					pending: 0,
+					failed: 0
+				} : {
+					merged: 0,
+					kept: 0,
+					pending: 0,
+					failed: 1
+				}
+			};
+		}
+	});
+}
+//#endregion
+//#region lib/types/resume-command.js
+async function runResumeCommand(options) {
+	const row = (await loadMergeState(options.io, options.home)).state.rows.find((item) => item.id === options.rowId);
+	if (row === void 0) return {
+		ok: false,
+		message: "merge row not found: " + options.rowId
+	};
+	if (row.state === "verify") return await runScanCommand({
+		io: options.io,
+		home: options.home,
+		registry: options.registry,
+		approval: true,
+		platformWrite: options.platformWrite,
+		now: options.now,
+		...options.makePorts === void 0 ? { ports: {
+			...options.ports,
+			screening: () => Promise.resolve([{
+				a: row.a,
+				b: row.b
+			}])
+		} } : { makePorts: (runId) => {
+			const makePorts = options.makePorts;
+			if (makePorts === void 0) throw new Error("resume makePorts disappeared");
+			return {
+				...makePorts(runId),
+				screening: () => Promise.resolve([{
+					a: row.a,
+					b: row.b
+				}])
+			};
+		} },
+		...options.timeoutMinutes === void 0 ? {} : { timeoutMinutes: options.timeoutMinutes }
+	});
+	if (row.state !== "fuse") return {
+		ok: false,
+		message: "row is not resumable from state " + row.state
+	};
+	const decision = row.decision;
+	if (decision === void 0) return {
+		ok: false,
+		message: "fuse row has no decision"
+	};
+	return await withMergeRun({
+		io: options.io,
+		home: options.home,
+		registry: options.registry,
+		command: "resume",
+		approval: {
+			platformWrite: options.platformWrite,
+			mergeApproval: true
+		},
+		now: options.now,
+		async body(ctx) {
+			await ctx.stage("author", {
+				done: 0,
+				total: 1
+			});
+			let outcome;
+			try {
+				outcome = options.round2WithRun === void 0 ? await options.ports.round2(row, decision, ctx.signal) : await options.round2WithRun(row, decision, ctx.signal, ctx.runId);
+			} catch (error) {
+				outcome = {
+					kind: "failed",
+					failure: {
+						stage: "author",
+						code: "merge-failed",
+						message: error instanceof Error ? error.message : String(error),
+						retryable: true,
+						retryFrom: "agent2"
+					}
+				};
+			}
+			const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
+			return {
+				stopReason: record.merged ? "completed" : "failed",
+				scope: {
+					candidatePairs: 1,
+					queueBefore: {
+						pending: 0,
+						retry: 1,
+						skipped: 0
+					}
+				},
+				pairs: [record.pair],
+				totals: record.merged ? {
+					merged: 1,
+					kept: 0,
+					pending: 0,
+					failed: 0
+				} : {
+					merged: 0,
+					kept: 0,
+					pending: 0,
+					failed: 1
+				},
+				notes: []
+			};
+		}
+	});
+}
+//#endregion
+//#region lib/types/staging.js
+/**
+* Staging is a run ARTIFACT, not a queue: <home>/merge/runs/<runId>/.
+*
+* createStaging writes a sibling .partial tree first and renames it into place; the .stage
+* marker is the last write inside the partial. A directory without that marker is a
+* half-created artifact and reads as unknown, never as "empty".
+*/
+const STAGING_SCHEMA_VERSION = 1;
+function stagingRoot(home, runId) {
+	return join(home, "merge", "runs", runId);
+}
+/** Relative support paths only; the staging tree must never escape its run directory. */
+function safeRelative$2(path) {
+	if (path === "" || path.startsWith("/") || path.startsWith("\\") || path.includes("\0")) return false;
+	return path.replace(/\\/g, "/").split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function manifestText(manifest) {
+	return JSON.stringify(manifest, null, 2) + "\n";
+}
+async function createStaging(io, home, input) {
+	const final = stagingRoot(home, input.runId);
+	if (await io.exists(final)) return {
+		ok: false,
+		message: "staging already exists for run " + input.runId
+	};
+	const names = /* @__PURE__ */ new Set();
+	for (const source of input.sources) {
+		if (names.has(source.name)) return {
+			ok: false,
+			message: "duplicate source " + source.name
+		};
+		names.add(source.name);
+		for (const file of source.files) if (!safeRelative$2(file.path)) return {
+			ok: false,
+			message: "unsafe support path: " + file.path
+		};
+	}
+	const partial = final + ".partial";
+	try {
+		await io.remove(partial);
+		for (const source of input.sources) {
+			const dir = join(partial, "sources", source.name);
+			await io.writeText(join(dir, "SKILL.md"), source.body);
+			for (const file of source.files) await io.writeText(join(dir, ...file.path.split("/")), file.content);
+		}
+		const at = input.now();
+		const manifest = {
+			schemaVersion: 1,
+			runId: input.runId,
+			target: input.target,
+			sources: input.sources.map((source) => source.name),
+			promptVersion: input.promptVersion,
+			createdAt: at,
+			expiresAt: at + Math.max(0, input.ttlDays) * 864e5
+		};
+		await io.writeText(join(partial, "manifest.json"), manifestText(manifest));
+		await io.writeText(join(partial, ".stage"), "");
+		await io.rename(partial, final);
+		return {
+			ok: true,
+			path: final,
+			manifest
+		};
+	} catch (error) {
+		try {
+			await io.remove(partial);
+		} catch {}
+		return {
+			ok: false,
+			message: "staging create failed: " + (error instanceof Error ? error.message : String(error))
+		};
+	}
+}
+async function readStaging(io, home, runId) {
+	const path = stagingRoot(home, runId);
+	if (!await io.exists(path)) return probeAbsent();
+	if (!await io.exists(join(path, ".stage"))) return probeUnknown("staging " + runId + " has no .stage marker (half-created)");
+	const probe = await probeText(io, join(path, "manifest.json"));
+	if (!isPresent(probe)) return probe;
+	try {
+		const parsed = JSON.parse(probe.value);
+		if (parsed.schemaVersion !== 1 || parsed.runId !== runId || typeof parsed.target !== "string" || !Array.isArray(parsed.sources)) return probeUnknown("staging manifest has an unexpected shape");
+		return probePresent({
+			path,
+			manifest: parsed
+		});
+	} catch (error) {
+		return probeUnknown("staging manifest is not JSON: " + (error instanceof Error ? error.message : String(error)));
+	}
+}
+//#endregion
+//#region lib/types/commit-receipt.js
+/**
+* Commit receipt: <run>/commit.json, written immediately after a successful commit.
+* It is the idempotency/recovery marker — merge resume and run start read it before
+* replaying a commit. Receipt write failure must not turn a landed commit into a failure;
+* the caller reports the warning instead.
+*/
+function commitReceiptPath(home, runId) {
+	return join(stagingRoot(home, runId), "commit.json");
+}
+async function writeCommitReceipt(io, home, receipt) {
+	const path = commitReceiptPath(home, receipt.runId);
+	await io.writeText(path, JSON.stringify(receipt, null, 2) + "\n");
+	return path;
+}
+async function readCommitReceipt(io, home, runId) {
+	const raw = await io.readText(commitReceiptPath(home, runId));
+	if (raw === null) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.runId !== "string" || typeof parsed.unitId !== "string" || typeof parsed.target !== "string" || typeof parsed.create !== "boolean" || !Array.isArray(parsed.sources) || !Array.isArray(parsed.archived) || typeof parsed.at !== "number") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region lib/types/undo-merge.js
+async function undoMergeReceipt(receipt, port) {
+	const targetVersions = (await port.listVersions(receipt.target)).filter((entry) => entry.unitId === receipt.unitId);
+	if (targetVersions.length === 0) return {
+		ok: false,
+		message: "unit " + receipt.unitId + " is not in the target history; refusing to guess",
+		reverted: []
+	};
+	const members = [{
+		skill: receipt.target,
+		entries: targetVersions,
+		status: "live",
+		...receipt.create ? { createdInUnit: true } : {}
+	}];
+	for (const source of receipt.sources) {
+		const live = await port.readSkill(source);
+		members.push({
+			skill: source,
+			entries: (await port.listVersions(source)).filter((entry) => entry.unitId === receipt.unitId),
+			status: live === null ? "archived" : "live",
+			...live === null ? { archivedPath: "archive" } : {}
+		});
+	}
+	const plan = planUnitUndoAcross(members);
+	if (plan.refusals.length > 0) return {
+		ok: false,
+		message: "merge undo preflight refused: " + plan.refusals.join("; "),
+		reverted: []
+	};
+	return await executeUnitUndo(plan, port);
+}
+//#endregion
+//#region lib/types/adapters/undo.js
+/**
+* SkillLibrary-backed undo sink. Blobs are content-addressed but the library exposes them by
+* version, so the first readBlob call indexes all version bodies once; an undo is rare enough
+* that this is preferable to adding a second hash index.
+*/
+function skillLibraryUndoPort(skills) {
+	let blobs;
+	const readBlob = async (hash) => {
+		if (blobs === void 0) {
+			blobs = /* @__PURE__ */ new Map();
+			for (const summary of await skills.list()) for (const version of await skills.listVersions(summary.name)) {
+				const body = await skills.readVersion(summary.name, version.v);
+				if (body !== null) blobs.set(contentHash(body), body);
+			}
+		}
+		return blobs.get(hash) ?? null;
+	};
+	return {
+		readSkill: (name) => skills.read(name),
+		readSupport: (name, path) => skills.readSupportFile(name, path),
+		readBlob,
+		async hasArchived(name) {
+			return await skills.read(name) === null;
+		},
+		restoreFromArchive: (name) => skills.restoreFromArchive(name),
+		archive: (name, reason) => skills.archive(name, { reason }),
+		updateSkill: (name, body, anchor) => skills.update(name, body, void 0, anchor),
+		writeSupportFile: (name, path, content, anchor) => skills.writeSupportFile(name, path, content, void 0, anchor),
+		removeSupportFile: (name, path, anchor) => skills.removeSupportFile(name, path, void 0, anchor),
+		listVersions: (name) => skills.listVersions(name)
+	};
+}
+//#endregion
+//#region lib/types/ladder.js
+/**
+* L0–L2 candidate gate. This is a CANDIDATE classifier, not a content quality judge.
+* Routing follows the frozen table: L0 -1 stops; L0 1/0 → L1; L1 -1 stops; L1 0/1 → L2;
+* L2 1 → agent1; L2 0 → agent1 (undecided); L2 -1 → skipped.
+*/
+var GateCache = class GateCache {
+	entries = /* @__PURE__ */ new Map();
+	get(key) {
+		return this.entries.get(key);
+	}
+	put(key, value) {
+		this.entries.set(key, value);
+	}
+	get size() {
+		return this.entries.size;
+	}
+	toObject() {
+		return Object.fromEntries(this.entries);
+	}
+	static fromObject(value) {
+		const cache = new GateCache();
+		if (typeof value !== "object" || value === null) return cache;
+		for (const [key, entry] of Object.entries(value)) {
+			if (typeof entry !== "object" || entry === null) continue;
+			const verdict = entry;
+			if (verdict.verdict === 1 || verdict.verdict === 0 || verdict.verdict === -1) cache.put(key, {
+				level: verdict.level === "L0" || verdict.level === "L1" || verdict.level === "L2" ? verdict.level : "L2",
+				verdict: verdict.verdict,
+				reason: typeof verdict.reason === "string" ? verdict.reason : "",
+				evidence: Array.isArray(verdict.evidence) ? verdict.evidence : [],
+				cached: true
+			});
+		}
+		return cache;
+	}
+};
+function gateCacheKey(level, payload, model) {
+	return createHash("sha256").update(JSON.stringify({
+		level,
+		payload,
+		model
+	})).digest("hex");
+}
+function payloadFor(level, candidate, facts) {
+	const a = facts.get(candidate.a);
+	const b = facts.get(candidate.b);
+	if (a === void 0 || b === void 0) throw new Error("candidate names are not in the fact set");
+	const base = {
+		level,
+		skill_a: {
+			name: a.name,
+			description: a.description
+		},
+		skill_b: {
+			name: b.name,
+			description: b.description
+		},
+		scores: { jaccard_summary: candidate.score ?? null },
+		schema: {
+			verdict: "1 | 0 | -1",
+			reason: "<=80 chars"
+		}
+	};
+	if (level === "L0") return JSON.stringify(base);
+	const withHead = {
+		...base,
+		skill_a: {
+			...base.skill_a,
+			head: a.body.slice(0, 2400)
+		},
+		skill_b: {
+			...base.skill_b,
+			head: b.body.slice(0, 2400)
+		}
+	};
+	if (level === "L1") return JSON.stringify(withHead);
+	return JSON.stringify({
+		...withHead,
+		skill_a: {
+			...withHead.skill_a,
+			body_excerpt: a.body.slice(0, 4e3)
+		},
+		skill_b: {
+			...withHead.skill_b,
+			body_excerpt: b.body.slice(0, 4e3)
+		}
+	});
+}
+const SYSTEM$1 = "Judge whether two skill documents describe the same reusable capability. Shared vocabulary or a shared preamble is not duplication. Return only strict JSON: {\"verdict\":1|0|-1,\"reason\":\"...\"}";
+function extractJson$1(text) {
+	const body = /\`\`\`(?:json)?\s*([\s\S]*?)\`\`\`/i.exec(text)?.[1] ?? text;
+	const start = body.indexOf("{");
+	if (start < 0) return void 0;
+	let depth = 0;
+	for (let index = start; index < body.length; index += 1) if (body[index] === "{") depth += 1;
+	else if (body[index] === "}") {
+		depth -= 1;
+		if (depth === 0) try {
+			return JSON.parse(body.slice(start, index + 1));
+		} catch {
+			return;
+		}
+	}
+}
+function parseVerdict(level, raw, cached = false) {
+	const value = typeof raw === "string" ? extractJson$1(raw) : raw;
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const verdict = record.verdict === 1 || record.verdict === "1" ? 1 : record.verdict === 0 || record.verdict === "0" ? 0 : record.verdict === -1 || record.verdict === "-1" ? -1 : void 0;
+	if (verdict === void 0) return void 0;
+	return {
+		level,
+		verdict,
+		reason: typeof record.reason === "string" ? record.reason.slice(0, 80) : "",
+		evidence: Array.isArray(record.evidence) ? record.evidence.filter((item) => typeof item === "object" && item !== null).map((item) => {
+			const entry = item;
+			return {
+				path: typeof entry.path === "string" ? entry.path : "",
+				line: typeof entry.line === "number" ? entry.line : -1,
+				quote: typeof entry.quote === "string" ? entry.quote.slice(0, 120) : ""
+			};
+		}) : [],
+		cached
+	};
+}
+/** Deterministic 10% L0 audit selection from the run seed + pair key. */
+function selectedForAudit(pairKey, seed, rate = .1) {
+	const digest = createHash("sha256").update(seed + "\0" + pairKey).digest();
+	return digest[0] !== void 0 && digest[0] < Math.round(Math.max(0, Math.min(1, rate)) * 256);
+}
+async function runLadder(options) {
+	const facts = new Map(options.facts.map((fact) => [fact.name, fact]));
+	const verdicts = [];
+	let calls = 0;
+	let level = options.startLevel ?? "L0";
+	for (;;) {
+		let payload;
+		try {
+			payload = payloadFor(level, options.candidate, facts);
+		} catch (error) {
+			return {
+				route: "error",
+				verdicts,
+				calls,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		const key = gateCacheKey(level, payload, options.modelName);
+		const cached = options.cache?.get(key);
+		let verdict;
+		if (cached !== void 0) verdict = {
+			...cached,
+			level,
+			cached: true
+		};
+		else try {
+			calls += 1;
+			const raw = await options.model.callJson({
+				system: SYSTEM$1,
+				user: payload,
+				maxTokens: 500,
+				signal: options.signal
+			});
+			verdict = parseVerdict(level, raw);
+			if (verdict !== void 0) options.cache?.put(key, verdict);
+		} catch (error) {
+			return {
+				route: "error",
+				verdicts,
+				calls,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (verdict === void 0) return {
+			route: "error",
+			verdicts,
+			calls,
+			error: "invalid gate JSON"
+		};
+		verdicts.push(verdict);
+		if (level === "L0") {
+			if (verdict.verdict === -1) return {
+				route: "keep",
+				verdicts,
+				calls,
+				droppedAt: "L0"
+			};
+			level = "L1";
+			continue;
+		}
+		if (level === "L1") {
+			if (verdict.verdict === -1) return {
+				route: "keep",
+				verdicts,
+				calls,
+				droppedAt: "L1"
+			};
+			level = "L2";
+			continue;
+		}
+		if (verdict.verdict === 1) return {
+			route: "merge",
+			verdicts,
+			calls
+		};
+		if (verdict.verdict === 0) return {
+			route: "undecided",
+			verdicts,
+			calls
+		};
+		return {
+			route: "keep",
+			verdicts,
+			calls,
+			droppedAt: "L2"
+		};
+	}
+}
+//#endregion
+//#region lib/types/gate-cache.js
+/**
+* File-backed gate cache: <home>/merge/gate-cache.json.
+* Reads are three-state; a malformed file is reported, not overwritten. Writes are one
+* transact so two runs cannot interleave a partial cache.
+*/
+const GATE_CACHE_VERSION = 1;
+function gateCachePath(home) {
+	return join(home, "merge", "gate-cache.json");
+}
+async function loadGateCache(io, home) {
+	const probe = await probeText(io, gateCachePath(home));
+	if (probe.kind === "absent") return { cache: new GateCache() };
+	if (probe.kind === "unknown") return {
+		cache: new GateCache(),
+		note: probe.reason
+	};
+	try {
+		const parsed = JSON.parse(probe.value);
+		if (parsed.schemaVersion !== 1 || typeof parsed.entries !== "object" || parsed.entries === null) return {
+			cache: new GateCache(),
+			note: "gate cache has an unexpected shape"
+		};
+		return { cache: GateCache.fromObject(parsed.entries) };
+	} catch (error) {
+		return {
+			cache: new GateCache(),
+			note: "gate cache is not JSON: " + (error instanceof Error ? error.message : String(error))
+		};
+	}
+}
+async function saveGateCache(io, home, cache) {
+	await transactIo(io, gateCachePath(home), () => JSON.stringify({
+		schemaVersion: 1,
+		entries: cache.toObject()
+	}, null, 2) + "\n");
+}
+function hasGateCache(cache) {
+	return cache.size > 0;
+}
+//#endregion
+//#region lib/types/doctor.js
+/**
+* Merge doctor rows: state, pending, gate cache and staging are each probed read-only.
+* A missing file is an empty feature, not a failure; an unreadable file is a warning the
+* operator can act on. This module never repairs or writes.
+*/
+const MERGE_DOCTOR_SCHEMA_VERSION = 3;
+async function mergeDoctor(io, home) {
+	const rows = [];
+	const loaded = await loadMergeState(io, home);
+	const counts = countRows(loaded.state.rows);
+	rows.push({
+		key: "state",
+		label: "合并状态",
+		status: loaded.note === void 0 ? "ok" : "warn",
+		detail: loaded.note ?? "pairs " + String(loaded.state.rows.length) + "；pending " + String(counts.pending) + " / retry " + String(counts.retry) + " / skipped " + String(counts.skipped)
+	});
+	const cache = await loadGateCache(io, home);
+	rows.push({
+		key: "gate-cache",
+		label: "闸门缓存",
+		status: cache.note === void 0 ? "ok" : "warn",
+		detail: cache.note ?? String(cache.cache.size) + " 条"
+	});
+	const runsDir = join(home, "merge", "runs");
+	const listed = await probeList(io, runsDir);
+	rows.push({
+		key: "staging",
+		label: "暂存树",
+		status: listed.kind === "unknown" ? "unknown" : "ok",
+		detail: listed.kind === "unknown" ? "无法列出 " + runsDir + "：" + listed.reason : listed.kind === "absent" ? "0 个 run 目录" : String(listed.value.length) + " 个 run 目录"
+	});
+	rows.push({
+		key: "staging-path",
+		label: "暂存路径",
+		status: "ok",
+		detail: stagingRoot(home, "<runId>")
+	});
+	return rows;
+}
+//#endregion
+//#region lib/types/decision.js
+function extractJson(text) {
+	const body = /\`\`\`(?:json)?\s*([\s\S]*?)\`\`\`/i.exec(text)?.[1] ?? text;
+	const start = body.indexOf("{");
+	if (start < 0) return void 0;
+	let depth = 0;
+	for (let index = start; index < body.length; index += 1) if (body[index] === "{") depth += 1;
+	else if (body[index] === "}") {
+		depth -= 1;
+		if (depth === 0) try {
+			return JSON.parse(body.slice(start, index + 1));
+		} catch {
+			return;
+		}
+	}
+}
+function parseDecision(text, pair) {
+	if (text === void 0 || text.trim() === "") return {
+		ok: false,
+		code: "decision-invalid",
+		message: "empty decision text"
+	};
+	const value = extractJson(text);
+	if (typeof value !== "object" || value === null) return {
+		ok: false,
+		code: "decision-invalid",
+		message: "decision is not a JSON object"
+	};
+	const record = value;
+	const shouldMerge = record.shouldMerge === true || record.should_merge === true;
+	const mode = record.mode;
+	if (mode !== "merge-into-existing" && mode !== "create-umbrella" && mode !== "keep") return {
+		ok: false,
+		code: "decision-invalid",
+		message: "mode must be merge-into-existing, create-umbrella or keep"
+	};
+	const target = typeof record.target === "string" ? record.target.trim() : "";
+	const sources = Array.isArray(record.sources) ? record.sources.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
+	const rationale = typeof record.rationale === "string" ? record.rationale.trim() : "";
+	if (!shouldMerge || mode === "keep") return {
+		ok: true,
+		decision: {
+			shouldMerge: false,
+			mode: "keep",
+			target,
+			sources,
+			rationale
+		}
+	};
+	if (target === "") return {
+		ok: false,
+		code: "decision-invalid",
+		message: "merge decision needs target"
+	};
+	if (sources.length === 0) return {
+		ok: false,
+		code: "decision-invalid",
+		message: "merge decision needs sources"
+	};
+	if (!sources.includes(pair.a) || !sources.includes(pair.b)) return {
+		ok: false,
+		code: "decision-invalid",
+		message: "sources must include both pair skills"
+	};
+	return {
+		ok: true,
+		decision: {
+			shouldMerge: true,
+			mode,
+			target,
+			sources,
+			rationale,
+			...typeof record.confidence === "number" ? { confidence: record.confidence } : {}
+		}
+	};
+}
+//#endregion
+//#region lib/types/prompts.js
+const MERGE_PROMPT_VERSION = "merge-pair/v1";
+const ROUND1_SYSTEM = "You decide whether two skill documents describe the same reusable capability. Shared vocabulary or a shared preamble is not duplication. Return only strict JSON.";
+const ROUND2_SYSTEM = "You write the merged skill into the staging tree through the merge_stage tool. Never modify the live skill tree. Follow the supplied decision exactly.";
+function buildRound1Prompt(candidate, cards) {
+	const byName = new Map(cards.map((card) => [card.name, card]));
+	const a = byName.get(candidate.a);
+	const b = byName.get(candidate.b);
+	return [
+		ROUND1_SYSTEM,
+		"",
+		"Return JSON: {\"should_merge\":true|false,\"mode\":\"merge-into-existing\"|\"create-umbrella\"|\"keep\",\"target\":\"<name>\",\"sources\":[\"<name>\",\"<name>\"],\"rationale\":\"<=120 chars\",\"confidence\":0..1}",
+		"If not enough evidence, set should_merge=false and mode=\"keep\".",
+		"",
+		"skill_a: " + JSON.stringify({
+			name: candidate.a,
+			description: a?.description ?? "",
+			body: (a?.body ?? "").slice(0, 6e3)
+		}),
+		"skill_b: " + JSON.stringify({
+			name: candidate.b,
+			description: b?.description ?? "",
+			body: (b?.body ?? "").slice(0, 6e3)
+		})
+	].join("\n");
+}
+function buildRound2Prompt(row, decision) {
+	return [
+		ROUND2_SYSTEM,
+		"",
+		"decision: " + JSON.stringify(decision),
+		"pair: " + JSON.stringify({
+			a: row.a,
+			b: row.b
+		}),
+		"target: " + JSON.stringify(decision.target),
+		"",
+		"Use merge_stage: list/read the source copies, write merged/" + decision.target + "/SKILL.md and any support files, then copy required support files. Do not write outside merged/" + decision.target + "/.",
+		"When the staged target is complete, reply with one short sentence. Do not return a JSON plan."
+	].join("\n");
+}
+//#endregion
+//#region lib/types/channel-port.js
+async function runRound1OverChannel(options, candidate, signal) {
+	let childId;
+	const dispose = async () => {
+		if (childId !== void 0) {
+			const id = childId;
+			childId = void 0;
+			try {
+				await options.channel.dispose(id);
+			} catch {}
+		}
+	};
+	const opened = await options.channel.open({
+		parent: options.parent,
+		label: "merge-round1",
+		promptText: buildRound1Prompt(candidate, options.cards),
+		kind: "reviewer",
+		allow: options.allow,
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		timeoutMs: options.timeoutMs,
+		signal
+	});
+	if (opened.kind === "unavailable") return {
+		outcome: {
+			kind: "failed",
+			failure: {
+				stage: "decide",
+				code: opened.code,
+				message: opened.reason,
+				retryable: true,
+				retryFrom: "agent1"
+			}
+		},
+		dispose
+	};
+	if (opened.kind === "aborted") return {
+		outcome: {
+			kind: "failed",
+			failure: {
+				stage: "decide",
+				code: "aborted",
+				message: "round1 aborted",
+				retryable: false,
+				retryFrom: "none"
+			}
+		},
+		dispose
+	};
+	childId = opened.childId;
+	if (opened.turn.stopReason !== "completed") {
+		await dispose();
+		return {
+			outcome: {
+				kind: "failed",
+				failure: {
+					stage: "decide",
+					code: opened.turn.stopReason,
+					message: "round1 did not complete",
+					retryable: true,
+					retryFrom: "agent1"
+				}
+			},
+			dispose
+		};
+	}
+	const parsed = parseDecision(opened.turn.text, candidate);
+	if (!parsed.ok) {
+		await dispose();
+		return {
+			outcome: {
+				kind: "failed",
+				failure: {
+					stage: "decide",
+					code: parsed.code,
+					message: parsed.message,
+					retryable: true,
+					retryFrom: "agent1"
+				}
+			},
+			dispose
+		};
+	}
+	if (!parsed.decision.shouldMerge || parsed.decision.mode === "keep") {
+		await dispose();
+		return {
+			outcome: {
+				kind: "keep",
+				decision: parsed.decision
+			},
+			dispose
+		};
+	}
+	const child = opened.childId;
+	return {
+		outcome: {
+			kind: "merge",
+			decision: parsed.decision
+		},
+		childId: child,
+		dispose,
+		async author(row, decision, turnSignal) {
+			const turn = await options.channel.continueTurn(child, buildRound2Prompt(row, decision), {
+				timeoutMs: options.timeoutMs,
+				signal: turnSignal
+			});
+			if (turn.kind !== "ok") throw new Error(turn.kind === "unavailable" ? turn.reason : "round2 aborted");
+			if (turn.turn.stopReason !== "completed") throw new Error("round2 did not complete: " + turn.turn.stopReason);
+			return turn.turn.text;
+		}
+	};
+}
+//#endregion
+//#region lib/types/staged-tree.js
+/**
+* Read the merged tree a child wrote into a staging run.
+*
+* The tree is the commit source: SKILL.md is the body, every other file is a support file.
+* A missing SKILL.md is unknown, never an empty merge; the caller then refuses commit.
+*/
+function safeRelative$1(path) {
+	if (path === "" || path.startsWith("/") || path.startsWith("\\") || path.includes("\0")) return false;
+	return path.replace(/\\/g, "/").split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+async function walkFiles(io, root, rel = "") {
+	const abs = rel === "" ? root : join(root, ...rel.split("/"));
+	try {
+		if (await io.readText(abs) !== null) return [rel];
+	} catch {}
+	const listed = await probeList(io, abs);
+	if (listed.kind === "unknown") throw new Error("cannot list " + abs + ": " + listed.reason);
+	if (listed.kind === "absent") return [];
+	const out = [];
+	for (const entry of listed.value) {
+		if (entry === "" || entry === "." || entry === "..") continue;
+		const child = rel === "" ? entry : rel + "/" + entry;
+		if (!safeRelative$1(child)) continue;
+		out.push(...await walkFiles(io, root, child));
+	}
+	return out;
+}
+async function readStagedTree(io, home, runId) {
+	const staging = await readStaging(io, home, runId);
+	if (staging.kind === "absent") return { kind: "absent" };
+	if (staging.kind === "unknown") return probeUnknown(staging.reason);
+	const target = staging.value.manifest.target;
+	const root = join(stagingRoot(home, runId), "merged", target);
+	let paths;
+	try {
+		paths = await walkFiles(io, root);
+	} catch (error) {
+		return probeUnknown("cannot list merged tree: " + (error instanceof Error ? error.message : String(error)));
+	}
+	if (!paths.includes("SKILL.md")) return probeUnknown("merged tree has no SKILL.md");
+	const files = [];
+	for (const path of paths.sort()) {
+		if (path === "SKILL.md") continue;
+		try {
+			const content = await io.readText(join(root, ...path.split("/")));
+			if (content === null) return probeUnknown("merged file disappeared: " + path);
+			files.push({
+				path,
+				content
+			});
+		} catch (error) {
+			return probeUnknown("cannot read merged file " + path + ": " + (error instanceof Error ? error.message : String(error)));
+		}
+	}
+	const body = await io.readText(join(root, "SKILL.md"));
+	if (body === null) return probeUnknown("merged SKILL.md disappeared");
+	return {
+		kind: "present",
+		value: {
+			target,
+			body,
+			files
+		}
+	};
+}
+//#endregion
+//#region lib/types/rules.js
+/**
+* Deterministic gate for a staged merge tree. No io, no model.
+*
+* block = commit must not proceed; warn = report only. The path and reference checks reuse
+* the skill-store's own `validateSupportPath` / `supportRefs`, so there is one whitelist.
+*/
+const PLACEHOLDER = /\bTODO\b|\bxxx\b|\{\{[^}]*\}\}/i;
+const DESC_WARN_LENGTH = 60;
+function validateStagedTree(tree, limits = DEFAULT_SKILL_LIMITS) {
+	const findings = [];
+	const block = (rule, path, message) => {
+		findings.push({
+			rule,
+			path,
+			severity: "block",
+			message
+		});
+	};
+	const warn = (rule, path, message) => {
+		findings.push({
+			rule,
+			path,
+			severity: "warn",
+			message
+		});
+	};
+	const parsed = parseFrontmatter(tree.body);
+	if (parsed === null) block("frontmatter", "SKILL.md", "SKILL.md has no valid frontmatter");
+	else {
+		const invalid = validateFrontmatter(tree.body, tree.target, limits);
+		if (invalid !== null) block("frontmatter", "SKILL.md", invalid);
+		if ((parsed.frontmatter.description ?? "").length > DESC_WARN_LENGTH) warn("desc-length", "SKILL.md", "description is longer than " + String(DESC_WARN_LENGTH) + " characters");
+	}
+	if (Buffer.byteLength(tree.body, "utf8") > limits.maxSkillFileBytes) block("bytes", "SKILL.md", "SKILL.md exceeds maxSkillFileBytes");
+	if (scanContentThreats(tree.body) !== null) block("threat", "SKILL.md", "SKILL.md tripped the content threat scanner");
+	if (PLACEHOLDER.test(tree.body)) warn("placeholder", "SKILL.md", "SKILL.md contains a TODO/xxx/{{...}} placeholder");
+	const paths = /* @__PURE__ */ new Set();
+	for (const file of tree.files) {
+		const badPath = validateSupportPath(file.path);
+		if (badPath !== null) {
+			block("path", file.path, badPath);
+			continue;
+		}
+		paths.add(file.path);
+		if (Buffer.byteLength(file.content, "utf8") > limits.maxSkillFileBytes) block("bytes", file.path, "file exceeds maxSkillFileBytes");
+		if (scanContentThreats(file.content) !== null) block("threat", file.path, "file tripped the content threat scanner");
+		if (PLACEHOLDER.test(file.content)) warn("placeholder", file.path, "file contains a TODO/xxx/{{...}} placeholder");
+	}
+	for (const ref of supportRefs(tree.body)) if (!paths.has(ref)) block("refs-pair", ref, "body references a support file that is not staged");
+	return findings;
+}
+function hasBlockingFinding(findings) {
+	return findings.some((finding) => finding.severity === "block");
+}
+//#endregion
+//#region lib/types/commit-plan.js
+const MAX_SKILL_NAME_LENGTH = 64;
+/** Pick the first free target: requested, then -v2, -v3, ... (never truncate a name). */
+function resolveTargetName(requested, exists) {
+	if (requested.length === 0 || requested.length > MAX_SKILL_NAME_LENGTH) return {
+		ok: false,
+		message: "target name must be 1.." + String(MAX_SKILL_NAME_LENGTH) + " characters"
+	};
+	if (!exists(requested)) return {
+		ok: true,
+		name: requested,
+		suffix: 1
+	};
+	for (let suffix = 2; suffix <= 99; suffix += 1) {
+		const candidate = requested + "-v" + String(suffix);
+		if (candidate.length > MAX_SKILL_NAME_LENGTH) break;
+		if (!exists(candidate)) return {
+			ok: true,
+			name: candidate,
+			suffix
+		};
+	}
+	return {
+		ok: false,
+		message: "no free target name for " + requested + " (tried up to -v99)"
+	};
+}
+/** Rewrite only the frontmatter name; body bytes stay otherwise intact. */
+function rewriteFrontmatterName(body, name) {
+	const lines = body.split("\n");
+	if (lines[0]?.trim() !== "---") return body;
+	const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+	if (end < 0) return body;
+	for (let index = 1; index < end; index += 1) if (/^name\s*:/.test(lines[index] ?? "")) {
+		lines[index] = "name: " + name;
+		return lines.join("\n");
+	}
+	return body;
+}
+function buildCommitPlan(input) {
+	if (input.create !== (input.targetCurrent === null)) return {
+		ok: false,
+		message: "create flag disagrees with the live target"
+	};
+	if (input.sourceBodies.length === 0) return {
+		ok: false,
+		message: "a merge needs at least one source"
+	};
+	const body = rewriteFrontmatterName(input.mergedBody, input.target);
+	return {
+		ok: true,
+		plan: {
+			target: input.target,
+			targetExists: !input.create,
+			sources: input.sourceBodies.map((source) => source.name),
+			body,
+			supportFiles: input.mergedFiles,
+			expectedTargetBody: input.targetCurrent,
+			expectedSourceBodies: input.sourceBodies,
+			origin: input.origin,
+			summary: input.summary
+		}
+	};
+}
+//#endregion
+//#region lib/types/commit-assembly.js
+async function assembleStagedCommit(io, home, runId, port, options) {
+	const staging = await readStaging(io, home, runId);
+	if (!isPresent(staging)) return {
+		ok: false,
+		message: "staging is not present for run " + runId
+	};
+	const tree = await readStagedTree(io, home, runId);
+	if (!isPresent(tree)) return {
+		ok: false,
+		message: "merged tree is not readable for run " + runId
+	};
+	const targetCurrent = await port.readSkill(staging.value.manifest.target);
+	const sources = [];
+	for (const name of staging.value.manifest.sources) {
+		const body = await port.readSkill(name);
+		if (body === null) return {
+			ok: false,
+			message: "source skill is not live: " + name
+		};
+		sources.push({
+			name,
+			body
+		});
+	}
+	return buildCommitPlan({
+		target: staging.value.manifest.target,
+		create: targetCurrent === null,
+		mergedBody: tree.value.body,
+		mergedFiles: tree.value.files,
+		targetCurrent,
+		sourceBodies: sources,
+		origin: options.origin,
+		summary: options.summary
+	});
+}
+//#endregion
+//#region lib/types/commit-execute.js
+async function commitStagedRun(io, home, runId, port, options) {
+	const assembled = await assembleStagedCommit(io, home, runId, port, {
+		origin: options.origin,
+		summary: options.summary
+	});
+	if (!assembled.ok) return {
+		ok: false,
+		message: assembled.message
+	};
+	const result = await port.commitMerge(assembled.plan);
+	if (!result.ok) return {
+		ok: false,
+		message: result.message,
+		plan: assembled.plan
+	};
+	if (result.unitId === void 0) return {
+		ok: true,
+		plan: assembled.plan,
+		result,
+		warning: "commit landed without a unitId; receipt not written"
+	};
+	const receipt = {
+		runId,
+		unitId: result.unitId,
+		target: assembled.plan.target,
+		create: !assembled.plan.targetExists,
+		sources: assembled.plan.sources,
+		archived: result.archived ?? [],
+		at: options.now()
+	};
+	try {
+		await writeCommitReceipt(io, home, receipt);
+		return {
+			ok: true,
+			plan: assembled.plan,
+			result,
+			receipt
+		};
+	} catch (error) {
+		return {
+			ok: true,
+			plan: assembled.plan,
+			result,
+			warning: "commit landed but receipt write failed: " + (error instanceof Error ? error.message : String(error))
+		};
+	}
+}
+//#endregion
+//#region lib/types/authoring-flow.js
+async function runAuthoring(options) {
+	const created = await createStaging(options.io, options.home, {
+		runId: options.runId,
+		target: options.target,
+		sources: options.cards.map((card) => ({
+			name: card.name,
+			body: card.body,
+			files: []
+		})),
+		promptVersion: "merge-pair/v1",
+		ttlDays: 7,
+		now: options.now
+	});
+	if (!created.ok) return {
+		ok: false,
+		message: created.message
+	};
+	try {
+		await options.author({
+			home: options.home,
+			runId: options.runId
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			message: "author failed: " + (error instanceof Error ? error.message : String(error))
+		};
+	}
+	const tree = await readStagedTree(options.io, options.home, options.runId);
+	if (tree.kind !== "present") return {
+		ok: false,
+		message: "staged tree is not readable: " + (tree.kind === "unknown" ? tree.reason : "absent")
+	};
+	const findings = validateStagedTree(tree.value);
+	if (hasBlockingFinding(findings)) return {
+		ok: false,
+		message: "staged tree failed the rule gate",
+		findings
+	};
+	const commit = await commitStagedRun(options.io, options.home, options.runId, options.commitPort, {
+		origin: "subagent",
+		summary: options.summary,
+		now: options.now
+	});
+	if (!commit.ok) return {
+		ok: false,
+		message: commit.message
+	};
+	return {
+		ok: true,
+		tree: tree.value,
+		commit
+	};
+}
+//#endregion
+//#region lib/types/scan-ports.js
+function createChannelScanPorts(options) {
+	const sessions = /* @__PURE__ */ new Map();
+	return {
+		screening: options.screening,
+		async round1(candidate, signal) {
+			const result = await runRound1OverChannel({
+				channel: options.channel,
+				parent: options.parent,
+				cards: options.cards,
+				allow: options.allow,
+				...options.cwd === void 0 ? {} : { cwd: options.cwd },
+				timeoutMs: options.timeoutMs
+			}, candidate, signal);
+			if (result.outcome.kind === "merge") if (options.approval) await result.dispose();
+			else {
+				sessions.set(pairKey(candidate.a, candidate.b), result);
+				if (result.childId !== void 0) options.onChild?.({
+					runId: options.runId,
+					childId: result.childId,
+					expectedChildId: result.childId,
+					phase: "author"
+				});
+			}
+			return result.outcome;
+		},
+		async round2(row, decision, signal) {
+			const key = pairKey(row.a, row.b);
+			const session = sessions.get(key);
+			if (session === void 0) return {
+				kind: "failed",
+				failure: {
+					stage: "author",
+					code: "no-session",
+					message: "no same-child round2 session; approve must open a new child",
+					retryable: false,
+					retryFrom: "none"
+				}
+			};
+			sessions.delete(key);
+			try {
+				const authored = await runAuthoring({
+					io: options.io,
+					home: options.home,
+					runId: options.runId,
+					target: decision.target,
+					cards: options.cards,
+					commitPort: options.commitPort,
+					now: options.now,
+					summary: "merge " + row.a + " + " + row.b,
+					author: async () => {
+						await session.author?.(row, decision, signal);
+						return "authored";
+					}
+				});
+				if (!authored.ok) return {
+					kind: "failed",
+					failure: {
+						stage: "author",
+						code: "authoring-failed",
+						message: authored.message,
+						retryable: true,
+						retryFrom: "agent2"
+					}
+				};
+				const receipt = authored.commit.ok ? authored.commit.receipt : void 0;
+				return {
+					kind: "merged",
+					...receipt?.unitId === void 0 ? {} : { unitId: receipt.unitId },
+					archived: receipt?.archived ?? [],
+					target: {
+						requested: decision.target,
+						actual: decision.target,
+						created: receipt?.create ?? false
+					}
+				};
+			} finally {
+				await session.dispose();
+				if (session.childId !== void 0) options.onChildClosed?.(session.childId);
+			}
+		}
+	};
+}
+//#endregion
+//#region lib/types/new-child-authoring.js
+async function runNewChildAuthoring(options, row, decision, signal) {
+	const staging = await createStaging(options.io, options.home, {
+		runId: options.runId,
+		target: decision.target,
+		sources: options.cards.map((card) => ({
+			name: card.name,
+			body: card.body,
+			files: []
+		})),
+		promptVersion: "merge-pair/v1",
+		ttlDays: 7,
+		now: options.now
+	});
+	if (!staging.ok) return {
+		kind: "failed",
+		failure: {
+			stage: "author",
+			code: "staging-create",
+			message: staging.message,
+			retryable: true,
+			retryFrom: "agent2"
+		}
+	};
+	const opened = await options.channel.open({
+		parent: options.parent,
+		label: "merge-round2",
+		promptText: buildRound2Prompt(row, decision),
+		kind: "maintainer",
+		allow: options.allow,
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		timeoutMs: options.timeoutMs,
+		signal
+	});
+	if (opened.kind !== "ok") return {
+		kind: "failed",
+		failure: {
+			stage: "author",
+			code: opened.kind,
+			message: opened.kind === "unavailable" ? opened.reason : "round2 aborted",
+			retryable: opened.kind !== "aborted",
+			retryFrom: opened.kind === "aborted" ? "none" : "agent2"
+		}
+	};
+	options.onChild?.({
+		runId: options.runId,
+		childId: opened.childId,
+		expectedChildId: opened.childId,
+		phase: "author"
+	});
+	try {
+		if (opened.turn.stopReason !== "completed") return {
+			kind: "failed",
+			failure: {
+				stage: "author",
+				code: opened.turn.stopReason,
+				message: "round2 did not complete",
+				retryable: true,
+				retryFrom: "agent2"
+			}
+		};
+		const tree = await readStagedTree(options.io, options.home, options.runId);
+		if (tree.kind !== "present") return {
+			kind: "failed",
+			failure: {
+				stage: "author",
+				code: "staging-missing",
+				message: tree.kind === "unknown" ? tree.reason : "staged tree absent",
+				retryable: true,
+				retryFrom: "agent2"
+			}
+		};
+		if (hasBlockingFinding(validateStagedTree(tree.value))) return {
+			kind: "failed",
+			failure: {
+				stage: "validate",
+				code: "rule-gate",
+				message: "staged tree failed the rule gate",
+				retryable: true,
+				retryFrom: "agent2"
+			}
+		};
+		const commit = await commitStagedRun(options.io, options.home, options.runId, options.commitPort, {
+			origin: "subagent",
+			summary: "merge " + row.a + " + " + row.b,
+			now: options.now
+		});
+		if (!commit.ok) return {
+			kind: "failed",
+			failure: {
+				stage: "commit",
+				code: "commit-failed",
+				message: commit.message,
+				retryable: true,
+				retryFrom: "agent2"
+			}
+		};
+		const receipt = commit.receipt;
+		return {
+			kind: "merged",
+			...receipt?.unitId === void 0 ? {} : { unitId: receipt.unitId },
+			archived: receipt?.archived ?? [],
+			target: {
+				requested: decision.target,
+				actual: decision.target,
+				created: receipt?.create ?? false
+			}
+		};
+	} finally {
+		try {
+			await options.channel.dispose(opened.childId);
+		} catch {}
+		options.onChildClosed?.(opened.childId);
+	}
+}
+function createNewChildRound2(options) {
+	return (row, decision, signal, runId) => runNewChildAuthoring({
+		...options,
+		runId
+	}, row, decision, signal);
+}
+//#endregion
+//#region lib/types/adapters/library.js
+function skillLibraryPort(skills) {
+	return {
+		readSkill: (name) => skills.read(name),
+		commitMerge: (plan) => skills.commitMerge(plan)
+	};
+}
+//#endregion
+//#region lib/types/runtime.js
+/**
+* The merge command runtime: cards -> screening -> channel ports -> scan/approve.
+* Plugin wiring supplies the channel, model and library; this module keeps the orchestration
+* out of apply() and makes the mutating verbs testable with fakes.
+*/
+function createMergeRuntime(deps) {
+	const readOnly = createReadOnlyMergeService(deps.io, deps.home);
+	const timeout = deps.timeoutMinutes > 0 ? deps.timeoutMinutes : void 0;
+	const common = {
+		io: deps.io,
+		home: deps.home,
+		registry: deps.registry,
+		platformWrite: deps.platformWrite,
+		now: deps.now,
+		...timeout === void 0 ? {} : { timeoutMinutes: timeout }
+	};
+	const stage = deps.stage;
+	const stageHooks = stage === void 0 ? {} : {
+		onChild: (context) => {
+			stage.bind(context);
+		},
+		onChildClosed: (childId) => {
+			stage.unbind(childId);
+		}
+	};
+	return { async execute(command, context) {
+		const parent = context?.parent ?? deps.parent;
+		if (command.verb === "pair") {
+			const signal = new AbortController().signal;
+			const cards = await deps.cards(signal);
+			const pair = [{
+				a: command.a,
+				b: command.b
+			}];
+			const result = await runScanCommand({
+				...common,
+				approval: deps.params.mergeApproval,
+				makePorts: (runId) => createChannelScanPorts({
+					io: deps.io,
+					home: deps.home,
+					runId,
+					cards,
+					screening: () => Promise.resolve(pair),
+					channel: deps.channel,
+					parent,
+					allow: deps.allow,
+					...deps.cwd === void 0 ? {} : { cwd: deps.cwd },
+					timeoutMs: deps.params.mergePairTimeoutMinutes * 6e4,
+					approval: deps.params.mergeApproval,
+					commitPort: skillLibraryPort(deps.skills),
+					now: deps.now,
+					...stageHooks
+				})
+			});
+			return result.ok ? {
+				ok: true,
+				text: "merge pair 完成：merged " + String(result.report.totals.merged) + " / pending " + String(result.report.totals.pending) + " / failed " + String(result.report.totals.failed)
+			} : {
+				ok: false,
+				text: result.message
+			};
+		}
+		if (command.verb === "scan") {
+			const signal = new AbortController().signal;
+			const cards = await deps.cards(signal);
+			const skipped = skippedPairKeys((await loadMergeState(deps.io, deps.home)).state.rows, deps.params.mergeSkippedTtlDays, deps.now());
+			const result = await runScanCommand({
+				...common,
+				approval: deps.params.mergeApproval,
+				makePorts: (runId) => createChannelScanPorts({
+					io: deps.io,
+					home: deps.home,
+					runId,
+					cards,
+					screening: async (turnSignal) => {
+						return (deps.screeningForRun === void 0 ? await deps.screening(cards, turnSignal) : await deps.screeningForRun(cards, runId, turnSignal)).filter((candidate) => !skipped.has(pairKey(candidate.a, candidate.b)));
+					},
+					channel: deps.channel,
+					parent,
+					allow: deps.allow,
+					...deps.cwd === void 0 ? {} : { cwd: deps.cwd },
+					timeoutMs: deps.params.mergePairTimeoutMinutes * 6e4,
+					approval: deps.params.mergeApproval,
+					commitPort: skillLibraryPort(deps.skills),
+					now: deps.now,
+					...stageHooks
+				})
+			});
+			return result.ok ? {
+				ok: true,
+				text: "merge scan 完成：merged " + String(result.report.totals.merged) + " / pending " + String(result.report.totals.pending) + " / failed " + String(result.report.totals.failed)
+			} : {
+				ok: false,
+				text: result.message
+			};
+		}
+		if (command.verb === "reject") {
+			const row = (await loadMergeState(deps.io, deps.home)).state.rows.find((item) => item.id === command.id);
+			if (row === void 0) return {
+				ok: false,
+				text: "merge row not found: " + command.id
+			};
+			const next = transition(row, {
+				type: "reject",
+				at: new Date(deps.now()).toISOString()
+			});
+			if (!next.ok || next.row === null) return {
+				ok: false,
+				text: "merge row is not pending: " + command.id
+			};
+			await upsertRow(deps.io, deps.home, deps.now, next.row);
+			return {
+				ok: true,
+				text: "已拒绝合并：" + command.id
+			};
+		}
+		if (command.verb === "doctor") return {
+			ok: true,
+			text: (await mergeDoctor(deps.io, deps.home)).map((row) => row.key + " [" + row.status + "] " + row.label + "：" + row.detail).join("\n")
+		};
+		if (command.verb === "report" || command.verb === "runs" || command.verb === "cancel") {
+			const registry = deps.registry;
+			if (command.verb === "runs") {
+				const mergeRuns = registry.runs("merge");
+				return {
+					ok: true,
+					text: mergeRuns.length === 0 ? "merge runs: empty" : ["merge runs: " + String(mergeRuns.length)].concat(mergeRuns.map((run) => "- " + run.id + " [" + run.state + "]" + (run.resultRef === void 0 ? "" : " " + run.resultRef))).join("\n")
+				};
+			}
+			if (command.verb === "cancel") {
+				if (command.id !== void 0) {
+					const cancelled = registry.cancel(command.id);
+					return {
+						ok: cancelled,
+						text: cancelled ? "已请求取消 " + command.id : "没有可取消的 run: " + command.id
+					};
+				}
+				const count = registry.cancelAll();
+				return {
+					ok: true,
+					text: "已请求取消 " + String(count) + " 个运行"
+				};
+			}
+			const run = command.id === void 0 ? registry.runs("merge")[0] : registry.find(command.id);
+			if (run === void 0) return {
+				ok: false,
+				text: "merge run not found: " + (command.id ?? "(latest)")
+			};
+			if (run.resultRef === void 0) return {
+				ok: false,
+				text: "merge run has no report yet: " + run.id
+			};
+			const report = await probeText(deps.io, run.resultRef);
+			if (report.kind === "unknown") return {
+				ok: false,
+				text: "report is unreadable: " + run.resultRef + "：" + report.reason
+			};
+			return report.kind === "absent" ? {
+				ok: false,
+				text: "report is missing: " + run.resultRef
+			} : {
+				ok: true,
+				text: report.value.slice(0, 12e3)
+			};
+		}
+		if (command.verb === "undo") {
+			const receipt = await readCommitReceipt(deps.io, deps.home, command.run);
+			if (receipt === null) return {
+				ok: false,
+				text: "merge run has no commit receipt: " + command.run
+			};
+			if (receipt.target !== command.target) return {
+				ok: false,
+				text: "receipt target is " + receipt.target + ", not " + command.target
+			};
+			const result = await undoMergeReceipt(receipt, skillLibraryUndoPort(deps.skills));
+			return {
+				ok: result.ok,
+				text: result.message
+			};
+		}
+		if (command.verb === "skipped" && command.restore !== void 0) {
+			const row = (await loadMergeState(deps.io, deps.home)).state.rows.find((item) => item.id === command.restore);
+			if (row === void 0 || row.state !== "skipped") return {
+				ok: false,
+				text: "skipped row not found: " + command.restore
+			};
+			await dropRow(deps.io, deps.home, deps.now, row.id);
+			return {
+				ok: true,
+				text: "已恢复参与筛选：" + row.id
+			};
+		}
+		if (command.verb === "resume") {
+			if (command.clear !== void 0) {
+				const cleared = (await loadMergeState(deps.io, deps.home)).state.rows.find((item) => item.id === command.clear);
+				if (cleared === void 0) return {
+					ok: false,
+					text: "merge row not found: " + command.clear
+				};
+				await dropRow(deps.io, deps.home, deps.now, cleared.id);
+				return {
+					ok: true,
+					text: "已清除合并行：" + cleared.id
+				};
+			}
+			const loaded = await loadMergeState(deps.io, deps.home);
+			const row = command.id === void 0 ? loaded.state.rows.find((item) => item.state === "fuse" || item.state === "verify") : loaded.state.rows.find((item) => item.id === command.id);
+			if (row === void 0) return {
+				ok: false,
+				text: "merge row not found: " + (command.id ?? "(auto)")
+			};
+			const signal = new AbortController().signal;
+			const cards = await deps.cards(signal);
+			const pair = () => Promise.resolve([{
+				a: row.a,
+				b: row.b
+			}]);
+			const failed = (stage, code, message) => Promise.resolve({
+				kind: "failed",
+				failure: {
+					stage,
+					code,
+					message,
+					retryable: false,
+					retryFrom: "none"
+				}
+			});
+			const basePorts = {
+				screening: pair,
+				round1: () => failed("decide", "resume-needs-ports", "verify resume needs makePorts"),
+				round2: () => failed("author", "resume-needs-child", "fuse resume needs a new child")
+			};
+			const result = await runResumeCommand({
+				...common,
+				rowId: row.id,
+				ports: basePorts,
+				makePorts: (runId) => createChannelScanPorts({
+					io: deps.io,
+					home: deps.home,
+					runId,
+					cards,
+					screening: pair,
+					channel: deps.channel,
+					parent,
+					allow: deps.allow,
+					...deps.cwd === void 0 ? {} : { cwd: deps.cwd },
+					timeoutMs: deps.params.mergePairTimeoutMinutes * 6e4,
+					approval: deps.params.mergeApproval,
+					commitPort: skillLibraryPort(deps.skills),
+					now: deps.now
+				}),
+				round2WithRun: createNewChildRound2({
+					io: deps.io,
+					home: deps.home,
+					cards,
+					channel: deps.channel,
+					parent,
+					allow: deps.allow,
+					...deps.cwd === void 0 ? {} : { cwd: deps.cwd },
+					timeoutMs: deps.params.mergePairTimeoutMinutes * 6e4,
+					commitPort: skillLibraryPort(deps.skills),
+					now: deps.now,
+					...stageHooks
+				})
+			});
+			return result.ok ? {
+				ok: true,
+				text: "merge resume 完成：merged " + String(result.report.totals.merged)
+			} : {
+				ok: false,
+				text: result.message
+			};
+		}
+		if (command.verb === "approve") {
+			const signal = new AbortController().signal;
+			const cards = await deps.cards(signal);
+			const result = await runApproveCommand({
+				...common,
+				rowId: command.id,
+				ports: { round2: createNewChildRound2({
+					io: deps.io,
+					home: deps.home,
+					cards,
+					channel: deps.channel,
+					parent,
+					allow: deps.allow,
+					...deps.cwd === void 0 ? {} : { cwd: deps.cwd },
+					timeoutMs: deps.params.mergePairTimeoutMinutes * 6e4,
+					commitPort: skillLibraryPort(deps.skills),
+					now: deps.now
+				}) }
+			});
+			return result.ok ? {
+				ok: true,
+				text: "merge approve 完成：merged " + String(result.report.totals.merged)
+			} : {
+				ok: false,
+				text: result.message
+			};
+		}
+		const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home);
+		if (text !== null) return {
+			ok: true,
+			text
+		};
+		return readOnly.execute(command);
+	} };
+}
+//#endregion
+//#region lib/types/params.js
+const MERGE_PARAM_DEFAULTS = {
+	mergeApproval: false,
+	mergeSkippedTtlDays: 0,
+	mergeRunTimeoutMinutes: 0,
+	mergePairTimeoutMinutes: 15
+};
+const KEYS = new Set(Object.keys(MERGE_PARAM_DEFAULTS));
+function materialize(value) {
+	if (typeof value === "object" && value !== null && typeof value.get === "function") return value.get();
+	return value;
+}
+function nonNegative(name, value) {
+	const resolved = materialize(value);
+	if (typeof resolved !== "number" || !Number.isInteger(resolved) || resolved < 0) throw new Error(name + " must be a non-negative integer");
+	return resolved;
+}
+function resolveMergeParams(input = {}) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error("merge params must be an object");
+	for (const key of Object.keys(input)) if (!KEYS.has(key)) throw new Error("unknown merge parameter: " + key);
+	const record = input;
+	const approval = record.mergeApproval === void 0 ? MERGE_PARAM_DEFAULTS.mergeApproval : materialize(record.mergeApproval);
+	if (typeof approval !== "boolean") throw new Error("mergeApproval must be a boolean");
+	return {
+		mergeApproval: approval,
+		mergeSkippedTtlDays: record.mergeSkippedTtlDays === void 0 ? MERGE_PARAM_DEFAULTS.mergeSkippedTtlDays : nonNegative("mergeSkippedTtlDays", record.mergeSkippedTtlDays),
+		mergeRunTimeoutMinutes: record.mergeRunTimeoutMinutes === void 0 ? MERGE_PARAM_DEFAULTS.mergeRunTimeoutMinutes : nonNegative("mergeRunTimeoutMinutes", record.mergeRunTimeoutMinutes),
+		mergePairTimeoutMinutes: record.mergePairTimeoutMinutes === void 0 ? MERGE_PARAM_DEFAULTS.mergePairTimeoutMinutes : (() => {
+			const value = nonNegative("mergePairTimeoutMinutes", record.mergePairTimeoutMinutes);
+			if (value === 0) throw new Error("mergePairTimeoutMinutes must be > 0");
+			return value;
+		})()
+	};
+}
+//#endregion
+//#region lib/types/screening.js
+/**
+* Deterministic candidate screening: name prefilter + lexical affinity.
+*
+* The semantic proposer (C3) is a separate port; this module is the zero-cost floor that
+* must work without a model. It reuses core `vocabulary`/`affinity` so drift/dedup and
+* merge screening share one tokenizer.
+*/
+/** Shannon entropy over characters; a cheap prefilter signal, not a name-quality judge. */
+function nameEntropy(name) {
+	if (name === "") return 0;
+	const counts = /* @__PURE__ */ new Map();
+	for (const char of name) counts.set(char, (counts.get(char) ?? 0) + 1);
+	let entropy = 0;
+	for (const count of counts.values()) {
+		const p = count / name.length;
+		entropy -= p * Math.log2(p);
+	}
+	return entropy;
+}
+const MIN_NAME_ENTROPY = 1.5;
+const MIN_NAME_LENGTH = 6;
+function prefilter(cards) {
+	return cards.filter((card) => {
+		const name = card.name.trim();
+		if (name.length < MIN_NAME_LENGTH) return false;
+		if (nameEntropy(name) < MIN_NAME_ENTROPY) return false;
+		return card.body.trim() !== "" || card.description.trim() !== "";
+	});
+}
+function sortedPair(a, b) {
+	return a < b ? [a, b] : [b, a];
+}
+function lexicalCandidates(cards, options = {}) {
+	const bodyGate = options.bodyGate ?? .9;
+	const summaryGate = options.summaryGate ?? .5;
+	const minAffinity = options.minAffinity ?? .3;
+	const eligible = prefilter(cards);
+	const vectors = eligible.map((card) => ({
+		card,
+		summary: vocabulary(card.description),
+		body: vocabulary(card.body)
+	}));
+	const candidates = [];
+	for (let i = 0; i < vectors.length; i += 1) for (let j = i + 1; j < vectors.length; j += 1) {
+		const left = vectors[i];
+		const right = vectors[j];
+		if (left === void 0 || right === void 0) continue;
+		const summary = affinity(left.summary, right.summary);
+		const body = affinity(left.body, right.body);
+		const arms = [];
+		if (body >= bodyGate) arms.push("body");
+		if (summary >= summaryGate && body >= minAffinity) arms.push("summary");
+		if (arms.length === 0) continue;
+		const [a, b] = sortedPair(left.card.name, right.card.name);
+		candidates.push({
+			a,
+			b,
+			score: Math.max(body, summary),
+			arms,
+			source: "lexical"
+		});
+	}
+	candidates.sort((left, right) => (right.score ?? 0) - (left.score ?? 0) || left.a.localeCompare(right.a) || left.b.localeCompare(right.b));
+	const capped = options.maxCandidates === void 0 ? candidates : candidates.slice(0, options.maxCandidates);
+	return {
+		candidates: capped,
+		stats: {
+			skills: cards.length,
+			filtered: cards.length - eligible.length,
+			candidates: capped.length
+		}
+	};
+}
+//#endregion
+//#region lib/types/adapters/channel.js
+function convert(outcome) {
+	if (outcome.kind !== "ok") return outcome;
+	return {
+		kind: "ok",
+		childId: String(outcome.childId),
+		turn: {
+			text: outcome.turn.text,
+			stopReason: outcome.turn.stopReason
+		}
+	};
+}
+function subagentChannelAdapter(channel) {
+	return {
+		async open(spec) {
+			if (channel.open === void 0) return {
+				kind: "unavailable",
+				code: "E-323",
+				reason: "subagent channel has no open()"
+			};
+			return convert(await channel.open(spec));
+		},
+		async continueTurn(childId, promptText, options) {
+			if (channel.continueTurn === void 0) return {
+				kind: "unavailable",
+				code: "E-323",
+				reason: "subagent channel has no continueTurn()"
+			};
+			return convert(await channel.continueTurn(childId, promptText, options));
+		},
+		async dispose(childId) {
+			if (channel.dispose === void 0) return;
+			await channel.dispose(childId);
+		}
+	};
+}
+//#endregion
+//#region lib/types/adapters/model.js
+function append(chunk, text) {
+	if (chunk.type === "text-delta" || chunk.type === "text") return text + (chunk.text ?? "");
+	if (chunk.type === "finish" && chunk.reason?.kind === "error") throw new Error("model call failed: " + (chunk.reason.failure?.message ?? "unknown"));
+	return text;
+}
+function createModelPort(llm, route) {
+	return { async callJson(request) {
+		const selection = route();
+		let text = "";
+		if (llm.stream !== void 0) {
+			for await (const chunk of llm.stream({
+				provider: selection.provider,
+				model: selection.model,
+				system: request.system,
+				messages: [{
+					role: "user",
+					content: [{
+						type: "text",
+						text: request.user
+					}]
+				}],
+				maxTokens: request.maxTokens,
+				temperature: 0,
+				signal: request.signal
+			})) text = append(chunk, text);
+			return text;
+		}
+		if (llm.prepareCall === void 0) throw new Error("llm service has neither stream nor prepareCall");
+		const call = await llm.prepareCall({
+			provider: selection.provider,
+			model: selection.model,
+			maxTokens: request.maxTokens,
+			temperature: 0
+		}, request.signal);
+		for await (const chunk of call.stream({
+			...call.config,
+			system: request.system,
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: request.user
+				}]
+			}],
+			signal: request.signal
+		})) text = append(chunk, text);
+		return text;
+	} };
+}
+//#endregion
+//#region lib/types/propose.js
+const SYSTEM = "You propose skill pairs that may be merged. Return only a JSON object: {\"pairs\":[{\"a\":\"skill-a\",\"b\":\"skill-b\",\"reason\":\"one sentence\"}]}. Use only supplied skill names. Do not decide whether a merge is good.";
+function parsePairs(raw, known, cap) {
+	let value = raw;
+	if (typeof raw === "string") try {
+		value = JSON.parse(raw);
+	} catch {
+		return [];
+	}
+	if (typeof value !== "object" || value === null) return [];
+	const pairs = value.pairs;
+	if (!Array.isArray(pairs)) return [];
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of pairs) {
+		if (out.length >= cap) break;
+		const pair = item;
+		if (typeof pair.a !== "string" || typeof pair.b !== "string") continue;
+		const a = pair.a.trim();
+		const b = pair.b.trim();
+		if (a === b || !known.has(a) || !known.has(b)) continue;
+		const [first, second] = a < b ? [a, b] : [b, a];
+		const key = first + "\0" + second;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			a: first,
+			b: second,
+			source: "proposed",
+			...typeof pair.reason === "string" && pair.reason.trim() !== "" ? { reason: pair.reason.trim() } : {}
+		});
+	}
+	return out;
+}
+async function proposePairs(cards, port, options) {
+	const shardSize = Math.max(2, options.shardSize ?? 60);
+	const cap = Math.max(0, options.maxPairs ?? 200);
+	const known = new Set(cards.map((card) => card.name));
+	const candidates = [];
+	const degraded = [];
+	let shards = 0;
+	for (let start = 0; start < cards.length && candidates.length < cap; start += shardSize) {
+		const shard = cards.slice(start, start + shardSize);
+		if (shard.length < 2) continue;
+		shards += 1;
+		try {
+			const raw = await port.callJson({
+				system: SYSTEM,
+				user: JSON.stringify(shard.map((card) => ({
+					name: card.name,
+					description: card.description.slice(0, 400),
+					body: card.body.slice(0, 600)
+				}))),
+				maxTokens: 1200,
+				signal: options.signal
+			});
+			candidates.push(...parsePairs(raw, known, cap - candidates.length));
+		} catch (error) {
+			degraded.push("proposal shard failed: " + (error instanceof Error ? error.message : String(error)));
+		}
+	}
+	return {
+		candidates,
+		shards,
+		degraded
+	};
+}
+//#endregion
+//#region lib/types/gate-filter.js
+function withGate(candidate, verdicts, auditOverride) {
+	const last = verdicts[verdicts.length - 1];
+	if (last === void 0) return candidate;
+	return {
+		...candidate,
+		gate: {
+			level: last.level,
+			verdict: last.verdict,
+			reason: last.reason,
+			...last.cached ? { cached: true } : {},
+			...auditOverride ? { auditOverride: true } : {}
+		}
+	};
+}
+async function filterCandidates(candidates, options) {
+	const kept = [];
+	const dropped = [];
+	const errors = [];
+	let calls = 0;
+	for (const candidate of candidates) {
+		const first = await runLadder({
+			level: "L0",
+			candidate,
+			facts: options.facts,
+			model: options.model,
+			modelName: options.modelName,
+			signal: options.signal,
+			...options.cache === void 0 ? {} : { cache: options.cache }
+		});
+		calls += first.calls;
+		if (first.route === "error") {
+			errors.push({
+				candidate,
+				message: first.error ?? "gate error"
+			});
+			continue;
+		}
+		if (first.route !== "keep" || first.droppedAt !== "L0") {
+			if (first.route === "merge" || first.route === "undecided") kept.push({
+				candidate: withGate(candidate, first.verdicts, false),
+				verdicts: first.verdicts,
+				auditOverride: false
+			});
+			else dropped.push({
+				candidate,
+				verdicts: first.verdicts,
+				auditOverride: false
+			});
+			continue;
+		}
+		if (!selectedForAudit(pairKey(candidate.a, candidate.b), options.runSeed, options.auditRate ?? .1)) {
+			dropped.push({
+				candidate,
+				verdicts: first.verdicts,
+				auditOverride: false
+			});
+			continue;
+		}
+		const audit = await runLadder({
+			level: "L0",
+			startLevel: "L2",
+			candidate,
+			facts: options.facts,
+			model: options.model,
+			modelName: options.modelName,
+			signal: options.signal,
+			...options.cache === void 0 ? {} : { cache: options.cache }
+		});
+		calls += audit.calls;
+		if (audit.route === "merge" || audit.route === "undecided") {
+			const all = [...first.verdicts, ...audit.verdicts];
+			kept.push({
+				candidate: withGate(candidate, all, true),
+				verdicts: all,
+				auditOverride: true
+			});
+		} else if (audit.route === "error") errors.push({
+			candidate,
+			message: audit.error ?? "audit gate error"
+		});
+		else dropped.push({
+			candidate,
+			verdicts: [...first.verdicts, ...audit.verdicts],
+			auditOverride: true
+		});
+	}
+	return {
+		kept,
+		dropped,
+		errors,
+		calls
+	};
+}
+//#endregion
+//#region lib/types/screening-port.js
+/**
+* The real screening port: lexical floor + optional C3 proposal + optional L0–L2 gate.
+* Each stage is independently testable; this file only composes their frozen contracts.
+*/
+async function buildScreeningCandidates(options) {
+	const lexical = lexicalCandidates(options.cards, options.lexical);
+	const merged = /* @__PURE__ */ new Map();
+	for (const candidate of lexical.candidates) merged.set(pairKey(candidate.a, candidate.b), candidate);
+	const degraded = [];
+	let proposed = 0;
+	let shards = 0;
+	if (options.propose !== void 0) {
+		const proposal = await proposePairs(options.cards, options.propose.model, {
+			signal: options.signal,
+			...options.propose.shardSize === void 0 ? {} : { shardSize: options.propose.shardSize },
+			...options.propose.maxPairs === void 0 ? {} : { maxPairs: options.propose.maxPairs }
+		});
+		proposed = proposal.candidates.length;
+		shards = proposal.shards;
+		degraded.push(...proposal.degraded);
+		for (const candidate of proposal.candidates) {
+			const key = pairKey(candidate.a, candidate.b);
+			const existing = merged.get(key);
+			if (existing === void 0) {
+				merged.set(key, candidate);
+				continue;
+			}
+			const arms = [...new Set([...existing.arms ?? [], ...candidate.arms ?? []])];
+			merged.set(key, {
+				...existing,
+				...candidate.reason === void 0 || existing.reason !== void 0 ? {} : { reason: candidate.reason },
+				...arms.length === 0 ? {} : { arms }
+			});
+		}
+	}
+	let candidates = [...merged.values()].sort((left, right) => (right.score ?? 0) - (left.score ?? 0) || left.a.localeCompare(right.a) || left.b.localeCompare(right.b));
+	let kept = candidates.length;
+	let dropped = 0;
+	let gateCalls = 0;
+	let gateErrors = 0;
+	if (options.gate !== void 0) {
+		const facts = options.cards.map((card) => ({
+			name: card.name,
+			description: card.description,
+			body: card.body
+		}));
+		const filtered = await filterCandidates(candidates, {
+			facts,
+			model: options.gate.model,
+			modelName: options.gate.modelName,
+			signal: options.signal,
+			runSeed: options.gate.runSeed,
+			...options.gate.cache === void 0 ? {} : { cache: options.gate.cache },
+			...options.gate.auditRate === void 0 ? {} : { auditRate: options.gate.auditRate }
+		});
+		candidates = filtered.kept.map((decision) => decision.candidate);
+		kept = filtered.kept.length;
+		dropped = filtered.dropped.length;
+		gateCalls = filtered.calls;
+		gateErrors = filtered.errors.length;
+		for (const error of filtered.errors) degraded.push("gate error: " + error.candidate.a + " + " + error.candidate.b + ": " + error.message);
+	}
+	return {
+		candidates,
+		stats: {
+			lexical: lexical.candidates.length,
+			proposed,
+			candidates: merged.size,
+			kept,
+			dropped,
+			gateCalls,
+			gateErrors,
+			shards
+		},
+		degraded
+	};
+}
+/** Build the run-scoped screening function; the run id seeds the 10% audit. */
+function createScreeningForRun(options) {
+	const gate = options.gate === void 0 ? void 0 : {
+		...options.gate,
+		runSeed: options.runSeed
+	};
+	return async (signal) => (await buildScreeningCandidates({
+		cards: options.cards,
+		signal,
+		...options.lexical === void 0 ? {} : { lexical: options.lexical },
+		...options.propose === void 0 ? {} : { propose: options.propose },
+		...gate === void 0 ? {} : { gate }
+	})).candidates;
+}
+//#endregion
+//#region lib/types/stage-tool-registry.js
+var StageToolRegistry = class {
+	bindings = /* @__PURE__ */ new Map();
+	bind(childId, context) {
+		this.bindings.set(childId, context);
+	}
+	unbind(childId) {
+		this.bindings.delete(childId);
+	}
+	clear() {
+		this.bindings.clear();
+	}
+	resolve(exec) {
+		const childId = childIdOf(exec);
+		return childId === void 0 ? void 0 : this.bindings.get(childId);
+	}
+};
+function childIdOf(exec) {
+	if (typeof exec !== "object" || exec === null) return void 0;
+	const agent = exec.agent;
+	if (typeof agent !== "object" || agent === null) return void 0;
+	const session = agent.session;
+	if (typeof session === "object" && session !== null) {
+		const id = session.id;
+		if (typeof id === "string") return id;
+	}
+	const sessionId = agent.sessionId;
+	return typeof sessionId === "string" ? sessionId : void 0;
+}
+//#endregion
+//#region lib/types/staging-files.js
+/**
+* Staged file operations used by the authoring tool.
+*
+* The child never receives a general filesystem write. Every path is resolved under
+* <run>/sources/<source>/ or <run>/merged/<target>/ and must stay there; the staging
+* manifest supplies the target name. Reads are three-state, writes are atomic at the
+* file level, and copy only goes sources -> merged.
+*/
+function safeRelative(path) {
+	if (path === "" || path.startsWith("/") || path.startsWith("\\") || path.includes("\0")) return false;
+	return path.replace(/\\/g, "/").split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function areaRoot(home, runId, target, area, source) {
+	const root = stagingRoot(home, runId);
+	if (area === "merged") return join(root, "merged", target);
+	if (source === void 0 || source === "") return null;
+	return join(root, "sources", source);
+}
+async function writeStagedFile(io, home, runId, path, content, source) {
+	if (!safeRelative(path)) return {
+		ok: false,
+		message: "unsafe staged path: " + path
+	};
+	const staging = await readStaging(io, home, runId);
+	if (!isPresent(staging)) return {
+		ok: false,
+		message: "staging is not present for run " + runId
+	};
+	const root = areaRoot(home, runId, staging.value.manifest.target, "merged", source);
+	if (root === null) return {
+		ok: false,
+		message: "staged write requires merged area"
+	};
+	const target = join(root, ...path.split("/"));
+	try {
+		await io.writeText(target, content);
+		return {
+			ok: true,
+			path
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: "staged write failed: " + (error instanceof Error ? error.message : String(error))
+		};
+	}
+}
+async function readStagedFile(io, home, runId, path, area, source) {
+	if (!safeRelative(path)) return probeUnknown("unsafe staged path: " + path);
+	const staging = await readStaging(io, home, runId);
+	if (!isPresent(staging)) return staging.kind === "absent" ? { kind: "absent" } : probeUnknown(staging.reason);
+	const root = areaRoot(home, runId, staging.value.manifest.target, area, source);
+	if (root === null) return probeUnknown("missing source name for sources area");
+	try {
+		const value = await io.readText(join(root, ...path.split("/")));
+		return value === null ? { kind: "absent" } : {
+			kind: "present",
+			value
+		};
+	} catch (error) {
+		return probeUnknown("staged read failed: " + (error instanceof Error ? error.message : String(error)));
+	}
+}
+async function listStagedFiles(io, home, runId, area, path = "", source) {
+	if (path !== "" && !safeRelative(path)) return probeUnknown("unsafe staged path: " + path);
+	const staging = await readStaging(io, home, runId);
+	if (!isPresent(staging)) return staging.kind === "absent" ? { kind: "absent" } : probeUnknown(staging.reason);
+	const root = areaRoot(home, runId, staging.value.manifest.target, area, source);
+	if (root === null) return probeUnknown("missing source name for sources area");
+	try {
+		return {
+			kind: "present",
+			value: [...await io.list(join(root, ...path.split("/").filter(Boolean)))].sort()
+		};
+	} catch (error) {
+		return probeUnknown("staged list failed: " + (error instanceof Error ? error.message : String(error)));
+	}
+}
+/** Copy one source file into the merged target; the only cross-area operation allowed. */
+async function copyStagedFile(io, home, runId, source, from, to) {
+	if (!safeRelative(from) || !safeRelative(to)) return {
+		ok: false,
+		message: "unsafe staged copy path"
+	};
+	const sourceFile = await readStagedFile(io, home, runId, from, "sources", source);
+	if (!isPresent(sourceFile)) return {
+		ok: false,
+		message: "source file is not readable: " + from
+	};
+	return await writeStagedFile(io, home, runId, to, sourceFile.value);
+}
+//#endregion
+//#region lib/types/stage-tool.js
+async function applyStageTool(io, home, ctx, op) {
+	if (ctx.childId !== ctx.expectedChildId) return {
+		ok: false,
+		code: "not-merge-child",
+		message: "merge_stage is only available to the bound merge child"
+	};
+	if (op.op === "write" || op.op === "copy") {
+		if (ctx.phase !== "author") return {
+			ok: false,
+			code: "phase",
+			message: "merge_stage write/copy is only allowed in the author phase"
+		};
+	}
+	if (op.op === "list") return probeResult(await listStagedFiles(io, home, ctx.runId, op.area, op.path ?? "", op.source), "list");
+	if (op.op === "read") return probeResult(await readStagedFile(io, home, ctx.runId, op.path, op.area, op.source), "read");
+	if (op.op === "write") {
+		const result = await writeStagedFile(io, home, ctx.runId, op.path, op.content);
+		return result.ok ? {
+			ok: true,
+			value: { path: result.path }
+		} : {
+			ok: false,
+			code: "io",
+			message: result.message
+		};
+	}
+	const result = await copyStagedFile(io, home, ctx.runId, op.source, op.from, op.to);
+	return result.ok ? {
+		ok: true,
+		value: { path: result.path }
+	} : {
+		ok: false,
+		code: "io",
+		message: result.message
+	};
+}
+function probeResult(probe, what) {
+	if (probe.kind === "present") return {
+		ok: true,
+		value: probe.value
+	};
+	if (probe.kind === "absent") return {
+		ok: false,
+		code: "not-found",
+		message: what + ": not found"
+	};
+	return {
+		ok: false,
+		code: "io",
+		message: what + ": " + probe.reason
+	};
+}
+//#endregion
+//#region lib/types/merge-tool.js
+const MERGE_STAGE_TOOL_NAME = "merge_stage";
+function shapeError(message) {
+	return {
+		ok: false,
+		code: "bad-path",
+		message
+	};
+}
+function operation(args) {
+	const op = args.op;
+	if (op === "list") {
+		const area = args.area;
+		if (area !== "sources" && area !== "merged") return shapeError("list.area must be sources or merged");
+		return {
+			op,
+			area,
+			...typeof args.path === "string" ? { path: args.path } : {},
+			...typeof args.source === "string" ? { source: args.source } : {}
+		};
+	}
+	if (op === "read") {
+		const area = args.area;
+		if (area !== "sources" && area !== "merged") return shapeError("read.area must be sources or merged");
+		if (typeof args.path !== "string" || args.path === "") return shapeError("read.path is required");
+		return {
+			op,
+			area,
+			path: args.path,
+			...typeof args.source === "string" ? { source: args.source } : {}
+		};
+	}
+	if (op === "write") {
+		if (typeof args.path !== "string" || args.path === "") return shapeError("write.path is required");
+		if (typeof args.content !== "string") return shapeError("write.content must be a string");
+		return {
+			op,
+			path: args.path,
+			content: args.content
+		};
+	}
+	if (op === "copy") {
+		if (typeof args.source !== "string" || typeof args.from !== "string" || typeof args.to !== "string") return shapeError("copy requires source/from/to");
+		return {
+			op,
+			source: args.source,
+			from: args.from,
+			to: args.to
+		};
+	}
+	return shapeError("op must be list/read/write/copy");
+}
+function createMergeStageTool(io, home, context) {
+	return {
+		name: MERGE_STAGE_TOOL_NAME,
+		description: "Read source copies and write the merged skill into the staging tree. Write/copy are only allowed in the author phase.",
+		parameters: {
+			type: "object",
+			properties: {
+				op: {
+					type: "string",
+					enum: [
+						"list",
+						"read",
+						"write",
+						"copy"
+					]
+				},
+				area: {
+					type: "string",
+					enum: ["sources", "merged"]
+				},
+				path: { type: "string" },
+				source: { type: "string" },
+				content: { type: "string" },
+				from: { type: "string" },
+				to: { type: "string" }
+			},
+			required: ["op"],
+			additionalProperties: false
+		},
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: value
+			}]
+		},
+		async execute(args, exec) {
+			const op = operation(args);
+			if ("ok" in op) return JSON.stringify(op);
+			const ctx = context(exec);
+			if (ctx === void 0) return JSON.stringify({
+				ok: false,
+				code: "not-merge-child",
+				message: "merge_stage is only available to an active merge child"
+			});
+			return JSON.stringify(await applyStageTool(io, home, ctx, op));
+		}
+	};
+}
+//#endregion
+//#region lib/types/supersede.js
+function mergeRunIdsToSupersede(runs) {
+	return runs.filter((run) => run.kind === "merge" && run.supersededAt === void 0).map((run) => run.id);
+}
+async function supersedeMergeRuns(registry) {
+	const shared = registry.supersedeKind;
+	if (typeof shared === "function") return await shared.call(registry, "merge");
+	const ids = mergeRunIdsToSupersede(registry.runs());
+	if (ids.length === 0) return 0;
+	await registry.supersede(ids);
+	return ids.length;
+}
+//#endregion
+//#region lib/types/pair-command.js
+async function runPairCommand(options) {
+	return await runScanCommand({
+		io: options.io,
+		home: options.home,
+		registry: options.registry,
+		approval: options.approval,
+		platformWrite: options.platformWrite,
+		now: options.now,
+		ports: {
+			...options.ports,
+			screening: () => Promise.resolve([{
+				a: options.a,
+				b: options.b
+			}])
+		},
+		...options.timeoutMinutes === void 0 ? {} : { timeoutMinutes: options.timeoutMinutes }
+	});
+}
+//#endregion
+//#region lib/types/index.js
+/** E3 knobs are volatile (user layer); the E2 pair timeout is deployment-only. */
+const Config = z.object({
+	mergeApproval: z.boolean().default(false).volatile(),
+	mergeSkippedTtlDays: z.number().min(0).default(0).volatile(),
+	mergeRunTimeoutMinutes: z.number().min(0).default(0).volatile(),
+	mergePairTimeoutMinutes: z.number().min(1).default(15)
+});
+/** Suppress the platform auto form; the registry renders the merge card instead. */
+function configureMergePresentation(ctx) {
+	ctx.inject(["settings"], (scope) => {
+		const settings = scope.settings;
+		if (typeof settings?.configure !== "function") return;
+		const disposer = settings.configure({ auto: false }, ctx.fiber);
+		if (typeof disposer === "function") scope.effect(() => disposer, "evolution-merge: settings presentation");
+	});
+}
+const inject = [];
+function apply(ctx, rawConfig = {}) {
+	configureMergePresentation(ctx);
+	const params = resolveMergeParams(rawConfig);
+	let source;
+	registerHostRoutes(ctx, (audit) => makeMergeRoutes({ getSource: () => source }, audit));
+	ctx.inject(["commands", "evolutionIo"], (scope) => {
+		const registry = scope.get("evolutionIo");
+		if (registry === void 0) return;
+		const io = evolutionIoAdapter(() => registry.provider());
+		const home = evolutionHome();
+		const runs = newRunRegistry({
+			io,
+			home,
+			warn: (message) => {
+				ctx.logger.warn(message);
+			}
+		});
+		runs.load();
+		ctx.effect(() => {
+			const host = ctx;
+			if (typeof host.on !== "function") return () => {};
+			return host.on("evolution/skill-mutated", (event) => {
+				if (event.action === "restore") supersedeMergeRuns(runs);
+			});
+		}, "evolution-merge: restore supersede");
+		const policySnapshot = ctx.get("evolutionPolicy");
+		const skills = newSkillLibrary({
+			io,
+			ctx,
+			authority: authorityFrom({ origin: "subagent" }),
+			limits: {
+				...DEFAULT_SKILL_LIMITS,
+				...policyStageLimits(policySnapshot?.get?.())
+			}
+		});
+		const channel = subagentChannelAdapter(createSubagentChannel(ctx));
+		const stage = new StageToolRegistry();
+		const llm = ctx.get("llm");
+		const defaultModel = ctx.get("agentDefaultModel");
+		const modelPort = llm === void 0 || defaultModel === void 0 ? void 0 : createModelPort(llm, () => defaultModel.currentSelection());
+		source = {
+			rows() {
+				return loadMergeState(io, home).then((loaded) => loaded.state.rows);
+			},
+			run(id) {
+				return Promise.resolve(runs.runs().find((record) => record.id === id));
+			},
+			runs() {
+				return Promise.resolve(runs.runs());
+			},
+			commands() {
+				return [
+					"merge scan",
+					"merge doctor",
+					"merge status",
+					"merge pending",
+					"merge skipped",
+					"merge report",
+					"merge runs",
+					"merge cancel"
+				];
+			}
+		};
+		const commands = scope.get("commands");
+		if (commands === void 0) return;
+		const command = createMergeCommand(createMergeRuntime({
+			io,
+			home,
+			registry: runs,
+			skills,
+			now: () => Date.now(),
+			params,
+			platformWrite: true,
+			channel,
+			parent: void 0,
+			allow: ["merge_stage"],
+			timeoutMinutes: params.mergeRunTimeoutMinutes,
+			async cards(signal) {
+				const listed = await skills.list({ withContent: true });
+				if (signal.aborted) return [];
+				return listed.map((item) => ({
+					name: item.name,
+					description: item.description,
+					body: item.content ?? ""
+				}));
+			},
+			screening(cards) {
+				return Promise.resolve(lexicalCandidates(cards).candidates);
+			},
+			...modelPort === void 0 ? {} : { async screeningForRun(cards, runId, signal) {
+				const cache = await loadGateCache(io, home);
+				const candidates = await createScreeningForRun({
+					cards,
+					runSeed: runId,
+					propose: { model: modelPort },
+					gate: {
+						model: modelPort,
+						modelName: defaultModel?.currentSelection().model ?? "",
+						runSeed: runId,
+						cache: cache.cache
+					}
+				})(signal);
+				await saveGateCache(io, home, cache.cache).catch(() => {});
+				return candidates;
+			} },
+			stage: {
+				bind: (context) => {
+					stage.bind(context.childId, context);
+				},
+				unbind: (childId) => {
+					stage.unbind(childId);
+				}
+			}
+		}));
+		scope.effect(() => commands.register(command), "evolution-merge: command");
+		ctx.inject(["tools"], (toolScope) => {
+			const tools = toolScope.get("tools");
+			if (tools === void 0) return;
+			const tool = createMergeStageTool(io, home, (exec) => stage.resolve(exec));
+			toolScope.effect(() => tools.register(tool), "evolution-merge: merge_stage");
+		});
+		scope.effect(() => () => {
+			runs.cancelAll();
+		}, "evolution-merge: runs");
+	});
+}
+//#endregion
+export { Config, GATE_CACHE_VERSION, GateCache, MERGE_DOCTOR_SCHEMA_VERSION, MERGE_PAIR_STATES, MERGE_PARAM_DEFAULTS, MERGE_PROMPT_VERSION, MERGE_QUEUES, MERGE_ROUTES, MERGE_STAGE_TOOL_NAME, MERGE_STATE_VERSION, STAGING_SCHEMA_VERSION, StageToolRegistry, apply, applyStageTool, approvePending, assembleStagedCommit, buildCommitPlan, buildMergeView, buildRound1Prompt, buildRound2Prompt, buildScreeningCandidates, canRetry, commitReceiptPath, commitStagedRun, committedPairs, configureMergePresentation, copyStagedFile, countRows, createChannelScanPorts, createMergeCommand, createMergeRuntime, createMergeStageTool, createModelPort, createNewChildRound2, createReadOnlyMergeService, createScreeningForRun, createStaging, dropRow, emptyMergeState, filterCandidates, formatQueue, formatStatus, gateCacheKey, gateCachePath, handleReadOnlyMergeCommand, hasBlockingFinding, hasGateCache, inject, isSkippedPair, lexicalCandidates, listStagedFiles, loadGateCache, loadMergeState, makeMergeRoutes, mergeCommandHelp, mergeDoctor, mergeReportDigestPath, mergeReportPath, mergeRunIdsToSupersede, mergeStatePath, mergeUsage, moveRow, mutateMergeState, nameEntropy, pageQueue, pairKey, parseDecision, parseMergeCommand, parseVerdict, prefilter, proposePairs, queueOf, readCommitReceipt, readMergeReport, readStagedFile, readStagedTree, readStaging, recordRound2Outcome, rejectPending, resolveMergeParams, resolveTargetName, rewriteFrontmatterName, rowIdOf, rowsOf, runApproveCommand, runAuthoring, runLadder, runNewChildAuthoring, runPairCommand, runResumeCommand, runRound1OverChannel, runScan, runScanCommand, saveGateCache, selectedForAudit, skillLibraryPort, skillLibraryUndoPort, skippedPairKeys, stageOf, stagingRoot, subagentChannelAdapter, supersedeMergeRuns, toRowView, toRunFact, transition, undoMergeReceipt, upsertRow, validateStagedTree, withMergeRun, writeCommitReceipt, writeMergeReport, writeStagedFile };