@lmzhen/dsh-evolution-merge 0.0.0 → 0.29.0

package/lib/index.js

@@ -0,0 +1,3814 @@
+import { join } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { screen, selectCandidates } from "@lmzhen/dsh-evolution-merge-engine";
+import { DEFAULT_SKILL_LIMITS, authorityFrom, contentHash, createSubagentChannel, evolutionHome, evolutionIoAdapter, executeUnitUndo, isPresent, newRunRegistry, newSkillLibrary, parseFrontmatter, planUnitUndoAcross, policyStageLimits, probeAbsent, probeList, probePresent, probeText, probeUnknown, scanContentThreats, supportRefs, transactIo, validateFrontmatter, validateSupportPath } from "@lmzhen/dsh-evolution-core";
+import { HOST_ROUTES, json, methodNotAllowed, registerHostRoutes } from "@lmzhen/dsh-evolution-core/http-routes";
+import { createHash } from "node:crypto";
+//#region lib/types/adapters/engine-screen.js
+/**
+* G3 screen adapter: cards -> corpus snapshot -> EnginePort.screen.
+*
+* The vendor engine reads a corpus from disk; host cards are content. This module
+* writes only SKILL.md support-free snapshots under the run directory. It does not
+* decide candidates: the Q02 selector is injected so engine/report-map stays the
+* single source of that policy.
+*/
+function safeName(name, index) {
+	const cleaned = name.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+	return (cleaned === "" ? "skill-" + String(index) : cleaned) + "__" + String(index);
+}
+/** Write the exact card bodies as a support-free corpus snapshot and return its root. */
+async function snapshotCards(io, home, runId, cards) {
+	const root = join(home, "merge", "runs", runId, "corpus");
+	for (let index = 0; index < cards.length; index += 1) {
+		const card = cards[index];
+		if (card === void 0) continue;
+		await io.writeText(join(root, safeName(card.name, index), "SKILL.md"), card.body);
+	}
+	return root;
+}
+function createEngineScreening(deps) {
+	return async (cards, runId, signal) => {
+		const corpusDir = await snapshotCards(deps.io, deps.home, runId, cards);
+		const outDir = join(deps.home, "merge", "runs", runId, "engine");
+		const result = await deps.engine.screen({
+			corpusDir,
+			outDir,
+			...deps.cfg === void 0 ? {} : { cfg: deps.cfg },
+			...deps.runner === void 0 ? {} : { runner: deps.runner },
+			signal
+		});
+		if (!result.ok) throw new Error("engine screen failed: " + result.error.code + (result.error.stage === void 0 ? "" : " @" + result.error.stage) + (result.error.detail === void 0 ? "" : ": " + result.error.detail));
+		const selection = deps.select(result.report);
+		if (deps.onSelection !== void 0) await deps.onSelection(selection, runId);
+		return Object.assign(selection.candidates.slice(), selection.candidatePairs === void 0 ? {} : { candidatePairs: selection.candidatePairs });
+	};
+}
+//#endregion
+//#region lib/types/adapters/model-runner.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 createEngineRunner(llm, route) {
+	return async (prompt) => {
+		const selection = route();
+		let text = "";
+		if (llm.stream !== void 0) {
+			for await (const chunk of llm.stream({
+				provider: selection.provider,
+				model: selection.model,
+				messages: [{
+					role: "user",
+					content: [{
+						type: "text",
+						text: prompt
+					}]
+				}],
+				temperature: 0
+			})) 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,
+			temperature: 0
+		});
+		for await (const chunk of call.stream({
+			...call.config,
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: prompt
+				}]
+			}]
+		})) text = append(chunk, text);
+		return text;
+	};
+}
+//#endregion
+//#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. */
+const MERGE_MAX_ATTEMPTS = 3;
+function canRetry(record) {
+	if (record.state === "skipped") return false;
+	if ((record.attempts ?? 0) >= 3) 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/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 },
+		...row.stagingRef === void 0 ? {} : { stagingRef: row.stagingRef },
+		...row.stagingExpiresAt === void 0 ? {} : { stagingExpiresAt: row.stagingExpiresAt }
+	};
+}
+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 (event.type === "gate-keep") {
+		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: "skipped",
+				queue: "skipped",
+				origin: "agent",
+				createdAt: event.at,
+				updatedAt: event.at
+			}
+		};
+	}
+	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 },
+				...event.stagingRef === void 0 ? {} : { stagingRef: event.stagingRef },
+				...event.stagingExpiresAt === void 0 ? {} : { stagingExpiresAt: event.stagingExpiresAt }
+			}) : next(current, event.at, "fuse", {
+				...event.decision === void 0 ? {} : { decision: event.decision },
+				...event.stagingRef === void 0 ? {} : { stagingRef: event.stagingRef },
+				...event.stagingExpiresAt === void 0 ? {} : { stagingExpiresAt: event.stagingExpiresAt }
+			});
+		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/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,
+		createdAt: row.createdAt,
+		...row.decision?.target === void 0 ? {} : { target: row.decision.target },
+		...row.decision?.confidence === void 0 ? {} : { confidence: row.decision.confidence },
+		...row.failure === void 0 ? {} : { failure: {
+			stage: row.failure.stage,
+			code: row.failure.code,
+			message: row.failure.message,
+			retryable: row.failure.retryable
+		} },
+		...row.attempts === void 0 ? {} : { attempts: row.attempts },
+		...row.origin === void 0 ? {} : { origin: row.origin },
+		...row.stagingExpiresAt === void 0 ? {} : { stagingExpiresAt: row.stagingExpiresAt },
+		actions: row.state === "pending" ? ["/evolution merge approve " + row.id, "/evolution merge reject " + row.id] : row.state === "skipped" ? ["/evolution merge skipped --restore " + row.id] : ["/evolution merge resume " + row.id]
+	};
+}
+function buildMergeView(rows, commands, latestRun, approval) {
+	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,
+		...latestRun === void 0 ? {} : { latestRun },
+		...approval === void 0 ? {} : { approval }
+	};
+}
+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();
+				const latestMerge = (await source.runs(void 0, 20)).find((run) => run.kind === "merge");
+				return json(200, {
+					ok: true,
+					data: buildMergeView(await source.rows(), source.commands(), latestMerge === void 0 ? void 0 : toRunFact(latestMerge), source.approval?.())
+				});
+			}
+		},
+		{
+			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: /evolution 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: /evolution 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
+		};
+	} };
+}
+async function runMergeCommand(service, rawInput, invocation) {
+	const tokens = rawInput.trim().split(/\s+/).filter(Boolean);
+	if (tokens[0] === "merge" || tokens[0] === "/merge" || tokens[0] === "evolution" || tokens[0] === "/evolution") tokens.shift();
+	if (tokens[0] === "merge") tokens.shift();
+	const parsed = parseMergeCommand(tokens);
+	if (!parsed.ok) return {
+		ok: false,
+		text: parsed.message
+	};
+	if (parsed.help === true) return {
+		ok: true,
+		text: mergeUsage()
+	};
+	try {
+		return await service.execute(parsed.command, invocation?.agent === void 0 ? {} : { parent: invocation.agent });
+	} catch (error) {
+		return {
+			ok: false,
+			text: "merge 命令失败：" + (error instanceof Error ? error.message : String(error)) + "\n运行 /evolution merge status 查看状态。"
+		};
+	}
+}
+function createMergeCommand(service) {
+	return {
+		name: "merge",
+		description: "技能自动合并：扫描、待批准、重跑、报告与 undo（兼容别名；请用 /evolution merge）",
+		input: { hint: mergeUsage() },
+		async handler(invocation) {
+			const result = await runMergeCommand(service, invocation.rawInput, invocation);
+			return {
+				kind: result.ok ? "success" : "error",
+				text: result.text
+			};
+		}
+	};
+}
+//#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/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 candidates = await options.ports.screening(options.signal);
+	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 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,
+				...round1.stagingRef === void 0 ? {} : { stagingRef: round1.stagingRef },
+				...round1.stagingExpiresAt === void 0 ? {} : { stagingExpiresAt: round1.stagingExpiresAt },
+				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,
+			...round1.stagingRef === void 0 ? {} : { stagingRef: round1.stagingRef },
+			...round1.stagingExpiresAt === void 0 ? {} : { stagingExpiresAt: round1.stagingExpiresAt },
+			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.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 stageKeyOf(runId, pairKey) {
+	return runId + "/pairs/" + createHash("sha256").update(pairKey).digest("hex").slice(0, 16);
+}
+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,
+			...input.mode === void 0 ? {} : { mode: input.mode },
+			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)));
+	}
+}
+async function ensureStaging(io, home, input) {
+	const existing = await readStaging(io, home, input.runId);
+	if (existing.kind === "present") return {
+		ok: true,
+		path: stagingRoot(home, input.runId),
+		manifest: existing.value.manifest
+	};
+	return createStaging(io, home, input);
+}
+async function setStagingTarget(io, home, stageKey, target, mode) {
+	const view = await readStaging(io, home, stageKey);
+	if (view.kind !== "present") return false;
+	const manifest = Object.assign({}, view.value.manifest, { target }, mode === void 0 ? {} : { mode });
+	await io.writeText(join(stagingRoot(home, stageKey), "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+	return true;
+}
+async function dropStaging(io, home, stageKey) {
+	await io.remove(stagingRoot(home, stageKey));
+}
+//#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");
+}
+function durableReceiptDir(home, parentRunId) {
+	return join(home, "merge", "receipts", parentRunId);
+}
+function durableReceiptPath(home, parentRunId, stageKey) {
+	const leaf = stageKey.split("/").pop() ?? stageKey;
+	return join(durableReceiptDir(home, parentRunId), leaf + ".json");
+}
+function parseReceipt(raw) {
+	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;
+	}
+}
+async function writeCommitReceipt(io, home, receipt) {
+	const path = commitReceiptPath(home, receipt.runId);
+	await io.writeText(path, JSON.stringify(receipt, null, 2) + "\n");
+	const parent = receipt.parentRunId ?? receipt.runId.split("/pairs/")[0] ?? receipt.runId;
+	await io.writeText(durableReceiptPath(home, parent, receipt.runId), JSON.stringify({
+		...receipt,
+		parentRunId: parent
+	}, null, 2) + "\n");
+	return path;
+}
+async function readCommitReceipt(io, home, runId, target) {
+	const direct = parseReceipt(await io.readText(commitReceiptPath(home, runId)));
+	if (direct !== null && (target === void 0 || direct.target === target)) return direct;
+	try {
+		const names = await io.list(durableReceiptDir(home, runId));
+		for (const name of names.sort()) {
+			const receipt = parseReceipt(await io.readText(join(durableReceiptDir(home, runId), name)));
+			if (receipt !== null && (target === void 0 || receipt.target === target)) return receipt;
+		}
+	} 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/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, configuredRoot) {
+	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 modelRoot = configuredRoot !== void 0 && configuredRoot !== "" ? configuredRoot : process.env.SKILL_MERGE_MODELS_ROOT;
+	if (modelRoot === void 0 || modelRoot === "") rows.push({
+		key: "models",
+		label: "合并模型",
+		status: "warn",
+		detail: "未设置 SKILL_MERGE_MODELS_ROOT；合并扫描会 fail loud"
+	});
+	else {
+		const int8 = join(modelRoot, "potion-multilingual-128M-int8");
+		const pca = join(modelRoot, "potion-multilingual-128M-pca64-int8");
+		const ok = await io.exists(int8) && await io.exists(pca);
+		rows.push({
+			key: "models",
+			label: "合并模型",
+			status: ok ? "ok" : "warn",
+			detail: ok ? modelRoot : "缺少 int8/pca64：" + modelRoot
+		});
+	}
+	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-b/v1";
+const STANDBY_PROMPT = "You are a merge worker. Wait for instructions.";
+function sourcePath(name) {
+	return "sources/" + name;
+}
+function mergedPath(target) {
+	return "merged/" + target;
+}
+function wireDecision(decision) {
+	return {
+		shouldMerge: decision.shouldMerge,
+		mode: decision.mode,
+		target: decision.target,
+		sources: decision.sources,
+		rationale: decision.rationale,
+		confidence: decision.confidence,
+		a_summary: decision.aSummary,
+		b_summary: decision.bSummary
+	};
+}
+function buildRound1Prompt(candidate, cards) {
+	return [
+		"你是技能合并决策 agent。第 1 轮只做判断，不要写文件、不要修改任何源目录。",
+		"",
+		"在当前工作目录下用 merge_stage 的 list/read 完整阅读两个源技能：",
+		"- A: " + sourcePath(candidate.a) + "（name=" + candidate.a + "）",
+		"- B: " + sourcePath(candidate.b) + "（name=" + candidate.b + "）",
+		"包含 SKILL.md 与 references/templates/scripts 等支撑文件。",
+		"",
+		"判断规则：",
+		"1) 两者是否语义等价/互补到值得合并，而不是词面相似；",
+		"2) 合并后是否更容易发现和使用，而不是变成更大的巨技能；",
+		"3) 若合并会破坏触发面/生命周期/可发现性，应输出 keep。",
+		"",
+		"只输出一个 JSON（不要 markdown 围栏）：",
+		"{\"should_merge\":true|false,\"mode\":\"merge-into-existing|create-umbrella|keep\",\"target\":\"kebab-case\",\"sources\":[\"源技能名\"],\"rationale\":\"<=150字\",\"confidence\":0.0,\"a_summary\":\"A 的一句话摘要\",\"b_summary\":\"B 的一句话摘要\"}"
+	].join("\n");
+}
+function buildRound2Prompt(row, decision, mode = "continue") {
+	const decisionJson = JSON.stringify(wireDecision(decision));
+	const head = [
+		"现在执行第 2 轮：把两个技能融合成一个完整、可用的技能，直接在当前工作目录的 merged/ 下写文件。",
+		"不要修改 " + sourcePath(row.a) + " 或 " + sourcePath(row.b) + "（只读源副本）；不要访问工作目录以外的路径。",
+		""
+	];
+	const body = [
+		"决策结果：" + decisionJson,
+		"目标技能名：" + decision.target,
+		"",
+		"工作方式：",
+		"- 用 merge_stage 的 list/read/write/copy 创建 " + mergedPath(decision.target) + "/SKILL.md 与需要的 references/templates/scripts；",
+		"- 可以复制源文件作为草稿基础，然后逐段修改；可以多轮读写；",
+		"- 保留两源独特内容，不编造事实，不留下 TODO/占位符；",
+		"- SKILL.md 以合法 YAML frontmatter 开头，name 等于目标名，description 不超过 60 字符；",
+		"- 正文与支撑文件的引用必须成对，路径只允许 references/templates/scripts/assets 下的相对路径。",
+		"",
+		"完成后只输出一个 JSON（不要 markdown 围栏）：",
+		"{\"target\":\"" + decision.target + "\",\"files\":[\"SKILL.md\",\"references/...\"],\"changelog\":[\"一条变更\"],\"notes\":\"可选的一句话\"}"
+	];
+	return (mode === "fresh" ? [
+		"基于已持久化的 decision。",
+		...head,
+		...body
+	] : [...head, ...body]).join("\n");
+}
+function buildStandbyPrompt() {
+	return STANDBY_PROMPT;
+}
+//#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: STANDBY_PROMPT,
+		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: "standby did not complete",
+					retryable: true,
+					retryFrom: "agent1"
+				}
+			},
+			dispose
+		};
+	}
+	try {
+		options.onChildOpened?.(opened.childId);
+	} catch (error) {
+		await dispose();
+		return {
+			outcome: {
+				kind: "failed",
+				failure: {
+					stage: "decide",
+					code: "child-bind",
+					message: String(error),
+					retryable: true,
+					retryFrom: "agent1"
+				}
+			},
+			dispose
+		};
+	}
+	const round1 = await options.channel.continueTurn(opened.childId, buildRound1Prompt(candidate, options.cards), {
+		timeoutMs: options.timeoutMs,
+		signal
+	});
+	if (round1.kind !== "ok") {
+		await dispose();
+		return {
+			outcome: {
+				kind: "failed",
+				failure: {
+					stage: "decide",
+					code: round1.kind,
+					message: round1.kind === "unavailable" ? round1.reason : "round1 aborted",
+					retryable: round1.kind !== "aborted",
+					retryFrom: round1.kind === "aborted" ? "none" : "agent1"
+				}
+			},
+			dispose
+		};
+	}
+	if (round1.turn.stopReason !== "completed") {
+		await dispose();
+		return {
+			outcome: {
+				kind: "failed",
+				failure: {
+					stage: "decide",
+					code: round1.turn.stopReason,
+					message: "round1 did not complete",
+					retryable: true,
+					retryFrom: "agent1"
+				}
+			},
+			dispose
+		};
+	}
+	const parsed = parseDecision(round1.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"
+	};
+	const sources = input.sourceBodies.filter((source) => source.name !== input.target);
+	if (sources.length === 0) return {
+		ok: false,
+		message: "a merge needs at least one source different from the target"
+	};
+	const body = rewriteFrontmatterName(input.mergedBody, input.target);
+	return {
+		ok: true,
+		plan: {
+			target: input.target,
+			targetExists: !input.create,
+			sources: sources.map((source) => source.name),
+			body,
+			supportFiles: input.mergedFiles,
+			expectedTargetBody: input.targetCurrent,
+			expectedSourceBodies: sources,
+			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 requested = staging.value.manifest.target;
+	let target = requested;
+	let targetCurrent = await port.readSkill(requested);
+	const requestedArchived = targetCurrent === null && await port.isArchived?.(requested) === true;
+	if (staging.value.manifest.mode === "create-umbrella" && (targetCurrent !== null || requestedArchived)) {
+		target = requested;
+		for (let suffix = 2; suffix <= 99; suffix += 1) {
+			const candidate = requested + "-v" + String(suffix);
+			if (await port.readSkill(candidate) === null && await port.isArchived?.(candidate) !== true) {
+				target = candidate;
+				targetCurrent = null;
+				break;
+			}
+		}
+		if (target === requested) return {
+			ok: false,
+			message: "no free umbrella target for " + requested
+		};
+	}
+	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,
+		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,
+		parentRunId: runId.split("/pairs/")[0] ?? 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 targetCard = options.cards.find((card) => card.name === options.target);
+	if (targetCard?.protectionUnknown === true || targetCard?.protectedBy === "pinned") return {
+		ok: false,
+		message: "target is pinned: " + options.target
+	};
+	const stageKey = options.stageKey ?? options.runId;
+	if (options.reuseStaging === true) {
+		if (!await setStagingTarget(options.io, options.home, stageKey, options.target, options.mode)) return {
+			ok: false,
+			message: "staging missing or unreadable: " + stageKey
+		};
+	} else {
+		const created = await createStaging(options.io, options.home, {
+			runId: stageKey,
+			target: options.target,
+			...options.mode === void 0 ? {} : { mode: options.mode },
+			sources: options.cards.map((card) => ({
+				name: card.name,
+				body: card.body,
+				files: card.files ?? []
+			})),
+			promptVersion: "merge-b/v1",
+			ttlDays: 7,
+			now: options.now
+		});
+		if (!created.ok) return {
+			ok: false,
+			message: created.message
+		};
+	}
+	try {
+		await options.author({
+			home: options.home,
+			runId: stageKey
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			message: "author failed: " + (error instanceof Error ? error.message : String(error))
+		};
+	}
+	const tree = await readStagedTree(options.io, options.home, stageKey);
+	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, stageKey, 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 stageKey = stageKeyOf(options.runId, pairKey(candidate.a, candidate.b));
+			const staged = await ensureStaging(options.io, options.home, {
+				runId: stageKey,
+				target: candidate.a + "-" + candidate.b,
+				sources: options.cards.filter((card) => card.name === candidate.a || card.name === candidate.b).map((card) => ({
+					name: card.name,
+					body: card.body,
+					files: card.files ?? []
+				})),
+				promptVersion: "merge-b/v1",
+				ttlDays: 7,
+				now: options.now
+			});
+			if (!staged.ok) return {
+				kind: "failed",
+				failure: {
+					stage: "decide",
+					code: "staging-create",
+					message: staged.message,
+					retryable: true,
+					retryFrom: "agent1"
+				}
+			};
+			const result = await runRound1OverChannel({
+				channel: options.channel,
+				parent: options.parent,
+				cards: options.cards,
+				allow: options.allow,
+				cwd: stagingRoot(options.home, stageKey),
+				timeoutMs: options.timeoutMs,
+				onChildOpened: (childId) => options.onChild?.({
+					runId: stageKey,
+					childId,
+					expectedChildId: childId,
+					phase: "decide"
+				})
+			}, candidate, signal);
+			if (result.outcome.kind !== "merge") await dropStaging(options.io, options.home, stageKey);
+			else if (options.approval) await result.dispose();
+			else {
+				sessions.set(pairKey(candidate.a, candidate.b), {
+					result,
+					stageKey
+				});
+				if (result.childId !== void 0) options.onChild?.({
+					runId: stageKey,
+					childId: result.childId,
+					expectedChildId: result.childId,
+					phase: "author"
+				});
+			}
+			return result.outcome.kind === "merge" ? {
+				...result.outcome,
+				stagingRef: stageKey,
+				stagingExpiresAt: options.now() + 7 * 864e5
+			} : result.outcome;
+		},
+		async round2(row, decision, signal) {
+			const key = pairKey(row.a, row.b);
+			const entry = sessions.get(key);
+			if (entry === 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,
+					stageKey: entry.stageKey,
+					reuseStaging: true,
+					target: decision.target,
+					mode: decision.mode,
+					cards: options.cards,
+					commitPort: options.commitPort,
+					now: options.now,
+					summary: "merge " + row.a + " + " + row.b,
+					author: async () => {
+						await entry.result.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.receipt;
+				return {
+					kind: "merged",
+					...receipt?.unitId === void 0 ? {} : { unitId: receipt.unitId },
+					archived: receipt?.archived ?? [],
+					target: {
+						requested: decision.target,
+						actual: authored.commit.plan.target,
+						created: receipt?.create ?? false
+					}
+				};
+			} finally {
+				await entry.result.dispose();
+				if (entry.result.childId !== void 0) options.onChildClosed?.(entry.result.childId);
+			}
+		}
+	};
+}
+//#endregion
+//#region lib/types/new-child-authoring.js
+async function runNewChildAuthoring(options, row, decision, signal) {
+	const targetCard = options.cards.find((card) => card.name === decision.target);
+	if (targetCard?.protectionUnknown === true || targetCard?.protectedBy === "pinned") return {
+		kind: "failed",
+		failure: {
+			stage: "author",
+			code: "target-pinned",
+			message: "target is pinned: " + decision.target,
+			retryable: false,
+			retryFrom: "none"
+		}
+	};
+	const stageKey = row.stagingRef ?? stageKeyOf(options.runId, pairKey(row.a, row.b));
+	if ((await readStaging(options.io, options.home, stageKey)).kind === "present") await setStagingTarget(options.io, options.home, stageKey, decision.target, decision.mode);
+	else {
+		const staging = await createStaging(options.io, options.home, {
+			runId: stageKey,
+			target: decision.target,
+			mode: decision.mode,
+			sources: options.cards.filter((card) => card.name === row.a || card.name === row.b).map((card) => ({
+				name: card.name,
+				body: card.body,
+				files: card.files ?? []
+			})),
+			promptVersion: "merge-b/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: STANDBY_PROMPT,
+		kind: "maintainer",
+		allow: options.allow,
+		cwd: stagingRoot(options.home, stageKey),
+		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: stageKey,
+		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: "standby did not complete",
+				retryable: true,
+				retryFrom: "agent2"
+			}
+		};
+		const turn = await options.channel.continueTurn(opened.childId, buildRound2Prompt(row, decision, "fresh"), {
+			timeoutMs: options.timeoutMs,
+			signal
+		});
+		if (turn.kind !== "ok") return {
+			kind: "failed",
+			failure: {
+				stage: "author",
+				code: turn.kind,
+				message: turn.kind === "unavailable" ? turn.reason : "round2 aborted",
+				retryable: turn.kind !== "aborted",
+				retryFrom: turn.kind === "aborted" ? "none" : "agent2"
+			}
+		};
+		if (turn.turn.stopReason !== "completed") return {
+			kind: "failed",
+			failure: {
+				stage: "author",
+				code: turn.turn.stopReason,
+				message: "round2 did not complete",
+				retryable: true,
+				retryFrom: "agent2"
+			}
+		};
+		const tree = await readStagedTree(options.io, options.home, stageKey);
+		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, stageKey, 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: commit.plan.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),
+		isArchived: async (name) => {
+			if (typeof skills.archivedNames !== "function") return false;
+			const names = await skills.archivedNames();
+			return names === null ? true : names.includes(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 loadedState = await loadMergeState(deps.io, deps.home);
+			const skipped = skippedPairKeys(loadedState.state.rows, deps.params.mergeSkippedTtlDays, deps.now());
+			const held = new Set(loadedState.state.rows.filter((row) => row.queue === "pending" || !canRetry(row)).map((row) => row.pairKey));
+			const result = await runScanCommand({
+				...common,
+				approval: deps.params.mergeApproval,
+				makePorts: (runId) => createChannelScanPorts({
+					io: deps.io,
+					home: deps.home,
+					runId,
+					cards,
+					screening: async (turnSignal) => {
+						const raw = await deps.screeningForRun(cards, runId, turnSignal);
+						const filtered = raw.filter((candidate) => {
+							const key = pairKey(candidate.a, candidate.b);
+							return !skipped.has(key) && !held.has(key);
+						});
+						const candidatePairs = raw.candidatePairs;
+						return candidatePairs === void 0 ? filtered : Object.assign(filtered, { candidatePairs });
+					},
+					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, deps.params.mergeModelsRoot)).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, command.target);
+			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,
+	mergeModelsRoot: ""
+};
+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),
+		mergeModelsRoot: record.mergeModelsRoot === void 0 ? MERGE_PARAM_DEFAULTS.mergeModelsRoot : (() => {
+			const value = materialize(record.mergeModelsRoot);
+			if (typeof value !== "string") throw new Error("mergeModelsRoot must be a string");
+			return value;
+		})(),
+		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/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/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. list/read use area=sources|merged plus source (for sources); write/copy paths are relative to merged/<target> (for example path=SKILL.md, from=SKILL.md, to=references/x.md). 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),
+	mergeModelsRoot: z.string().default("")
+});
+function engineConfigFromEnv(configuredRoot) {
+	const root = configuredRoot !== void 0 && configuredRoot !== "" ? configuredRoot : process.env.SKILL_MERGE_MODELS_ROOT;
+	if (root === void 0 || root === "") return void 0;
+	return {
+		models_dir: "",
+		offline: true,
+		auto_provision: false,
+		embed_backend: "local",
+		embedder_model: join(root, "potion-multilingual-128M-int8"),
+		embedder_model_last: join(root, "potion-multilingual-128M-pca64-int8")
+	};
+}
+/** 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 mergeRun;
+	const mergeService = { async run(rawInput, invocation) {
+		return mergeRun === void 0 ? {
+			ok: false,
+			text: "merge 未就绪：evolutionIo 尚未挂载"
+		} : mergeRun(rawInput, invocation);
+	} };
+	const mergeContext = ctx;
+	if (typeof mergeContext.provide === "function") mergeContext.provide("evolutionMerge", mergeService);
+	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 engineConfig = engineConfigFromEnv(params.mergeModelsRoot);
+		const llm = ctx.get("llm");
+		const defaultModel = ctx.get("agentDefaultModel");
+		const runner = llm === void 0 || defaultModel === void 0 ? void 0 : createEngineRunner(llm, () => defaultModel.currentSelection());
+		const engineScreening = createEngineScreening({
+			io,
+			home,
+			engine: { screen },
+			select: selectCandidates,
+			...engineConfig === void 0 ? {} : { cfg: engineConfig },
+			...runner === void 0 ? {} : { runner },
+			async onSelection(selection) {
+				const loaded = await loadMergeState(io, home);
+				const at = (/* @__PURE__ */ new Date()).toISOString();
+				for (const skipped of selection.skipped) {
+					if (loaded.state.rows.some((row) => row.pairKey === skipped.pairKey)) continue;
+					const next = transition(void 0, {
+						type: "gate-keep",
+						a: skipped.a,
+						b: skipped.b,
+						...skipped.reason === void 0 ? {} : { reason: skipped.reason },
+						at
+					});
+					if (next.ok && next.row !== null) await upsertRow(io, home, () => Date.now(), next.row);
+				}
+			}
+		});
+		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());
+			},
+			approval() {
+				return params.mergeApproval;
+			},
+			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 runtime = 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 Promise.all(listed.map(async (item) => {
+					const probe = await skills.listSupportFiles(item.name);
+					const paths = probe.kind === "present" ? probe.value : [];
+					const files = await Promise.all(paths.map(async (path) => ({
+						path,
+						content: await skills.readSupportFile(item.name, path) ?? ""
+					})));
+					return {
+						name: item.name,
+						description: item.description,
+						body: item.content ?? "",
+						files,
+						protectedBy: item.protectedBy,
+						protectionUnknown: item.protectionUnknown
+					};
+				}));
+			},
+			screeningForRun: engineScreening,
+			stage: {
+				bind: (context) => {
+					stage.bind(context.childId, context);
+				},
+				unbind: (childId) => {
+					stage.unbind(childId);
+				}
+			}
+		});
+		mergeRun = (rawInput, invocation) => runMergeCommand(runtime, rawInput, invocation);
+		const command = createMergeCommand(runtime);
+		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, MERGE_DOCTOR_SCHEMA_VERSION, MERGE_MAX_ATTEMPTS, MERGE_PAIR_STATES, MERGE_PARAM_DEFAULTS, MERGE_PROMPT_VERSION, MERGE_QUEUES, MERGE_ROUTES, MERGE_STAGE_TOOL_NAME, MERGE_STATE_VERSION, STAGING_SCHEMA_VERSION, STANDBY_PROMPT, StageToolRegistry, apply, applyStageTool, approvePending, assembleStagedCommit, buildCommitPlan, buildMergeView, buildRound1Prompt, buildRound2Prompt, buildStandbyPrompt, canRetry, commitReceiptPath, commitStagedRun, committedPairs, configureMergePresentation, copyStagedFile, countRows, createChannelScanPorts, createEngineRunner, createEngineScreening, createMergeCommand, createMergeRuntime, createMergeStageTool, createNewChildRound2, createReadOnlyMergeService, createStaging, dropRow, dropStaging, durableReceiptDir, durableReceiptPath, emptyMergeState, engineConfigFromEnv, ensureStaging, formatQueue, formatStatus, handleReadOnlyMergeCommand, hasBlockingFinding, inject, isSkippedPair, listStagedFiles, loadMergeState, makeMergeRoutes, mergeCommandHelp, mergeDoctor, mergeReportDigestPath, mergeReportPath, mergeRunIdsToSupersede, mergeStatePath, mergeUsage, moveRow, mutateMergeState, pageQueue, pairKey, parseDecision, parseMergeCommand, queueOf, readCommitReceipt, readMergeReport, readStagedFile, readStagedTree, readStaging, recordRound2Outcome, rejectPending, resolveMergeParams, resolveTargetName, rewriteFrontmatterName, rowIdOf, rowsOf, runApproveCommand, runAuthoring, runMergeCommand, runNewChildAuthoring, runPairCommand, runResumeCommand, runRound1OverChannel, runScan, runScanCommand, setStagingTarget, skillLibraryPort, skillLibraryUndoPort, skippedPairKeys, snapshotCards, stageKeyOf, stageOf, stagingRoot, subagentChannelAdapter, supersedeMergeRuns, toRowView, toRunFact, transition, undoMergeReceipt, upsertRow, validateStagedTree, withMergeRun, writeCommitReceipt, writeMergeReport, writeStagedFile };