pakhale 0.2.0 → 0.4.0

package/dist/cli.js

@@ -6,6 +6,7 @@ import { homedir } from "node:os";
 import { parseArgs, styleText } from "node:util";
 import process$1, { stdin, stdout } from "node:process";
 import l__default from "node:readline";
+import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 
 //#region rolldown:runtime
@@ -104,7 +105,7 @@ var require_picocolors = /* @__PURE__ */ __commonJS({ "node_modules/picocolors/p
 
 //#endregion
 //#region config.ts
-var import_picocolors$3 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+var import_picocolors$4 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 const config = {
 	agents: ["claude-code", "opencode"],
 	marketplaces: {
@@ -195,6 +196,14 @@ const config = {
 				repo: "github/gh-stack",
 				skills: ["gh-stack"]
 			} }
+		},
+		{
+			name: "sitedrop",
+			deliver: { all: {
+				via: "skills",
+				repo: "pratikpakhale/sitedrop",
+				skills: ["sitedrop"]
+			} }
 		}
 	],
 	authoredSkillsDir: "skills",
@@ -218,14 +227,14 @@ const config = {
 //#endregion
 //#region src/util/log.ts
 const log = {
-	agent: (s) => console.log(`\n${import_picocolors$3.default.bold(import_picocolors$3.default.magenta(`■ ${s}`))}`),
-	section: (s) => console.log(`\n${import_picocolors$3.default.bold(import_picocolors$3.default.cyan(`▸ ${s}`))}`),
-	ok: (s) => console.log(`  ${import_picocolors$3.default.green("✓")} ${s}`),
-	skip: (s) => console.log(`  ${import_picocolors$3.default.dim("·")} ${import_picocolors$3.default.dim(s)}`),
-	warn: (s) => console.log(`  ${import_picocolors$3.default.yellow("!")} ${s}`),
-	fail: (s) => console.log(`  ${import_picocolors$3.default.red("✗")} ${s}`),
-	plan: (s) => console.log(`  ${import_picocolors$3.default.yellow("would")} ${s}`),
-	info: (s) => console.log(`  ${import_picocolors$3.default.dim(s)}`)
+	agent: (s) => console.log(`\n${import_picocolors$4.default.bold(import_picocolors$4.default.magenta(`■ ${s}`))}`),
+	section: (s) => console.log(`\n${import_picocolors$4.default.bold(import_picocolors$4.default.cyan(`▸ ${s}`))}`),
+	ok: (s) => console.log(`  ${import_picocolors$4.default.green("✓")} ${s}`),
+	skip: (s) => console.log(`  ${import_picocolors$4.default.dim("·")} ${import_picocolors$4.default.dim(s)}`),
+	warn: (s) => console.log(`  ${import_picocolors$4.default.yellow("!")} ${s}`),
+	fail: (s) => console.log(`  ${import_picocolors$4.default.red("✗")} ${s}`),
+	plan: (s) => console.log(`  ${import_picocolors$4.default.yellow("would")} ${s}`),
+	info: (s) => console.log(`  ${import_picocolors$4.default.dim(s)}`)
 };
 
 //#endregion
@@ -633,7 +642,7 @@ function isActionKey(n$2, e) {
 	for (const s of n$2) if (s !== void 0 && isActionKey(s, e)) return true;
 	return false;
 }
-function diffLines(i$1, s) {
+function diffLines$1(i$1, s) {
 	if (i$1 === s) return;
 	const e = i$1.split(`
 `), t = s.split(`
@@ -661,8 +670,8 @@ function wrapTextWithPrefix(e, r$1, o, t = o, s = o, n$2) {
 		hard: true,
 		trim: false
 	}).split(`
-`).map((c, i$1, m$1) => {
-		const d = n$2 ? n$2(c, i$1) : c;
+`).map((c$1, i$1, m$1) => {
+		const d = n$2 ? n$2(c$1, i$1) : c$1;
 		return i$1 === 0 ? `${t}${d}` : i$1 === m$1.length - 1 ? `${s}${d}` : `${o}${d}`;
 	}).join(`
 `);
@@ -813,7 +822,7 @@ var V = class {
 		if (t !== this._prevFrame) {
 			if (this.state === "initial") this.output.write(import_src$1.cursor.hide);
 			else {
-				const e = diffLines(this._prevFrame, t), i$1 = getRows(this.output);
+				const e = diffLines$1(this._prevFrame, t), i$1 = getRows(this.output);
 				if (this.restoreCursor(), e) {
 					const n$2 = Math.max(0, e.numLinesAfter - i$1), s = Math.max(0, e.numLinesBefore - i$1);
 					let r$1 = e.lines.find((o) => o >= n$2);
@@ -891,6 +900,34 @@ var a = class extends V {
 		});
 	}
 };
+let n$1 = class n$2 extends V {
+	options;
+	cursor = 0;
+	get _selectedValue() {
+		return this.options[this.cursor];
+	}
+	changeValue() {
+		const e = this._selectedValue;
+		this.value = e === void 0 ? void 0 : e.value;
+	}
+	constructor(e) {
+		super(e, false), this.options = e.options;
+		const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t = o === -1 ? 0 : o;
+		this.cursor = this.options[t]?.disabled ? findCursor(t, 1, this.options) : t, this.changeValue(), this.on("cursor", (s) => {
+			switch (s) {
+				case "left":
+				case "up":
+					this.cursor = findCursor(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = findCursor(this.cursor, 1, this.options);
+					break;
+			}
+			this.changeValue();
+		});
+	}
+};
 
 //#endregion
 //#region node_modules/@clack/prompts/dist/index.mjs
@@ -939,11 +976,11 @@ const limitOptions = ({ cursor: l, options: e, style: w, output: p$1 = process.s
 	const i$1 = getColumns(p$1) - C, m$1 = getRows(p$1), M = styleText("dim", "..."), v = Math.max(m$1 - r$1, 0), a$1 = Math.max(Math.min(b, v), 5);
 	let f = 0;
 	l >= a$1 - 3 && (f = Math.max(Math.min(l - a$1 + 3, e.length - a$1), 0));
-	let d = a$1 < e.length && f > 0, c = a$1 < e.length && f + a$1 < e.length;
+	let d = a$1 < e.length && f > 0, c$1 = a$1 < e.length && f + a$1 < e.length;
 	const W = Math.min(f + a$1, e.length), s = [];
 	let g = 0;
-	d && g++, c && g++;
-	const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+	d && g++, c$1 && g++;
+	const T = f + (d ? 1 : 0), y = W - (c$1 ? 1 : 0);
 	for (let t = T; t < y; t++) {
 		const n$2 = e[t], h$1 = wrapAnsi(n$2 ? w(n$2, t === l) : "", i$1, {
 			hard: true,
@@ -957,12 +994,12 @@ const limitOptions = ({ cursor: l, options: e, style: w, output: p$1 = process.s
 		const h$1 = l - T;
 		let u$4 = v;
 		const L = () => I(s, o, 0, h$1, u$4), E = () => I(s, o, h$1 + 1, s.length, u$4, true);
-		d ? ({lineCount: o, removals: t} = L(), o > u$4 && (c || (u$4 -= 1), {lineCount: o, removals: n$2} = E())) : (c || (u$4 -= 1), {lineCount: o, removals: n$2} = E(), o > u$4 && (u$4 -= 1, {lineCount: o, removals: t} = L())), t > 0 && (d = true, s.splice(0, t)), n$2 > 0 && (c = true, s.splice(s.length - n$2, n$2));
+		d ? ({lineCount: o, removals: t} = L(), o > u$4 && (c$1 || (u$4 -= 1), {lineCount: o, removals: n$2} = E())) : (c$1 || (u$4 -= 1), {lineCount: o, removals: n$2} = E(), o > u$4 && (u$4 -= 1, {lineCount: o, removals: t} = L())), t > 0 && (d = true, s.splice(0, t)), n$2 > 0 && (c$1 = true, s.splice(s.length - n$2, n$2));
 	}
 	const x = [];
 	d && x.push(M);
 	for (const t of s) for (const n$2 of t) x.push(n$2);
-	return c && x.push(M), x;
+	return c$1 && x.push(M), x;
 };
 const MULTISELECT_INSTRUCTIONS = [
 	`${styleText("dim", "↑/↓")} to navigate`,
@@ -1074,6 +1111,63 @@ const u$3 = {
 	block: unicodeOr("█", "#")
 };
 const SELECT_INSTRUCTIONS = [`${styleText("dim", "↑/↓")} to navigate`, `${styleText("dim", "Enter:")} confirm`];
+const c = (t, o) => t.includes(`
+`) ? t.split(`
+`).map((d) => o(d)).join(`
+`) : o(t);
+const select$1 = (t) => {
+	const o = (n$2, m$1) => {
+		if (n$2 === void 0) return "";
+		const s = n$2.label ?? String(n$2.value);
+		switch (m$1) {
+			case "disabled": return `${styleText("gray", S_RADIO_INACTIVE)} ${c(s, (i$1) => styleText("gray", i$1))}${n$2.hint ? ` ${styleText("dim", `(${n$2.hint ?? "disabled"})`)}` : ""}`;
+			case "selected": return `${c(s, (i$1) => styleText("dim", i$1))}`;
+			case "active": return `${styleText("green", S_RADIO_ACTIVE)} ${s}${n$2.hint ? ` ${styleText("dim", `(${n$2.hint})`)}` : ""}`;
+			case "cancelled": return `${c(s, (i$1) => styleText(["strikethrough", "dim"], i$1))}`;
+			default: return `${styleText("dim", S_RADIO_INACTIVE)} ${c(s, (i$1) => styleText("dim", i$1))}`;
+		}
+	}, d = t.showInstructions ?? true;
+	return new n$1({
+		options: t.options,
+		signal: t.signal,
+		input: t.input,
+		output: t.output,
+		initialValue: t.initialValue,
+		render() {
+			const n$2 = t.withGuide ?? settings.withGuide, m$1 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i$1 = wrapTextWithPrefix(t.output, t.message, s, m$1), u$4 = `${n$2 ? `${styleText("gray", S_BAR)}
+` : ""}${i$1}
+`;
+			switch (this.state) {
+				case "submit": {
+					const r$1 = n$2 ? `${styleText("gray", S_BAR)}  ` : "";
+					return `${u$4}${wrapTextWithPrefix(t.output, o(this.options[this.cursor], "selected"), r$1)}`;
+				}
+				case "cancel": {
+					const r$1 = n$2 ? `${styleText("gray", S_BAR)}  ` : "";
+					return `${u$4}${wrapTextWithPrefix(t.output, o(this.options[this.cursor], "cancelled"), r$1)}${n$2 ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				}
+				default: {
+					const r$1 = n$2 ? `${styleText("cyan", S_BAR)}  ` : "", a$1 = u$4.split(`
+`).length, p$1 = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n$2) : n$2 ? [styleText("cyan", S_BAR_END)] : [], b = p$1.join(`
+`), f = p$1.length + 1;
+					return `${u$4}${r$1}${limitOptions({
+						output: t.output,
+						cursor: this.cursor,
+						options: this.options,
+						maxItems: t.maxItems,
+						columnPadding: r$1.length,
+						rowPadding: a$1 + f,
+						style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+					}).join(`
+${r$1}`)}
+${b}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
 const i = `${styleText("gray", S_BAR)}  `;
 
 //#endregion
@@ -1083,12 +1177,12 @@ async function multiSelect(message, choices) {
 	if (!choices.length) return [];
 	const picked = await multiselect({
 		message,
-		options: choices.map((c) => ({
-			value: c.value,
-			label: c.label,
-			hint: c.hint
+		options: choices.map((c$1) => ({
+			value: c$1.value,
+			label: c$1.label,
+			hint: c$1.hint
 		})),
-		initialValues: choices.map((c) => c.value),
+		initialValues: choices.map((c$1) => c$1.value),
 		required: false
 	});
 	if (isCancel(picked)) {
@@ -1097,6 +1191,22 @@ async function multiSelect(message, choices) {
 	}
 	return picked;
 }
+/** One answer from a list. Cancelling returns null — the caller decides what safe means. */
+async function select(message, choices) {
+	const picked = await select$1({
+		message,
+		options: choices.map((c$1) => ({
+			value: c$1.value,
+			label: c$1.label,
+			hint: c$1.hint
+		}))
+	});
+	if (isCancel(picked)) {
+		cancel("cancelled");
+		return null;
+	}
+	return picked;
+}
 function isInteractive() {
 	return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
@@ -1210,7 +1320,7 @@ function logCoverage(config$1) {
 	const nameWidth = Math.max(...rows.map((r$1) => r$1.name.length));
 	const cellWidths = config$1.agents.map((_, i$1) => Math.max(...rows.map((r$1) => r$1.cells[i$1].length)));
 	for (const { name: name$1, cells } of rows) {
-		const line = cells.map((c, i$1) => c.padEnd(cellWidths[i$1])).join("   ");
+		const line = cells.map((c$1, i$1) => c$1.padEnd(cellWidths[i$1])).join("   ");
 		log.info(`${name$1.padEnd(nameWidth)}   ${line.trimEnd()}`);
 	}
 }
@@ -1268,8 +1378,10 @@ function claudePluginInstalls(config$1, home) {
 	return out;
 }
 /**
-* skills.sh installs into the shared `~/.agents` store. `linkDir` is where the agent expects
-* to find each skill afterwards — omit it for agents that read the store directly.
+* `linkDir` is where *this* agent expects to find each skill afterwards — the shared store
+* itself for agents that read it directly. Always pass it: `.skill-lock.json` is one
+* agent-agnostic file, so a name-only probe is satisfied by whichever agent installed first
+* and every later agent's install is skipped forever, silently reporting `unchanged`.
 */
 function skillInstalls(config$1, agent, home, linkDir) {
 	return skillDeliveries(config$1, agent).map((delivery) => {
@@ -1300,6 +1412,36 @@ function skillInstalls(config$1, agent, home, linkDir) {
 	});
 }
 
+//#endregion
+//#region src/commands/setup/agents/state.ts
+/** Machine-local bookkeeping, never a source of truth — do not sync or vendor it. */
+function stateFileFor(home) {
+	return join(home, ".agents", ".setup-state.json");
+}
+function hashContent(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+function hashValue(value) {
+	return hashContent(stable(value));
+}
+async function loadState(file) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		return {
+			files: parsed.files ?? {},
+			keys: parsed.keys ?? {}
+		};
+	} catch {
+		return {
+			files: {},
+			keys: {}
+		};
+	}
+}
+async function saveState(file, state) {
+	await writeJson(file, state);
+}
+
 //#endregion
 //#region src/commands/setup/agents/store.ts
 const AGENTS_STORE = ".agents/skills";
@@ -1312,6 +1454,7 @@ async function buildStorePlan(ctx) {
 	const archiveDir = join(ctx.home, ".agents/.setup-backups", stamp);
 	return {
 		archiveDir,
+		stateFile: stateFileFor(ctx.home),
 		groups: [{
 			section: "Skills store (~/.agents/skills)",
 			artifacts: (await authoredSkillNames(ctx)).map((name$1) => ({
@@ -1398,6 +1541,7 @@ async function buildPlan$1(ctx) {
 	});
 	return {
 		archiveDir,
+		stateFile: stateFileFor(ctx.home),
 		groups
 	};
 }
@@ -1423,8 +1567,8 @@ function claudeMcp(server) {
 		...server.headers && { headers: server.headers }
 	};
 }
-function mapValues(record, fn) {
-	return Object.fromEntries(Object.entries(record).map(([k, v]) => [k, fn(v)]));
+function mapValues(record$1, fn) {
+	return Object.fromEntries(Object.entries(record$1).map(([k, v]) => [k, fn(v)]));
 }
 async function authoredSkillLinks(ctx, root, archiveDir) {
 	return (await authoredSkillNames(ctx)).map((name$1) => ({
@@ -1473,7 +1617,7 @@ async function buildPlan(ctx) {
 	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 	const groups = [{
 		section: "Skills (remote)",
-		artifacts: skillInstalls(ctx.config, "opencode", ctx.home)
+		artifacts: skillInstalls(ctx.config, "opencode", ctx.home, join(ctx.home, AGENTS_STORE))
 	}, {
 		section: "Instructions",
 		artifacts: [{
@@ -1494,6 +1638,7 @@ async function buildPlan(ctx) {
 	});
 	return {
 		archiveDir: join(root, ".setup-backups", stamp),
+		stateFile: stateFileFor(ctx.home),
 		groups
 	};
 }
@@ -1561,14 +1706,631 @@ async function which(bin) {
 	])).ok;
 }
 
+//#endregion
+//#region node_modules/diff/libesm/diff/base.js
+var Diff = class {
+	diff(oldStr, newStr, options = {}) {
+		let callback;
+		if (typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if ("callback" in options) callback = options.callback;
+		const oldString = this.castInput(oldStr, options);
+		const newString = this.castInput(newStr, options);
+		const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+		const newTokens = this.removeEmpty(this.tokenize(newString, options));
+		return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+	}
+	diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+		var _a;
+		const done = (value) => {
+			value = this.postProcess(value, options);
+			if (callback) {
+				setTimeout(function() {
+					callback(value);
+				}, 0);
+				return;
+			} else return value;
+		};
+		const newLen = newTokens.length, oldLen = oldTokens.length;
+		let editLength = 1;
+		let maxEditLength = newLen + oldLen;
+		if (options.maxEditLength != null) maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+		const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+		const abortAfterTimestamp = Date.now() + maxExecutionTime;
+		const bestPath = [{
+			oldPos: -1,
+			lastComponent: void 0
+		}];
+		let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+		if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+		let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+		const execEditLength = () => {
+			for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+				let basePath;
+				const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+				if (removePath) bestPath[diagonalPath - 1] = void 0;
+				let canAdd = false;
+				if (addPath) {
+					const addPathNewPos = addPath.oldPos - diagonalPath;
+					canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+				}
+				const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+				if (!canAdd && !canRemove) {
+					bestPath[diagonalPath] = void 0;
+					continue;
+				}
+				if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) basePath = this.addToPath(addPath, true, false, 0, options);
+				else basePath = this.addToPath(removePath, false, true, 1, options);
+				newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+				if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+				else {
+					bestPath[diagonalPath] = basePath;
+					if (basePath.oldPos + 1 >= oldLen) maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+					if (newPos + 1 >= newLen) minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+				}
+			}
+			editLength++;
+		};
+		if (callback) (function exec$1() {
+			setTimeout(function() {
+				if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) return callback(void 0);
+				if (!execEditLength()) exec$1();
+			}, 0);
+		})();
+		else while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+			const ret = execEditLength();
+			if (ret) return ret;
+		}
+	}
+	addToPath(path, added, removed, oldPosInc, options) {
+		const last = path.lastComponent;
+		if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) return {
+			oldPos: path.oldPos + oldPosInc,
+			lastComponent: {
+				count: last.count + 1,
+				added,
+				removed,
+				previousComponent: last.previousComponent
+			}
+		};
+		else return {
+			oldPos: path.oldPos + oldPosInc,
+			lastComponent: {
+				count: 1,
+				added,
+				removed,
+				previousComponent: last
+			}
+		};
+	}
+	extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+		const newLen = newTokens.length, oldLen = oldTokens.length;
+		let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+		while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+			newPos++;
+			oldPos++;
+			commonCount++;
+			if (options.oneChangePerToken) basePath.lastComponent = {
+				count: 1,
+				previousComponent: basePath.lastComponent,
+				added: false,
+				removed: false
+			};
+		}
+		if (commonCount && !options.oneChangePerToken) basePath.lastComponent = {
+			count: commonCount,
+			previousComponent: basePath.lastComponent,
+			added: false,
+			removed: false
+		};
+		basePath.oldPos = oldPos;
+		return newPos;
+	}
+	equals(left, right, options) {
+		if (options.comparator) return options.comparator(left, right);
+		else return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+	}
+	removeEmpty(array) {
+		const ret = [];
+		for (let i$1 = 0; i$1 < array.length; i$1++) if (array[i$1]) ret.push(array[i$1]);
+		return ret;
+	}
+	castInput(value, options) {
+		return value;
+	}
+	tokenize(value, options) {
+		return Array.from(value);
+	}
+	join(chars) {
+		return chars.join("");
+	}
+	postProcess(changeObjects, options) {
+		return changeObjects;
+	}
+	get useLongestToken() {
+		return false;
+	}
+	buildValues(lastComponent, newTokens, oldTokens) {
+		const components = [];
+		let nextComponent;
+		while (lastComponent) {
+			components.push(lastComponent);
+			nextComponent = lastComponent.previousComponent;
+			delete lastComponent.previousComponent;
+			lastComponent = nextComponent;
+		}
+		components.reverse();
+		const componentLen = components.length;
+		let componentPos = 0, newPos = 0, oldPos = 0;
+		for (; componentPos < componentLen; componentPos++) {
+			const component = components[componentPos];
+			if (!component.removed) {
+				if (!component.added && this.useLongestToken) {
+					let value = newTokens.slice(newPos, newPos + component.count);
+					value = value.map(function(value$1, i$1) {
+						const oldValue = oldTokens[oldPos + i$1];
+						return oldValue.length > value$1.length ? oldValue : value$1;
+					});
+					component.value = this.join(value);
+				} else component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+				newPos += component.count;
+				if (!component.added) oldPos += component.count;
+			} else {
+				component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+				oldPos += component.count;
+			}
+		}
+		return components;
+	}
+};
+
+//#endregion
+//#region node_modules/diff/libesm/diff/character.js
+var CharacterDiff = class extends Diff {};
+const characterDiff = new CharacterDiff();
+
+//#endregion
+//#region node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+	let i$1;
+	for (i$1 = 0; i$1 < str1.length && i$1 < str2.length; i$1++) if (str1[i$1] != str2[i$1]) return str1.slice(0, i$1);
+	return str1.slice(0, i$1);
+}
+function longestCommonSuffix(str1, str2) {
+	let i$1;
+	if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) return "";
+	for (i$1 = 0; i$1 < str1.length && i$1 < str2.length; i$1++) if (str1[str1.length - (i$1 + 1)] != str2[str2.length - (i$1 + 1)]) return str1.slice(-i$1);
+	return str1.slice(-i$1);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+	if (string.slice(0, oldPrefix.length) != oldPrefix) throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+	return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+	if (!oldSuffix) return string + newSuffix;
+	if (string.slice(-oldSuffix.length) != oldSuffix) throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+	return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+	return replacePrefix(string, oldPrefix, "");
+}
+function removeSuffix(string, oldSuffix) {
+	return replaceSuffix(string, oldSuffix, "");
+}
+function maximumOverlap(string1, string2) {
+	return string2.slice(0, overlapCount(string1, string2));
+}
+function overlapCount(a$1, b) {
+	let startA = 0;
+	if (a$1.length > b.length) startA = a$1.length - b.length;
+	let endB = b.length;
+	if (a$1.length < b.length) endB = a$1.length;
+	const map = Array(endB);
+	let k = 0;
+	map[0] = 0;
+	for (let j = 1; j < endB; j++) {
+		if (b[j] == b[k]) map[j] = map[k];
+		else map[j] = k;
+		while (k > 0 && b[j] != b[k]) k = map[k];
+		if (b[j] == b[k]) k++;
+	}
+	k = 0;
+	for (let i$1 = startA; i$1 < a$1.length; i$1++) {
+		while (k > 0 && a$1[i$1] != b[k]) k = map[k];
+		if (a$1[i$1] == b[k]) k++;
+	}
+	return k;
+}
+/**
+* Split a string into segments using a word segmenter, merging consecutive
+* segments if they are both whitespace segments. Whitespace segments can
+* appear adjacent to one another for two reasons:
+* - newlines always get their own segment
+* - where a diacritic is attached to a whitespace character in the text, the
+*   segment ends after the diacritic, so e.g. " \u0300 " becomes two segments.
+* This function therefore runs the segmenter's .segment() method and then
+* merges consecutive segments of whitespace into a single part.
+*/
+function segment(string, segmenter) {
+	const parts = [];
+	for (const segmentObj of Array.from(segmenter.segment(string))) {
+		const segment$1 = segmentObj.segment;
+		if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment$1)) parts[parts.length - 1] += segment$1;
+		else parts.push(segment$1);
+	}
+	return parts;
+}
+function trailingWs(string, segmenter) {
+	if (segmenter) return leadingAndTrailingWs(string, segmenter)[1];
+	let i$1;
+	for (i$1 = string.length - 1; i$1 >= 0; i$1--) if (!string[i$1].match(/\s/)) break;
+	return string.substring(i$1 + 1);
+}
+function leadingWs(string, segmenter) {
+	if (segmenter) return leadingAndTrailingWs(string, segmenter)[0];
+	const match = string.match(/^\s*/);
+	return match ? match[0] : "";
+}
+function leadingAndTrailingWs(string, segmenter) {
+	if (!segmenter) return [leadingWs(string), trailingWs(string)];
+	if (segmenter.resolvedOptions().granularity != "word") throw new Error("The segmenter passed must have a granularity of \"word\"");
+	const segments = segment(string, segmenter);
+	const firstSeg = segments[0];
+	const lastSeg = segments[segments.length - 1];
+	return [/\s/.test(firstSeg) ? firstSeg : "", /\s/.test(lastSeg) ? lastSeg : ""];
+}
+
+//#endregion
+//#region node_modules/diff/libesm/diff/word.js
+const extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+const tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+var WordDiff = class extends Diff {
+	equals(left, right, options) {
+		if (options.ignoreCase) {
+			left = left.toLowerCase();
+			right = right.toLowerCase();
+		}
+		return left.trim() === right.trim();
+	}
+	tokenize(value, options = {}) {
+		let parts;
+		if (options.intlSegmenter) {
+			const segmenter = options.intlSegmenter;
+			if (segmenter.resolvedOptions().granularity != "word") throw new Error("The segmenter passed must have a granularity of \"word\"");
+			parts = segment(value, segmenter);
+		} else parts = value.match(tokenizeIncludingWhitespace) || [];
+		const tokens = [];
+		let prevPart = null;
+		parts.forEach((part) => {
+			if (/\s/.test(part)) if (prevPart == null) tokens.push(part);
+			else tokens.push(tokens.pop() + part);
+			else if (prevPart != null && /\s/.test(prevPart)) if (tokens[tokens.length - 1] == prevPart) tokens.push(tokens.pop() + part);
+			else tokens.push(prevPart + part);
+			else tokens.push(part);
+			prevPart = part;
+		});
+		return tokens;
+	}
+	join(tokens) {
+		return tokens.map((token, i$1) => {
+			if (i$1 == 0) return token;
+			else return token.replace(/^\s+/, "");
+		}).join("");
+	}
+	postProcess(changes, options) {
+		if (!changes || options.oneChangePerToken) return changes;
+		let lastKeep = null;
+		let insertion = null;
+		let deletion = null;
+		changes.forEach((change) => {
+			if (change.added) insertion = change;
+			else if (change.removed) deletion = change;
+			else {
+				if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
+				lastKeep = change;
+				insertion = null;
+				deletion = null;
+			}
+		});
+		if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
+		return changes;
+	}
+};
+const wordDiff = new WordDiff();
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
+	if (deletion && insertion) {
+		const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
+		const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
+		if (startKeep) {
+			const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+			startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+			deletion.value = removePrefix(deletion.value, commonWsPrefix);
+			insertion.value = removePrefix(insertion.value, commonWsPrefix);
+		}
+		if (endKeep) {
+			const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+			endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+			deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+			insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+		}
+	} else if (insertion) {
+		if (startKeep) {
+			const ws = leadingWs(insertion.value, segmenter);
+			insertion.value = insertion.value.substring(ws.length);
+		}
+		if (endKeep) {
+			const ws = leadingWs(endKeep.value, segmenter);
+			endKeep.value = endKeep.value.substring(ws.length);
+		}
+	} else if (startKeep && endKeep) {
+		const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
+		const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+		deletion.value = removePrefix(deletion.value, newWsStart);
+		const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+		deletion.value = removeSuffix(deletion.value, newWsEnd);
+		endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+		startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+	} else if (endKeep) {
+		const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
+		const overlap = maximumOverlap(trailingWs(deletion.value, segmenter), endKeepWsPrefix);
+		deletion.value = removeSuffix(deletion.value, overlap);
+	} else if (startKeep) {
+		const overlap = maximumOverlap(trailingWs(startKeep.value, segmenter), leadingWs(deletion.value, segmenter));
+		deletion.value = removePrefix(deletion.value, overlap);
+	}
+}
+var WordsWithSpaceDiff = class extends Diff {
+	tokenize(value) {
+		const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+		return value.match(regex) || [];
+	}
+};
+const wordsWithSpaceDiff = new WordsWithSpaceDiff();
+
+//#endregion
+//#region node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+	constructor() {
+		super(...arguments);
+		this.tokenize = tokenize;
+	}
+	equals(left, right, options) {
+		if (options.ignoreWhitespace) {
+			if (!options.newlineIsToken || !left.includes("\n")) left = left.trim();
+			if (!options.newlineIsToken || !right.includes("\n")) right = right.trim();
+		} else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+			if (left.endsWith("\n")) left = left.slice(0, -1);
+			if (right.endsWith("\n")) right = right.slice(0, -1);
+		}
+		return super.equals(left, right, options);
+	}
+};
+const lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+	return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+	if (options.stripTrailingCr) value = value.replace(/\r\n/g, "\n");
+	const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+	if (!linesAndNewlines[linesAndNewlines.length - 1]) linesAndNewlines.pop();
+	for (let i$1 = 0; i$1 < linesAndNewlines.length; i$1++) {
+		const line = linesAndNewlines[i$1];
+		if (i$1 % 2 && !options.newlineIsToken) retLines[retLines.length - 1] += line;
+		else retLines.push(line);
+	}
+	return retLines;
+}
+
+//#endregion
+//#region node_modules/diff/libesm/diff/sentence.js
+function isSentenceEndPunct(char) {
+	return char == "." || char == "!" || char == "?";
+}
+var SentenceDiff = class extends Diff {
+	tokenize(value) {
+		var _a;
+		const result = [];
+		let tokenStartI = 0;
+		for (let i$1 = 0; i$1 < value.length; i$1++) {
+			if (i$1 == value.length - 1) {
+				result.push(value.slice(tokenStartI));
+				break;
+			}
+			if (isSentenceEndPunct(value[i$1]) && value[i$1 + 1].match(/\s/)) {
+				result.push(value.slice(tokenStartI, i$1 + 1));
+				i$1 = tokenStartI = i$1 + 1;
+				while ((_a = value[i$1 + 1]) === null || _a === void 0 ? void 0 : _a.match(/\s/)) i$1++;
+				result.push(value.slice(tokenStartI, i$1 + 1));
+				tokenStartI = i$1 + 1;
+			}
+		}
+		return result;
+	}
+};
+const sentenceDiff = new SentenceDiff();
+
+//#endregion
+//#region node_modules/diff/libesm/diff/css.js
+var CssDiff = class extends Diff {
+	tokenize(value) {
+		return value.split(/([{}:;,]|\s+)/);
+	}
+};
+const cssDiff = new CssDiff();
+
+//#endregion
+//#region node_modules/diff/libesm/diff/json.js
+var JsonDiff = class extends Diff {
+	constructor() {
+		super(...arguments);
+		this.tokenize = tokenize;
+	}
+	get useLongestToken() {
+		return true;
+	}
+	castInput(value, options) {
+		const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
+		return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+	}
+	equals(left, right, options) {
+		return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
+	}
+};
+const jsonDiff = new JsonDiff();
+function canonicalize(obj, stack, replacementStack, replacer, key) {
+	stack = stack || [];
+	replacementStack = replacementStack || [];
+	if (replacer) obj = replacer(key === void 0 ? "" : key, obj);
+	let i$1;
+	for (i$1 = 0; i$1 < stack.length; i$1 += 1) if (stack[i$1] === obj) return replacementStack[i$1];
+	let canonicalizedObj;
+	if ("[object Array]" === Object.prototype.toString.call(obj)) {
+		stack.push(obj);
+		canonicalizedObj = new Array(obj.length);
+		replacementStack.push(canonicalizedObj);
+		for (i$1 = 0; i$1 < obj.length; i$1 += 1) canonicalizedObj[i$1] = canonicalize(obj[i$1], stack, replacementStack, replacer, String(i$1));
+		stack.pop();
+		replacementStack.pop();
+		return canonicalizedObj;
+	}
+	if (obj && obj.toJSON) obj = obj.toJSON();
+	if (typeof obj === "object" && obj !== null) {
+		stack.push(obj);
+		canonicalizedObj = {};
+		replacementStack.push(canonicalizedObj);
+		const sortedKeys = [];
+		let key$1;
+		for (key$1 in obj)
+ /* istanbul ignore else */
+		if (Object.prototype.hasOwnProperty.call(obj, key$1)) sortedKeys.push(key$1);
+		sortedKeys.sort();
+		for (i$1 = 0; i$1 < sortedKeys.length; i$1 += 1) {
+			key$1 = sortedKeys[i$1];
+			canonicalizedObj[key$1] = canonicalize(obj[key$1], stack, replacementStack, replacer, key$1);
+		}
+		stack.pop();
+		replacementStack.pop();
+	} else canonicalizedObj = obj;
+	return canonicalizedObj;
+}
+
+//#endregion
+//#region node_modules/diff/libesm/diff/array.js
+var ArrayDiff = class extends Diff {
+	tokenize(value) {
+		return value.slice();
+	}
+	join(value) {
+		return value;
+	}
+	removeEmpty(value) {
+		return value;
+	}
+};
+const arrayDiff = new ArrayDiff();
+
+//#endregion
+//#region node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+	let optionsObj;
+	if (!options) optionsObj = {};
+	else if (typeof options === "function") optionsObj = { callback: options };
+	else optionsObj = options;
+	if (typeof optionsObj.context === "undefined") optionsObj.context = 4;
+	const context = optionsObj.context;
+	if (optionsObj.newlineIsToken) throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+	if (!optionsObj.callback) return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+	else {
+		const { callback } = optionsObj;
+		diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff$1) => {
+			callback(diffLinesResultToPatch(diff$1));
+		} }));
+	}
+	function diffLinesResultToPatch(diff$1) {
+		if (!diff$1) return;
+		diff$1.push({
+			value: "",
+			lines: []
+		});
+		function contextLines(lines) {
+			return lines.map(function(entry) {
+				return " " + entry;
+			});
+		}
+		const hunks = [];
+		let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+		for (let i$1 = 0; i$1 < diff$1.length; i$1++) {
+			const current = diff$1[i$1], lines = current.lines || splitLines(current.value);
+			current.lines = lines;
+			if (current.added || current.removed) {
+				if (!oldRangeStart) {
+					const prev = diff$1[i$1 - 1];
+					oldRangeStart = oldLine;
+					newRangeStart = newLine;
+					if (prev) {
+						curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+						oldRangeStart -= curRange.length;
+						newRangeStart -= curRange.length;
+					}
+				}
+				for (const line of lines) curRange.push((current.added ? "+" : "-") + line);
+				if (current.added) newLine += lines.length;
+				else oldLine += lines.length;
+			} else {
+				if (oldRangeStart) if (lines.length <= context * 2 && i$1 < diff$1.length - 2) for (const line of contextLines(lines)) curRange.push(line);
+				else {
+					const contextSize = Math.min(lines.length, context);
+					for (const line of contextLines(lines.slice(0, contextSize))) curRange.push(line);
+					const hunk = {
+						oldStart: oldRangeStart,
+						oldLines: oldLine - oldRangeStart + contextSize,
+						newStart: newRangeStart,
+						newLines: newLine - newRangeStart + contextSize,
+						lines: curRange
+					};
+					hunks.push(hunk);
+					oldRangeStart = 0;
+					newRangeStart = 0;
+					curRange = [];
+				}
+				oldLine += lines.length;
+				newLine += lines.length;
+			}
+		}
+		for (const hunk of hunks) for (let i$1 = 0; i$1 < hunk.lines.length; i$1++) if (hunk.lines[i$1].endsWith("\n")) hunk.lines[i$1] = hunk.lines[i$1].slice(0, -1);
+		else {
+			hunk.lines.splice(i$1 + 1, 0, "\");
+			i$1++;
+		}
+		return {
+			oldFileName,
+			newFileName,
+			oldHeader,
+			newHeader,
+			hunks
+		};
+	}
+}
+/**
+* Split `text` into an array of lines, including the trailing newline character (where present)
+*/
+function splitLines(text) {
+	const hasTrailingNl = text.endsWith("\n");
+	const result = text.split("\n").map((line) => line + "\n");
+	if (hasTrailingNl) result.pop();
+	else result.push(result.pop().slice(0, -1));
+	return result;
+}
+
 //#endregion
 //#region src/commands/setup/agents/diff.ts
-async function diff(plan) {
+async function diff(plan, state) {
 	const probes = new Probes();
 	const sections = [];
 	for (const group of plan.groups) {
 		const changes = [];
-		for (const artifact of group.artifacts) changes.push(await changeFor(artifact, plan.archiveDir, probes));
+		for (const artifact of group.artifacts) changes.push(await changeFor(artifact, plan.archiveDir, state, probes));
 		sections.push({
 			title: group.section,
 			changes
@@ -1576,29 +2338,62 @@ async function diff(plan) {
 	}
 	return sections;
 }
-function changeFor(a$1, archiveDir, probes) {
+function changeFor(a$1, archiveDir, state, probes) {
 	switch (a$1.kind) {
-		case "file": return fileChange(a$1);
+		case "file": return fileChange(a$1, archiveDir, state);
 		case "symlink": return symlinkChange(a$1);
-		case "jsonMerge": return jsonMergeChange(a$1, archiveDir);
+		case "jsonMerge": return jsonMergeChange(a$1, archiveDir, state);
 		case "install": return installChange(a$1, probes);
 	}
 }
-async function fileChange(a$1) {
+async function fileChange(a$1, archiveDir, state) {
 	const next = await readFile(a$1.src);
-	if ((await readFile(a$1.dest).catch(() => null))?.equals(next)) return {
+	const current = await readFile(a$1.dest).catch(() => null);
+	const record$1 = {
+		file: a$1.dest,
+		hash: hashContent(next)
+	};
+	if (current?.equals(next)) return {
 		status: "unchanged",
-		label: a$1.dest
+		label: a$1.dest,
+		record: record$1
+	};
+	const action = {
+		do: "write-file",
+		src: a$1.src,
+		dest: a$1.dest,
+		...a$1.mode && { mode: a$1.mode }
+	};
+	if (current === null && a$1.dest in state.files) return {
+		status: "conflict",
+		label: a$1.dest,
+		summary: "was deleted on this machine",
+		diffText: unified(basename(a$1.dest), "", next.toString()),
+		apply: {
+			action,
+			record: record$1
+		},
+		keep: null
+	};
+	if (current !== null && state.files[a$1.dest] !== hashContent(current)) return {
+		status: "conflict",
+		label: a$1.dest,
+		summary: "has content setup did not write",
+		diffText: unified(basename(a$1.dest), current.toString(), next.toString()),
+		apply: {
+			action: {
+				...action,
+				backupTo: archiveDir
+			},
+			record: record$1
+		},
+		keep: null
 	};
 	return {
 		status: "pending",
 		label: a$1.dest,
-		action: {
-			do: "write-file",
-			src: a$1.src,
-			dest: a$1.dest,
-			...a$1.mode && { mode: a$1.mode }
-		}
+		action,
+		record: record$1
 	};
 }
 async function symlinkChange(a$1) {
@@ -1613,7 +2408,8 @@ async function symlinkChange(a$1) {
 		label,
 		action: link
 	};
-	if ((await lstat(a$1.linkPath)).isSymbolicLink()) {
+	const st = await lstat(a$1.linkPath);
+	if (st.isSymbolicLink()) {
 		if (await readlink(a$1.linkPath) === a$1.target) return {
 			status: "unchanged",
 			label
@@ -1634,49 +2430,106 @@ async function symlinkChange(a$1) {
 	};
 	const archiveTo = join(a$1.archiveDisplaced, basename(a$1.linkPath));
 	return {
-		status: "pending",
+		status: "conflict",
 		label,
-		action: {
+		summary: `a real ${st.isDirectory() ? "directory" : "file"} sits where the link goes`,
+		diffText: "",
+		apply: { action: {
 			...link,
 			archiveTo
-		}
+		} },
+		keep: null
 	};
 }
-async function jsonMergeChange(a$1, archiveDir) {
+async function jsonMergeChange(a$1, archiveDir, state) {
 	const label = basename(a$1.dest);
 	const raw = await readFile(a$1.dest, "utf8").catch(() => null);
 	let current = {};
-	if (raw !== null) try {
-		current = JSON.parse(raw);
-	} catch {
-		return {
+	if (raw !== null) {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return {
+				status: "blocked",
+				label,
+				reason: "not parseable JSON (comments?)"
+			};
+		}
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {
 			status: "blocked",
 			label,
-			reason: "not parseable JSON (comments?)"
+			reason: "not a JSON object"
 		};
+		current = parsed;
 	}
-	const value = {
-		...current,
+	const desired = {
 		...a$1.managed,
 		...a$1.derived
 	};
+	const value = {
+		...current,
+		...desired
+	};
+	const record$1 = {
+		file: a$1.dest,
+		keys: Object.fromEntries(Object.keys(desired).map((k) => [k, hashValue(desired[k])]))
+	};
 	if (stable(current) === stable(value)) return {
 		status: "unchanged",
-		label
+		label,
+		record: record$1
 	};
 	const notes = Object.keys(value).filter((k) => stable(current[k]) !== stable(value[k])).map((k) => `set ${k}${k in a$1.derived ? " (derived)" : ""}`);
 	const unmanaged = Object.keys(current).filter((k) => !(k in a$1.managed) && !(k in a$1.derived));
 	if (unmanaged.length) notes.push(`preserved unmanaged keys: ${unmanaged.join(", ")}`);
-	return {
+	const action = {
+		do: "write-json",
+		dest: a$1.dest,
+		value,
+		backupTo: archiveDir
+	};
+	const ours = state.keys[a$1.dest] ?? {};
+	const contested = Object.keys(desired).filter((k) => {
+		if (stable(current[k]) === stable(desired[k])) return false;
+		if (k in current) return ours[k] !== hashValue(current[k]);
+		return k in ours;
+	});
+	if (!contested.length) return {
 		status: "pending",
 		label,
+		action,
+		notes,
+		record: record$1
+	};
+	const keepValue = { ...value };
+	for (const k of contested) if (k in current) keepValue[k] = current[k];
+	else delete keepValue[k];
+	const keepRecord = {
+		file: a$1.dest,
+		keys: Object.fromEntries(Object.entries(record$1.keys).filter(([k]) => !contested.includes(k)))
+	};
+	const keep = stable(keepValue) === stable(current) ? null : {
 		action: {
 			do: "write-json",
 			dest: a$1.dest,
-			value,
+			value: keepValue,
 			backupTo: archiveDir
 		},
-		notes
+		record: keepRecord,
+		notes: [`kept your values: ${contested.join(", ")}`]
+	};
+	return {
+		status: "conflict",
+		label,
+		summary: `set outside setup: ${contested.join(", ")}`,
+		diffText: contested.map((k) => unified(k, k in current ? pretty(current[k]) : "", pretty(desired[k]))).join("\n"),
+		apply: {
+			action,
+			record: record$1,
+			notes
+		},
+		keep
 	};
 }
 async function installChange(a$1, probes) {
@@ -1698,6 +2551,18 @@ async function installChange(a$1, probes) {
 		}
 	};
 }
+function pretty(value) {
+	return `${JSON.stringify(value, null, 2) ?? "null"}\n`;
+}
+function unified(name$1, before, after) {
+	const patch = structuredPatch(name$1, name$1, before, after);
+	const lines = [`── ${name$1}`];
+	for (const hunk of patch.hunks) {
+		lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+		lines.push(...hunk.lines);
+	}
+	return lines.join("\n");
+}
 /** Memoised machine lookups — `claude plugin list` costs a process spawn, so it runs once. */
 var Probes = class {
 	onPathCache = /* @__PURE__ */ new Map();
@@ -1753,8 +2618,11 @@ var Probes = class {
 //#endregion
 //#region src/commands/setup/agents/executor.ts
 /** The one place `dryRun` is consulted: the same diff is either printed or committed. */
-async function runPlan(plan, dryRun) {
-	await walk(await diff(plan), dryRun ? render : commit);
+async function runPlan(plan, dryRun, resolve$1) {
+	const state = await loadState(plan.stateFile);
+	const before = stable(state);
+	await walk(await diff(plan, state), dryRun ? render : (change) => commit(change, state, resolve$1));
+	if (!dryRun && stable(state) !== before) await saveState(plan.stateFile, state);
 }
 async function walk(sections, handle) {
 	for (const { title, changes } of sections) {
@@ -1769,29 +2637,59 @@ function render(change) {
 		case "pending":
 			log.plan(phrase(change.action));
 			for (const note of change.notes ?? []) log.info(note);
+			return;
+		case "conflict":
+			log.warn(`conflict: ${change.label} — ${change.summary}`);
+			log.info("will ask keep / use config / show diff (piped runs keep; --force uses config)");
 	}
 }
-async function commit(change) {
+async function commit(change, state, resolve$1) {
 	switch (change.status) {
-		case "unchanged": return log.skip(`${change.label} (unchanged)`);
+		case "unchanged":
+			record(state, change.record);
+			return log.skip(`${change.label} (unchanged)`);
 		case "blocked": return log.fail(`${change.label} — ${change.reason}, leaving it alone`);
 		case "pending": {
 			const { ok, notes } = await perform(change.action);
 			if (!ok) return log.fail(`${change.label}: ${notes.join(" ")}`);
+			record(state, change.record);
 			log.ok(change.label);
 			for (const note of [...notes, ...change.notes ?? []]) log.info(note);
+			return;
+		}
+		case "conflict": {
+			const outcome = await resolve$1(change) === "apply" ? change.apply : change.keep;
+			if (!outcome) return log.warn(`${change.label} — ${change.summary}; kept as-is (resolve interactively or with --force)`);
+			const { ok, notes } = await perform(outcome.action);
+			if (!ok) return log.fail(`${change.label}: ${notes.join(" ")}`);
+			record(state, outcome.record);
+			log.ok(change.label);
+			for (const note of [...notes, ...outcome.notes ?? []]) log.info(note);
 		}
 	}
 }
+function record(state, entry) {
+	if (!entry) return;
+	if ("hash" in entry) state.files[entry.file] = entry.hash;
+	else state.keys[entry.file] = {
+		...state.keys[entry.file],
+		...entry.keys
+	};
+}
 async function perform(action) {
 	switch (action.do) {
 		case "write-file": {
+			const notes = [];
+			if (action.backupTo) {
+				const bak = await backup(action.dest, action.backupTo);
+				if (bak) notes.push(`backed up → ${bak}`);
+			}
 			const bytes = await readFile(action.src);
 			await ensureDir(dirname(action.dest));
 			await writeFile(action.dest, bytes, action.mode ? { mode: action.mode } : void 0);
 			return {
 				ok: true,
-				notes: []
+				notes
 			};
 		}
 		case "link": {
@@ -1848,16 +2746,72 @@ function phrase(action) {
 	}
 }
 
+//#endregion
+//#region src/commands/setup/agents/resolve.ts
+var import_picocolors$3 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+/** `--force`: the config wins every conflict, exactly as if each prompt answered "use config". */
+const forceResolver = async () => "apply";
+/** No one to ask — keep what the machine has, dpkg's default for the same reason. */
+const keepResolver = async () => "keep";
+function defaultResolver() {
+	return isInteractive() ? interactiveResolver() : keepResolver;
+}
+function interactiveResolver(ask = select) {
+	let rest$1 = null;
+	return async (conflict) => {
+		if (rest$1) return rest$1;
+		for (;;) switch (await ask(`${conflict.label} — ${conflict.summary}`, [
+			{
+				value: "keep",
+				label: "Keep what this machine has",
+				hint: "asks again next run"
+			},
+			{
+				value: "apply",
+				label: "Use the config's version",
+				hint: "existing is backed up"
+			},
+			...conflict.diffText ? [{
+				value: "diff",
+				label: "Show the diff first"
+			}] : [],
+			{
+				value: "keep-all",
+				label: "Keep — here and for every remaining conflict"
+			},
+			{
+				value: "apply-all",
+				label: "Use config — here and for every remaining conflict"
+			}
+		])) {
+			case "diff":
+				printDiff(conflict.diffText);
+				continue;
+			case "apply": return "apply";
+			case "apply-all": return rest$1 = "apply";
+			case "keep-all":
+			case null: return rest$1 = "keep";
+			default: return "keep";
+		}
+	};
+}
+function printDiff(text) {
+	for (const line of text.split("\n")) if (line.startsWith("+")) console.log(`  ${import_picocolors$3.default.green(line)}`);
+	else if (line.startsWith("-")) console.log(`  ${import_picocolors$3.default.red(line)}`);
+	else if (line.startsWith("@@")) console.log(`  ${import_picocolors$3.default.cyan(line)}`);
+	else console.log(`  ${import_picocolors$3.default.dim(line)}`);
+}
+
 //#endregion
 //#region src/commands/setup/agents/apply.ts
 /** An agent with no config directory is not on this machine — skip it, never create it. */
 function isInstalled(home, emitter) {
 	return exists(join(home, emitter.configDir));
 }
-async function applyAgents(ctx, ids, dryRun) {
+async function applyAgents(ctx, ids, dryRun, resolve$1 = defaultResolver()) {
 	validateExtensions(ctx.config);
 	logCoverage(ctx.config);
-	await runPlan(await buildStorePlan(ctx), dryRun);
+	await runPlan(await buildStorePlan(ctx), dryRun, resolve$1);
 	for (const id of ids) {
 		const emitter = emitters[id];
 		if (!emitter) continue;
@@ -1866,7 +2820,7 @@ async function applyAgents(ctx, ids, dryRun) {
 			log.warn(`${id} not installed on this machine — skipping`);
 			continue;
 		}
-		await runPlan(await emitter.buildPlan(ctx), dryRun);
+		await runPlan(await emitter.buildPlan(ctx), dryRun, resolve$1);
 	}
 }
 
@@ -1881,10 +2835,14 @@ scripted runs apply to every configured agent.
 
   plan               dry run — show every change, write nothing
 
+Anything on the machine that setup did not write is a conflict: interactively you choose
+keep / use config / see the diff; piped runs keep the machine's version.
+
 Options:
   -n, --dry-run      same as plan
   -a, --agent <id>   target one agent (repeatable) — skips the prompt
       --all          every configured agent — skips the prompt
+      --force        resolve every conflict in the config's favour, no prompts
       --home <dir>   apply against a different home directory
   -h, --help         show this help`;
 const agents = {
@@ -1908,6 +2866,10 @@ const agents = {
 					type: "boolean",
 					default: false
 				},
+				force: {
+					type: "boolean",
+					default: false
+				},
 				home: { type: "string" },
 				help: {
 					type: "boolean",
@@ -1945,7 +2907,7 @@ const agents = {
 			home,
 			repoRoot: packageRoot$1,
 			config
-		}, selected, dryRun);
+		}, selected, dryRun, values.force ? forceResolver : defaultResolver());
 		console.log(dryRun ? `\n${import_picocolors$2.default.yellow("dry run complete — nothing written")}\n` : `\n${import_picocolors$2.default.green("done")}\n`);
 		return 0;
 	}
@@ -2009,7 +2971,7 @@ async function version() {
 }
 function usage() {
 	console.log(`Usage: pakhale <command> [options]\n\nCommands:`);
-	for (const c of Object.values(commands)) console.log(`  ${c.name.padEnd(10)} ${c.describe}`);
+	for (const c$1 of Object.values(commands)) console.log(`  ${c$1.name.padEnd(10)} ${c$1.describe}`);
 	console.log(`\nOptions:\n  -h, --help     show this help\n  -v, --version  show version`);
 }
 if (!name || name === "--help" || name === "-h") {