@tryaura/aura-cli 0.1.0

package/dist/skill-deployment-plan-C4GTrVSy.js

@@ -0,0 +1,1996 @@
+import { McpWriteError, advanceMarkdownFence, defineOwnProperty, definePlugin, detectLineEnding as detectLineEnding$1, jsonPropertyPath, mcpServerNameProblem, normalizeMcpServerDefinition, parseMcpServerDefinition, pluginContentUrl, splitSourceLines as splitSourceLines$1 } from "@tryaura/aura-sdk";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Buffer, isUtf8 } from "node:buffer";
+import { createHash } from "node:crypto";
+import { createTwoFilesPatch } from "diff";
+import { isDeepStrictEqual } from "node:util";
+//#region ../core/src/pluralize.ts
+/** Selects the noun or verb form that agrees with a numeric count. */
+function pluralize(count, singular, plural = `${singular}s`) {
+	return count === 1 ? singular : plural;
+}
+//#endregion
+//#region ../../plugins/content-official/src/index.ts
+/** Neutral starter content used when Aura creates the canonical shared instruction source. */
+const SHARED_INSTRUCTIONS_TEMPLATE = "# Shared agent instructions\n";
+const contentSource = (path) => ({
+	type: "file",
+	url: pluginContentUrl(import.meta.url, path)
+});
+var src_default = definePlugin({
+	apiVersion: 1,
+	id: "official",
+	name: "Aura Official Content",
+	mcpCatalog: [
+		{
+			description: "Connect Atlassian Rovo to Jira and Confluence through Atlassian OAuth.",
+			id: "official/atlassian-rovo",
+			kind: "mcp-server",
+			name: "Atlassian Rovo",
+			source: contentSource("mcp/atlassian-rovo.json"),
+			version: "1.0.0"
+		},
+		{
+			description: "Connect GitHub repositories, issues, and pull requests with a personal token.",
+			id: "official/github",
+			kind: "mcp-server",
+			name: "GitHub",
+			source: contentSource("mcp/github.json"),
+			version: "1.0.0"
+		},
+		{
+			description: "Connect Sentry projects, issues, and telemetry with an auth token.",
+			id: "official/sentry",
+			kind: "mcp-server",
+			name: "Sentry",
+			source: contentSource("mcp/sentry.json"),
+			version: "1.0.0"
+		}
+	],
+	skillDirectories: [{
+		id: "directory:agenticskills",
+		kind: "directory",
+		name: "agenticskills.io",
+		url: "https://agenticskills.io"
+	}],
+	snippets: [
+		{
+			category: "git",
+			description: "Apply clear, consistent conventions to Git commits.",
+			id: "official/commit-conventions",
+			kind: "snippet",
+			name: "Commit conventions",
+			source: contentSource("snippets/commit-conventions.md"),
+			version: "1.0.0"
+		},
+		{
+			category: "safety",
+			description: "Require confirmation before destructive or irreversible operations.",
+			id: "official/ask-before-destructive",
+			kind: "snippet",
+			name: "Ask before destructive operations",
+			source: contentSource("snippets/ask-before-destructive.md"),
+			version: "1.0.0"
+		},
+		{
+			category: "git",
+			description: "Write pull request descriptions that explain intent and validation.",
+			id: "official/pr-descriptions",
+			kind: "snippet",
+			name: "Pull request descriptions",
+			source: contentSource("snippets/pr-descriptions.md"),
+			version: "1.0.0"
+		},
+		{
+			category: "atlassian",
+			description: "Keep Jira issue references consistent across development artifacts.",
+			id: "official/jira-linking",
+			kind: "snippet",
+			name: "Jira issue linking",
+			source: contentSource("snippets/jira-linking.md"),
+			version: "1.0.0"
+		},
+		{
+			category: "atlassian",
+			description: "Reference Confluence without hiding execution-critical context.",
+			id: "official/confluence-references",
+			kind: "snippet",
+			name: "Confluence references",
+			source: contentSource("snippets/confluence-references.md"),
+			version: "1.0.0"
+		},
+		{
+			category: "language",
+			description: "Apply strict and explicit TypeScript typing conventions.",
+			id: "official/typescript-style",
+			kind: "snippet",
+			name: "TypeScript style",
+			source: contentSource("snippets/typescript-style.md"),
+			version: "1.0.0"
+		},
+		{
+			category: "language",
+			description: "Apply typed Python conventions with consistent Ruff validation.",
+			id: "official/python-style",
+			kind: "snippet",
+			name: "Python style",
+			source: contentSource("snippets/python-style.md"),
+			version: "1.0.0"
+		}
+	],
+	version: "0.0.0"
+});
+//#endregion
+//#region ../core/src/manifest/error.ts
+/** A manifest cannot be serialized or written without risking data loss. */
+var AuraManifestError = class extends Error {
+	path;
+	problem;
+	constructor(path, problem, cause) {
+		super(problem.message, { cause });
+		this.name = "AuraManifestError";
+		this.path = path;
+		this.problem = problem;
+	}
+};
+//#endregion
+//#region ../core/src/manifest/protocol.ts
+/** Resolves the manifest protocol path against one captured home directory. */
+function resolveAuraManifestPath(homeDir) {
+	return join(homeDir, "agents", "aura.json");
+}
+//#endregion
+//#region ../core/src/values.ts
+/**
+* Reading values back out of unknown data: thrown errors and parsed JSON.
+*
+* These say nothing about any one feature: every module that catches a Node filesystem rejection
+* or narrows a parsed document needs them, so they live in one place rather than accumulating
+* per-directory copies that drift apart.
+*/
+/** The `errno` code of a Node filesystem failure, when the value is one. */
+function errorCode(error) {
+	return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Narrows an unknown parsed value to a plain object. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region ../core/src/manifest/schema-values.ts
+var AuraManifestValidationError = class extends Error {
+	jsonPath;
+	constructor(jsonPath, message) {
+		super(`${jsonPath}: ${message}`);
+		this.name = "AuraManifestValidationError";
+		this.jsonPath = jsonPath;
+	}
+};
+function invalid(path, message) {
+	return new AuraManifestValidationError(path, message);
+}
+function requiredString(value, key, path) {
+	const field = value[key];
+	if (typeof field !== "string") throw invalid(`${path}.${key}`, "must be a string");
+	return field;
+}
+function requiredBoolean(value, key, path) {
+	const field = value[key];
+	if (typeof field !== "boolean") throw invalid(`${path}.${key}`, "must be a boolean");
+	return field;
+}
+/**
+* Narrows a value the top-level walk has already normalized.
+*
+* The section helpers run over subtrees of that walk, so they check shape and hand the existing
+* frozen object back rather than copying and freezing it a second time.
+*/
+function requiredObject(value, path) {
+	if (!isJsonObject(value)) throw invalid(path, "must be an object");
+	return value;
+}
+function stringArray(value, path) {
+	if (!Array.isArray(value)) throw invalid(path, "must be an array");
+	return Object.freeze(value.map((candidate, index) => {
+		if (typeof candidate !== "string") throw invalid(`${path}[${String(index)}]`, "must be a string");
+		return candidate;
+	}));
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region ../core/src/manifest/schema-checks.ts
+const CHECK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/u;
+const MAX_CHECK_IDS = 256;
+function optionalPreset(value) {
+	if (value === void 0) return {};
+	if (typeof value !== "string" || value.trim().length === 0) throw invalid("$.preset", "must be a non-empty preset reference");
+	return { preset: value };
+}
+/**
+* Validates the four recognized check settings, carrying anything else through untouched.
+*
+* Unknown keys survive on purpose, as they do everywhere else in the manifest: the file is written
+* by Aura and read back by whatever version runs next, so a setting a newer release understands
+* must not be destroyed — or rejected — by an older one that does not. Typo protection belongs
+* where a human is authoring by hand, which is the preset schema and the command line, not here.
+*/
+function optionalChecks(value) {
+	if (value === void 0) return {};
+	const source = requiredObject(value, "$.checks");
+	const enabled = optionalStringArray(source["enabled"], "$.checks.enabled");
+	const disabled = optionalStringArray(source["disabled"], "$.checks.disabled");
+	const conflicts = new Set(enabled ?? []);
+	for (const id of disabled ?? []) if (conflicts.has(id)) throw invalid("$.checks", `must not both enable and disable check ${id}`);
+	return { checks: Object.freeze({
+		...source,
+		...disabled === void 0 ? {} : { disabled },
+		...enabled === void 0 ? {} : { enabled },
+		...optionalSeverity(source["severity"]),
+		...optionalThresholds(source["thresholds"])
+	}) };
+}
+function optionalStringArray(value, path) {
+	if (value === void 0) return;
+	const values = stringArray(value, path);
+	if (values.length > MAX_CHECK_IDS) throw invalid(path, `must contain at most ${String(MAX_CHECK_IDS)} check IDs`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, id] of values.entries()) {
+		if (!CHECK_ID_PATTERN.test(id)) throw invalid(`${path}[${String(index)}]`, "must be a valid check ID");
+		if (seen.has(id)) throw invalid(`${path}[${String(index)}]`, "must not duplicate another check ID");
+		seen.add(id);
+	}
+	return values;
+}
+function optionalSeverity(value) {
+	if (value === void 0) return {};
+	const source = requiredObject(value, "$.checks.severity");
+	if (Object.keys(source).length > MAX_CHECK_IDS) throw invalid("$.checks.severity", `must contain at most ${String(MAX_CHECK_IDS)} entries`);
+	const result = {};
+	for (const [id, candidate] of Object.entries(source)) {
+		if (!CHECK_ID_PATTERN.test(id)) throw invalid(jsonPropertyPath("$.checks.severity", id), "check ID is invalid");
+		if (candidate !== "error" && candidate !== "info" && candidate !== "warn") throw invalid(jsonPropertyPath("$.checks.severity", id), "must be error, info, or warn");
+		defineOwnProperty(result, id, candidate);
+	}
+	return { severity: Object.freeze(result) };
+}
+function optionalThresholds(value) {
+	if (value === void 0) return {};
+	const source = requiredObject(value, "$.checks.thresholds");
+	if (Object.keys(source).length > MAX_CHECK_IDS) throw invalid("$.checks.thresholds", `must contain at most ${String(MAX_CHECK_IDS)} entries`);
+	const result = {};
+	for (const [id, candidate] of Object.entries(source)) {
+		if (!CHECK_ID_PATTERN.test(id)) throw invalid(jsonPropertyPath("$.checks.thresholds", id), "check ID is invalid");
+		defineOwnProperty(result, id, requiredObject(candidate, jsonPropertyPath("$.checks.thresholds", id)));
+	}
+	return { thresholds: Object.freeze(result) };
+}
+//#endregion
+//#region ../core/src/manifest/schema-mcp.ts
+/**
+* Validates the desired MCP state, which is the one section that names credentials.
+*
+* The transport is handed to the SDK parser rather than checked here, so a definition Aura writes
+* into an application's configuration and one it reads back out of a manifest pass through exactly
+* the same rules. What stays here is the bookkeeping around it: which applications an entry claims,
+* and the uniqueness that makes "the server named X" mean one thing.
+*/
+function mcpServers(value) {
+	if (!Array.isArray(value)) throw invalid("$.mcpServers", "must be an array");
+	const claimed = /* @__PURE__ */ new Map();
+	return Object.freeze(value.map((candidate, index) => mcpServer(candidate, `$.mcpServers[${String(index)}]`, claimed)));
+}
+function mcpServer(candidate, path, claimed) {
+	const server = requiredObject(candidate, path);
+	const name = requiredString(server, "name", path);
+	const nameProblem = mcpServerNameProblem(name);
+	if (nameProblem !== void 0) throw invalid(`${path}.name`, nameProblem);
+	const scope = server["scope"];
+	if (scope !== "global" && scope !== "project") throw invalid(`${path}.scope`, "must be either \"global\" or \"project\"");
+	const apps = targetApps(server["apps"], `${path}.apps`, name, scope, claimed);
+	const transport = parseMcpServerDefinition(server["transport"], `${path}.transport`);
+	if ("error" in transport) throw invalid(transport.error.path, transport.error.message);
+	const catalogId = server["catalogId"];
+	if (catalogId !== void 0 && (typeof catalogId !== "string" || catalogId.length === 0)) throw invalid(`${path}.catalogId`, "must be a non-empty string");
+	return Object.freeze({
+		...server,
+		apps,
+		...catalogId === void 0 ? {} : { catalogId },
+		name,
+		scope,
+		transport: transport.value
+	});
+}
+/**
+* Reads the applications one entry targets, refusing any that already has this server.
+*
+* `name` is the key written into each application's own configuration, so two entries claiming it
+* for the same application and scope describe two different desired states for one key. Convergence
+* would resolve that by writing whichever came last, which is not a decision a manifest should
+* leave to iteration order. An entry that targets nothing is refused for a plainer reason: it
+* converges nowhere, and the user who wrote it is watching for it to take effect.
+*/
+function targetApps(value, path, name, scope, claimed) {
+	const entries = stringArray(value, path);
+	if (entries.length === 0) throw invalid(path, "must name at least one application");
+	const key = `${scope}${name}`;
+	const owners = claimed.get(key) ?? /* @__PURE__ */ new Set();
+	claimed.set(key, owners);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, entry] of entries.entries()) {
+		if (entry.length === 0) throw invalid(`${path}[${String(index)}]`, "must be non-empty");
+		if (seen.has(entry)) throw invalid(`${path}[${String(index)}]`, `duplicates ${entry}`);
+		if (owners.has(entry)) throw invalid(`${path}[${String(index)}]`, `duplicates the ${scope} server "${name}" already declared for ${entry}`);
+		seen.add(entry);
+		owners.add(entry);
+	}
+	return entries;
+}
+//#endregion
+//#region ../core/src/manifest/schema.ts
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+const SKILL_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const SKILL_SOURCE_PATTERN = /^(?:directory|driver|plugin):[^\s:]+$/u;
+/**
+* How deep the manifest may nest.
+*
+* The normalizing walk below is recursive, and `JSON.parse` is not: a few kilobytes of `[` parses
+* fine and then overflows the stack on the way back out. A `RangeError` is not one of the failures
+* a manifest can degrade into, so it would escape as an exception and take the whole scan with it.
+* Version 1 nests four levels; this leaves room for extension fields without leaving that open.
+*/
+const MAX_DEPTH = 100;
+/** Validates and normalizes a runtime value into manifest v1 without dropping extension fields. */
+function validateAuraManifest(value) {
+	const source = jsonObject(value, "$", "manifest must be an object");
+	const version = source["schemaVersion"];
+	if (typeof version !== "number" || !Number.isInteger(version)) throw invalid("$.schemaVersion", "must be an integer");
+	if (version !== 1) throw new UnsupportedAuraManifestVersionError(version);
+	return Object.freeze({
+		...source,
+		apps: apps(source["apps"]),
+		...optionalChecks(source["checks"]),
+		mcpServers: mcpServers(source["mcpServers"]),
+		ownership: ownership(source["ownership"]),
+		...optionalPreset(source["preset"]),
+		schemaVersion: 1,
+		skills: skills(source["skills"]),
+		snippets: snippets(source["snippets"])
+	});
+}
+function skills(value) {
+	if (!Array.isArray(value)) throw invalid("$.skills", "must be an array");
+	const ids = /* @__PURE__ */ new Set();
+	return Object.freeze(value.map((candidate, index) => {
+		const path = `$.skills[${String(index)}]`;
+		const skill = requiredObject(candidate, path);
+		const id = requiredString(skill, "id", path);
+		if (id.length > 64 || !SKILL_ID_PATTERN.test(id)) throw invalid(`${path}.id`, "must be a kebab-case skill ID of at most 64 characters");
+		if (ids.has(id)) throw invalid(`${path}.id`, "must not duplicate another selected skill ID");
+		ids.add(id);
+		const source = requiredSkillSource(skill, path);
+		const treeHash = requiredString(skill, "treeHash", path);
+		if (!SHA256_PATTERN.test(treeHash)) throw invalid(`${path}.treeHash`, "must be a lowercase SHA-256 hash");
+		return Object.freeze({
+			...skill,
+			id,
+			pinned: requiredBoolean(skill, "pinned", path),
+			source,
+			treeHash,
+			version: requiredString(skill, "version", path)
+		});
+	}));
+}
+function requiredSkillSource(value, path) {
+	const source = requiredString(value, "source", path);
+	if (!SKILL_SOURCE_PATTERN.test(source)) throw invalid(`${path}.source`, "must be a plugin:, directory:, or driver: source ID");
+	if (source.startsWith("plugin:")) return `plugin:${source.slice(7)}`;
+	if (source.startsWith("directory:")) return `directory:${source.slice(10)}`;
+	return `driver:${source.slice(7)}`;
+}
+var UnsupportedAuraManifestVersionError = class extends Error {
+	actualVersion;
+	constructor(actualVersion) {
+		super(`$.schemaVersion: version ${String(actualVersion)} is not supported`);
+		this.name = "UnsupportedAuraManifestVersionError";
+		this.actualVersion = actualVersion;
+	}
+};
+function apps(value) {
+	const source = requiredObject(value, "$.apps");
+	const result = {};
+	for (const [id, candidate] of Object.entries(source)) {
+		const path = jsonPropertyPath("$.apps", id);
+		const app = requiredObject(candidate, path);
+		defineOwnProperty(result, id, Object.freeze({
+			...app,
+			managed: requiredBoolean(app, "managed", path)
+		}));
+	}
+	return Object.freeze(result);
+}
+function snippets(value) {
+	if (!Array.isArray(value)) throw invalid("$.snippets", "must be an array");
+	return Object.freeze(value.map((candidate, index) => {
+		const path = `$.snippets[${String(index)}]`;
+		const snippet = requiredObject(candidate, path);
+		const hash = requiredString(snippet, "hash", path);
+		if (!SHA256_PATTERN.test(hash)) throw invalid(`${path}.hash`, "must be a lowercase SHA-256 hash");
+		return Object.freeze({
+			...snippet,
+			hash,
+			id: requiredString(snippet, "id", path),
+			pinned: requiredBoolean(snippet, "pinned", path),
+			version: requiredString(snippet, "version", path)
+		});
+	}));
+}
+function ownership(value) {
+	const source = requiredObject(value, "$.ownership");
+	const result = {};
+	for (const [id, candidate] of Object.entries(source)) {
+		const path = jsonPropertyPath("$.ownership", id);
+		const entry = requiredObject(candidate, path);
+		defineOwnProperty(result, id, Object.freeze({
+			...entry,
+			files: stringArray(entry["files"], `${path}.files`),
+			mcpServerNames: stringArray(entry["mcpServerNames"], `${path}.mcpServerNames`)
+		}));
+	}
+	return Object.freeze(result);
+}
+function jsonObject(value, path, message) {
+	if (!isRecord(value)) throw invalid(path, message);
+	return freezeJsonObject(value, path, 0);
+}
+function freezeJsonObject(value, path, depth) {
+	const result = {};
+	for (const [key, candidate] of Object.entries(value)) defineOwnProperty(result, key, jsonValue(candidate, jsonPropertyPath(path, key), depth + 1));
+	return Object.freeze(result);
+}
+function jsonValue(value, path, depth) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value;
+	if (depth > MAX_DEPTH) throw invalid(path, `is nested deeper than the ${String(MAX_DEPTH)} level limit`);
+	if (Array.isArray(value)) return Object.freeze(value.map((candidate, index) => jsonValue(candidate, `${path}[${index}]`, depth + 1)));
+	if (isRecord(value)) return freezeJsonObject(value, path, depth);
+	throw invalid(path, "must be a JSON value");
+}
+//#endregion
+//#region ../core/src/manifest/codec.ts
+/** Creates the writable empty desired state used when no manifest exists yet. */
+function createEmptyAuraManifest() {
+	return Object.freeze({
+		apps: Object.freeze({}),
+		mcpServers: Object.freeze([]),
+		ownership: Object.freeze({}),
+		schemaVersion: 1,
+		skills: Object.freeze([]),
+		snippets: Object.freeze([])
+	});
+}
+/**
+* Parses manifest JSON into a ready or read-only model without exposing source contents.
+*
+* `mode` is the file's observed permission bits, carried through so a caller can tell a manifest
+* that only needs its mode repaired from one that needs nothing at all.
+*/
+function parseAuraManifest(text, path, mode) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch (error) {
+		const location = parseLocation(error, text);
+		const message = `${path} is not valid JSON${location === void 0 ? "" : ` at line ${String(location.line)}, column ${String(location.column)}`}. Restore it from an Aura backup or move it aside before writing; Aura left it unchanged.`;
+		return readOnly(path, {
+			column: location?.column,
+			kind: "invalid-json",
+			line: location?.line,
+			message
+		});
+	}
+	try {
+		return Object.freeze({
+			exists: true,
+			...mode === void 0 ? {} : { mode },
+			path,
+			status: "ready",
+			value: validateAuraManifest(value)
+		});
+	} catch (error) {
+		if (error instanceof UnsupportedAuraManifestVersionError) {
+			const newer = error.actualVersion > 1;
+			return readOnly(path, {
+				actualVersion: error.actualVersion,
+				kind: "unsupported-version",
+				message: newer ? `${path} uses manifest schema version ${String(error.actualVersion)}, but this Aura release supports version ${String(1)}. Upgrade Aura before making changes; checks will continue in read-only mode.` : `${path} uses unsupported manifest schema version ${String(error.actualVersion)}. Restore a version ${String(1)} backup or move the file aside before writing; Aura left it unchanged.`,
+				supportedVersion: 1
+			});
+		}
+		if (error instanceof AuraManifestValidationError) return readOnly(path, {
+			jsonPath: error.jsonPath,
+			kind: "invalid-schema",
+			message: `${path} has an invalid manifest value at ${error.jsonPath}: ${validationMessage(error)}. Restore it from an Aura backup or repair that value before writing; Aura left it unchanged.`
+		});
+		throw error;
+	}
+}
+/** Serializes one validated manifest using the canonical on-disk formatting. */
+function serializeAuraManifest(manifest, path = "Aura manifest") {
+	try {
+		return `${JSON.stringify(validateAuraManifest(manifest), void 0, 2)}\n`;
+	} catch (error) {
+		if (error instanceof UnsupportedAuraManifestVersionError) throw new AuraManifestError(path, {
+			actualVersion: error.actualVersion,
+			kind: "unsupported-version",
+			message: `${path} uses unsupported manifest schema version ${String(error.actualVersion)} and cannot be written.`,
+			supportedVersion: 1
+		}, error);
+		if (error instanceof AuraManifestValidationError) throw new AuraManifestError(path, {
+			jsonPath: error.jsonPath,
+			kind: "invalid-schema",
+			message: `${path} has an invalid manifest value at ${error.jsonPath}: ${validationMessage(error)}.`
+		}, error);
+		throw error;
+	}
+}
+function readOnly(path, problem) {
+	return Object.freeze({
+		exists: true,
+		path,
+		problem,
+		status: "read-only"
+	});
+}
+function validationMessage(error) {
+	const prefix = `${error.jsonPath}: `;
+	return error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message;
+}
+function parseLocation(error, text) {
+	if (!(error instanceof Error)) return;
+	const position = errorPosition(error.message);
+	return position === void 0 ? errorLineColumn(error.message) : locationAt(text, position);
+}
+function errorPosition(message) {
+	const captured = /position (?<position>[0-9]+)/u.exec(message)?.groups?.["position"];
+	const position = Number(captured);
+	return captured !== void 0 && Number.isInteger(position) && position >= 0 ? position : void 0;
+}
+function errorLineColumn(message) {
+	const match = /line (?<line>[0-9]+) column (?<column>[0-9]+)/u.exec(message);
+	const line = Number(match?.groups?.["line"]);
+	const column = Number(match?.groups?.["column"]);
+	return Number.isInteger(line) && Number.isInteger(column) ? {
+		column,
+		line
+	} : void 0;
+}
+function locationAt(text, position) {
+	const lines = text.slice(0, position).split("\n");
+	return {
+		column: (lines.at(-1)?.length ?? 0) + 1,
+		line: lines.length
+	};
+}
+//#endregion
+//#region ../core/src/manifest/write.ts
+/** Refuses any write based on desired state Aura could not safely understand. */
+function assertAuraManifestWritable(state) {
+	if (state.status === "read-only") throw new AuraManifestError(state.path, state.problem);
+}
+/**
+* Builds the fix-plan operation used to persist a complete manifest.
+*
+* `mode` covers creating the file. Holding an existing one at the same mode is not this function's
+* to ask for: the kernel recognizes the manifest by path and enforces it there.
+*/
+function createAuraManifestWriteOperation(state, manifest) {
+	assertAuraManifestWritable(state);
+	return Object.freeze({
+		content: serializeAuraManifest(manifest, state.path),
+		mode: 384,
+		path: state.path,
+		type: "write"
+	});
+}
+//#endregion
+//#region ../core/src/fix-plan/limits.ts
+/**
+* The largest file Aura will write over, remove, or replace with a link.
+*
+* A mutation is only reversible if its previous contents were captured, so this doubles as the
+* ceiling on what one operation retains in memory. Agent configuration is measured in kilobytes;
+* anything approaching this size is not something a fix should be rewriting unattended.
+*/
+const MAX_MUTABLE_FILE_BYTES = 4194304;
+/**
+* The most file content Aura retains across a whole plan.
+*
+* {@link MAX_MUTABLE_FILE_BYTES} bounds one operation; without a plan-wide budget a long plan still
+* multiplies it by the operation count.
+*/
+const MAX_RETAINED_PLAN_BYTES = 67108864;
+/**
+* The combined before/after size above which a preview summarizes instead of rendering a patch.
+*
+* A unified diff is larger than the inputs that produced it, and a preview no human can read is not
+* worth the memory it costs.
+*/
+const MAX_DIFF_BYTES = 262144;
+/**
+* Every mode a plan may request.
+*
+* `FileMode` already closes this set, but a type is erased at runtime and plugins ship as compiled
+* JavaScript. Since the mode reaches `chmod` unchanged, checking it here is what actually keeps a
+* plan from asking for a world-writable or setuid file.
+*/
+const FILE_MODES = /* @__PURE__ */ new Set([
+	384,
+	420,
+	448,
+	493
+]);
+//#endregion
+//#region ../core/src/fix-plan/diff.ts
+const NULL_PATH = "/dev/null";
+function renderWriteDiff(path, before, content, requestedMode, mode) {
+	const note = modeNote(before, requestedMode, mode);
+	const previous = textOf(before);
+	if (previous === void 0) return renderSummary("write", path, "Binary or oversized file would change.") + note;
+	if (exceedsDiffBudget(previous, content)) return renderSummary("write", path, "File is too large to diff; contents would change.") + note;
+	return renderPatch("write", path, before.kind === "missing" ? NULL_PATH : path, path, previous, content) + note;
+}
+/** Fail-closed write preview used when a semantic redactor cannot safely project both sides. */
+function renderWriteSummary(path, before, requestedMode, mode) {
+	return renderSummary("write", path, "Sensitive MCP configuration would change.") + modeNote(before, requestedMode, mode);
+}
+function renderRemoveDiff(path, before) {
+	if (before.kind === "directory") return renderSummary("remove", path, "Remove empty directory.");
+	const previous = textOf(before);
+	if (previous === void 0) return renderSummary("remove", path, "Binary or oversized file would be removed.");
+	if (exceedsDiffBudget(previous, "")) return renderSummary("remove", path, "File is too large to diff; it would be removed.");
+	return renderPatch("remove", path, path, NULL_PATH, previous, "");
+}
+function renderMoveDiff(sourcePath, destinationPath) {
+	return [
+		`diff --aura move ${sourcePath} ${destinationPath}`,
+		`rename from ${sourcePath}`,
+		`rename to ${destinationPath}`,
+		""
+	].join("\n");
+}
+function renderArchiveDiff(path, relativePath, before, replacement, replacementMode) {
+	const archive = renderSummary("archive", path, `Preserve the original at <backup>/consolidation/${relativePath}.`);
+	if (replacement === void 0) return `${archive}${renderRemoveDiff(path, before)}`;
+	return replacement.type === "symlink" ? `${archive}${renderSymlinkDiff(path, before, replacement.target)}` : `${archive}${renderWriteDiff(path, before, replacement.content, replacement.mode, replacementMode ?? 420)}`;
+}
+function renderSymlinkDiff(path, before, target) {
+	const previous = textOf(before);
+	if (previous === void 0) return renderSummary("symlink", path, `Binary or oversized file would become a link.`);
+	if (exceedsDiffBudget(previous, target)) return renderSummary("symlink", path, "File is too large to diff; it would become a link.");
+	return `${renderPatch("symlink", path, before.kind === "missing" ? NULL_PATH : path, path, previous, `${target}\n`)}link target ${target}\n`;
+}
+/** Describes a conflict in the same shape as a diff, so a renderer can treat previews uniformly. */
+function renderConflict(operation, path, reason) {
+	return renderSummary(operation, path, `Blocked: ${reason}.`);
+}
+function renderPatch(operation, displayPath, oldPath, newPath, oldContent, newContent) {
+	return `diff --aura ${operation} ${displayPath}\n${createTwoFilesPatch(oldPath, newPath, oldContent, newContent, "before", "after", { context: 3 })}`;
+}
+function renderSummary(operation, path, detail) {
+	return [
+		`diff --aura ${operation} ${path}`,
+		detail,
+		""
+	].join("\n");
+}
+/**
+* Says what happens to an existing file's permissions.
+*
+* Two cases are worth a line. A mode that changes is a change the diff itself cannot show, and core
+* only does that to files it owns as protocol. A `mode` a plan asked for and will not get is the
+* commoner one: an existing file keeps whatever the user set, and saying so is the difference
+* between a deliberate choice and a silent one.
+*/
+function modeNote(before, requestedMode, mode) {
+	if (before.kind !== "file") return "";
+	if (before.mode !== mode) return `mode ${formatMode(before.mode)} changes to ${formatMode(mode)}\n`;
+	if (requestedMode !== void 0 && requestedMode !== before.mode) return `mode ${formatMode(requestedMode)} requested; existing mode ${formatMode(before.mode)} is preserved\n`;
+	return "";
+}
+function formatMode(mode) {
+	return `0o${mode.toString(8).padStart(3, "0")}`;
+}
+function exceedsDiffBudget(before, after) {
+	return Buffer.byteLength(before, "utf8") + Buffer.byteLength(after, "utf8") > MAX_DIFF_BYTES;
+}
+function textOf(state) {
+	switch (state.kind) {
+		case "directory":
+		case "unsupported": return;
+		case "file": return state.content !== void 0 && isUtf8(state.content) ? state.content.toString("utf8") : void 0;
+		case "missing": return "";
+		case "symlink": return `${state.target}\n`;
+	}
+}
+//#endregion
+//#region ../core/src/fix-plan/write-redaction.ts
+const REDACTORS = /* @__PURE__ */ new WeakMap();
+/**
+* Paths some operation has asked to have redacted, kept beside the identity-keyed registry above.
+*
+* The registry is keyed on the operation object, so anything that copies an operation between
+* planning and preview silently drops its masker — and the symptom of that would be a credential
+* rendered into a diff rather than an error. Remembering the path as well turns the silent case
+* into the conservative one: a write to a path that has ever needed masking and arrives without a
+* masker gets a summary, not a patch.
+*/
+const REDACTED_PATHS = /* @__PURE__ */ new Set();
+/** Associates a semantic content masker with a write without changing the public operation schema. */
+function rememberWriteRedactor(operation, redactor) {
+	const existing = REDACTORS.get(operation) ?? [];
+	REDACTORS.set(operation, [...existing, redactor]);
+	REDACTED_PATHS.add(operation.path);
+}
+/**
+* Wraps an adapter's transform so a projection that could not account for every field fails closed.
+*
+* `unresolved` names the fields whose server entry this content does not contain. That is not the
+* same as "nothing to mask": a rewritten side legitimately has nothing left to mask and reports no
+* unresolved fields, while a document shaped in a way the adapter cannot navigate reports them all
+* and still holds the credential.
+*/
+function mcpSecretRedactor(transform, sightings) {
+	return (content) => {
+		const redaction = transform.redact({
+			content,
+			sightings
+		});
+		return redaction === void 0 || redaction.unresolved.length > 0 ? void 0 : redaction.content;
+	};
+}
+/** Renders a write only after every registered semantic masker succeeds on both diff sides. */
+function renderRedactedWriteDiff(operations, path, before, content, requestedMode, mode) {
+	const redactors = operations.flatMap((operation) => REDACTORS.get(operation) ?? []);
+	if (redactors.length === 0) return REDACTED_PATHS.has(path) ? renderWriteSummary(path, before, requestedMode, mode) : renderWriteDiff(path, before, content, requestedMode, mode);
+	const next = redactAll(redactors, content);
+	if (next === void 0) return renderWriteSummary(path, before, requestedMode, mode);
+	if (before.kind !== "file" || before.content === void 0) return renderWriteDiff(path, before, next, requestedMode, mode);
+	const previous = redactAll(redactors, before.content.toString("utf8"));
+	if (previous === void 0) return renderWriteSummary(path, before, requestedMode, mode);
+	return renderWriteDiff(path, {
+		...before,
+		content: Buffer.from(previous, "utf8")
+	}, next, requestedMode, mode);
+}
+function redactAll(redactors, content) {
+	let projected = content;
+	for (const redact of redactors) {
+		const result = safeRedact(redact, projected);
+		if (result === void 0) return;
+		projected = result;
+	}
+	return projected;
+}
+function safeRedact(redact, content) {
+	try {
+		return redact(content);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region ../core/src/managed-block/protocol.ts
+/** Distribution-independent outer marker opening Aura-managed content. */
+const AURA_MANAGED_BLOCK_BEGIN = "<!-- aura:begin -->";
+/** Distribution-independent outer marker closing Aura-managed content. */
+const AURA_MANAGED_BLOCK_END = "<!-- aura:end -->";
+/** Prefix shared by every Aura snippet opening marker. */
+const AURA_MANAGED_SNIPPET_BEGIN_PREFIX = "<!-- aura:begin id=";
+/** Prefix shared by every Aura snippet closing marker. */
+const AURA_MANAGED_SNIPPET_END_PREFIX = "<!-- aura:end id=";
+/** Human-facing ownership warning rendered once inside the outer block. */
+const AURA_MANAGED_BLOCK_NOTICE = "Managed by Aura. Edit via the Aura CLI; manual edits to this block are overwritten.";
+const MANAGED_SNIPPET_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+const MANAGED_SNIPPET_HASH_PATTERN = /^[0-9a-f]{64}$/;
+/** Whether an id is both line-safe and legal inside an HTML comment. */
+function isManagedSnippetId(id) {
+	return MANAGED_SNIPPET_ID_PATTERN.test(id) && !id.includes("--");
+}
+/**
+* Normalizes snippet text to the bytes covered by the managed-block hash protocol.
+*
+* Trailing newlines are trimmed by scanning rather than with `/\n+$/`, whose backtracking is
+* quadratic when a long newline run does not reach the end of the string.
+*/
+function canonicalizeManagedSnippet(content) {
+	const normalized = content.replace(/\r\n?/g, "\n");
+	let end = normalized.length;
+	while (end > 0 && normalized[end - 1] === "\n") end -= 1;
+	return `${normalized.slice(0, end)}\n`;
+}
+/** Computes the protocol hash for text already in {@link canonicalizeManagedSnippet} form. */
+function hashCanonicalManagedSnippet(canonical) {
+	return createHash("sha256").update(canonical, "utf8").digest("hex");
+}
+/** Computes the protocol hash for a snippet's canonical UTF-8 contents. */
+function hashManagedSnippet(content) {
+	return hashCanonicalManagedSnippet(canonicalizeManagedSnippet(content));
+}
+//#endregion
+//#region ../core/src/managed-block/parse-state.ts
+function collectMarkerValidation(marker, line, problems) {
+	if (!isManagedSnippetId(marker.id)) addProblem(problems, "invalid-snippet-id", line.number, `Snippet ID "${marker.id}" is not safe inside an HTML comment marker.`);
+	if (marker.kind === "snippet-begin" && !MANAGED_SNIPPET_HASH_PATTERN.test(marker.hash)) addProblem(problems, "invalid-hash", line.number, `Snippet "${marker.id}" must declare a lowercase 64-character SHA-256 hash.`);
+}
+function closeSnippet(snippet, end, source) {
+	const content = source.slice(snippet.contentStart, end.start);
+	const computedHash = hashManagedSnippet(content);
+	return Object.freeze({
+		computedHash,
+		content,
+		contentEndOffset: end.start,
+		contentStartOffset: snippet.contentStart,
+		endLine: end.number,
+		endOffset: end.end,
+		hashMatches: computedHash === snippet.storedHash,
+		id: snippet.id,
+		startLine: snippet.startLine,
+		startOffset: snippet.startOffset,
+		storedHash: snippet.storedHash
+	});
+}
+function closeBlock(block, end) {
+	return Object.freeze({
+		endLine: end.number,
+		endOffset: end.end,
+		snippets: Object.freeze(block.snippets),
+		startLine: block.start.number,
+		startOffset: block.start.start,
+		unmanagedContent: block.unmanaged.join("")
+	});
+}
+function addProblem(problems, code, line, message) {
+	problems.push(Object.freeze({
+		code,
+		line,
+		message
+	}));
+}
+//#endregion
+//#region ../core/src/managed-block/marker-handlers.ts
+function handleMarkerOutsideBlock(marker, line, blocks, problems) {
+	if (marker.kind === "block-begin") {
+		if (blocks.length > 0) addProblem(problems, "duplicate-block", line.number, "Aura files may contain only one managed block.");
+		return {
+			acceptsNotice: true,
+			snippets: [],
+			snippetIds: /* @__PURE__ */ new Set(),
+			start: line,
+			unmanaged: []
+		};
+	}
+	if (marker.kind === "block-end") addProblem(problems, "orphan-outer-end", line.number, "Found an Aura outer end marker without a matching begin marker.");
+	else if (marker.kind === "malformed") addProblem(problems, "malformed-marker", line.number, "Found a malformed Aura marker.");
+	else {
+		collectMarkerValidation(marker, line, problems);
+		addProblem(problems, "orphan-snippet-marker", line.number, "Found an Aura snippet marker outside a managed block.");
+	}
+}
+function handleMarkerInsideBlock(marker, line, block, problems) {
+	if (marker.kind === "block-end") return { closed: closeBlock(block, line) };
+	if (marker.kind === "snippet-begin") {
+		collectMarkerValidation(marker, line, problems);
+		if (block.snippetIds.has(marker.id)) addProblem(problems, "duplicate-snippet", line.number, `Snippet ID "${marker.id}" appears more than once in the managed block.`);
+		block.snippetIds.add(marker.id);
+		return { snippet: {
+			contentStart: line.end,
+			id: marker.id,
+			startLine: line.number,
+			startOffset: line.start,
+			storedHash: marker.hash
+		} };
+	} else if (marker.kind === "snippet-end") {
+		collectMarkerValidation(marker, line, problems);
+		addProblem(problems, "orphan-snippet-marker", line.number, "Found a snippet end marker without a matching begin marker.");
+	} else addProblem(problems, "malformed-marker", line.number, "Found a malformed Aura marker.");
+	return {};
+}
+function handleMarkerInsideSnippet(marker, line, block, snippet, source, problems) {
+	if (marker.kind === "snippet-end") {
+		collectMarkerValidation(marker, line, problems);
+		if (marker.id !== snippet.id) addProblem(problems, "mismatched-snippet-end", line.number, `Snippet "${snippet.id}" ends with marker for "${marker.id}".`);
+		block.snippets.push(closeSnippet(snippet, line, source));
+		return {};
+	}
+	if (marker.kind === "block-end") {
+		addProblem(problems, "outer-end-before-snippet-end", line.number, `Outer block ends before snippet "${snippet.id}" closes.`);
+		return { closedBlock: closeBlock(block, line) };
+	}
+	if (marker.kind === "snippet-begin") {
+		collectMarkerValidation(marker, line, problems);
+		addProblem(problems, "nested-snippet", line.number, `Snippet "${marker.id}" begins before snippet "${snippet.id}" ends.`);
+	} else addProblem(problems, "malformed-marker", line.number, "Found a malformed Aura marker.");
+	return { snippet };
+}
+//#endregion
+//#region ../core/src/managed-block/markers.ts
+/** Parses exact protocol lines; callers suppress this inside Markdown fences. */
+function parseMarker(line) {
+	if (line === "<!-- aura:begin -->") return { kind: "block-begin" };
+	if (line === "<!-- aura:end -->") return { kind: "block-end" };
+	if (line.startsWith("<!-- aura:begin id=")) {
+		const match = /^<!-- aura:begin id=(\S+) sha256=(\S+) -->$/.exec(line);
+		return match === null || match[1] === void 0 || match[2] === void 0 ? { kind: "malformed" } : {
+			hash: match[2],
+			id: match[1],
+			kind: "snippet-begin"
+		};
+	}
+	if (line.startsWith("<!-- aura:end id=")) {
+		const match = /^<!-- aura:end id=(\S+) -->$/.exec(line);
+		return match === null || match[1] === void 0 ? { kind: "malformed" } : {
+			id: match[1],
+			kind: "snippet-end"
+		};
+	}
+	if (line.startsWith("<!-- aura:begin") || line.startsWith("<!-- aura:end")) return { kind: "malformed" };
+}
+//#endregion
+//#region ../core/src/managed-block/read.ts
+/** Parses the single Aura-managed block in a source string without touching the filesystem. */
+function readManagedBlock(source) {
+	const state = {
+		block: void 0,
+		blocks: [],
+		fence: void 0,
+		notes: [],
+		problems: [],
+		snippet: void 0,
+		suppressedMarkerLine: void 0
+	};
+	for (const line of splitSourceLines$1(source)) processSourceLine(state, line, source);
+	return finishRead(state);
+}
+function processSourceLine(state, line, source) {
+	const protectedByFence = advanceFenceState(state, line);
+	const marker = protectedByFence ? void 0 : parseMarker(line.text);
+	if (marker === void 0) {
+		collectPlainLine(source, line, protectedByFence, state.block, state.snippet, state.notes);
+		return;
+	}
+	if (state.block === void 0) {
+		state.block = handleMarkerOutsideBlock(marker, line, state.blocks, state.problems);
+		return;
+	}
+	applyMarkerInsideBlock(state, state.block, marker, line, source);
+}
+/** Advances fence state, remembering the first marker the currently open fence is hiding. */
+function advanceFenceState(state, line) {
+	const previousFence = state.fence;
+	state.fence = advanceMarkdownFence(line.text, state.fence);
+	if (state.fence === void 0) {
+		state.suppressedMarkerLine = void 0;
+		return previousFence !== void 0;
+	}
+	if (state.suppressedMarkerLine === void 0 && line.text.startsWith("<!-- aura:")) state.suppressedMarkerLine = line.number;
+	return true;
+}
+function applyMarkerInsideBlock(state, block, marker, line, source) {
+	block.acceptsNotice = false;
+	if (marker.kind === "block-begin") {
+		addProblem(state.problems, "nested-block", line.number, "Aura managed blocks cannot be nested.");
+		return;
+	}
+	if (state.snippet === void 0) {
+		const outcome = handleMarkerInsideBlock(marker, line, block, state.problems);
+		closeBlockIfEnded(state, outcome.closed);
+		state.snippet = outcome.snippet;
+		return;
+	}
+	const outcome = handleMarkerInsideSnippet(marker, line, block, state.snippet, source, state.problems);
+	closeBlockIfEnded(state, outcome.closedBlock);
+	state.snippet = outcome.snippet;
+}
+function closeBlockIfEnded(state, closed) {
+	if (closed !== void 0) {
+		state.blocks.push(closed);
+		state.block = void 0;
+	}
+}
+function finishRead(state) {
+	if (state.fence !== void 0 && state.suppressedMarkerLine !== void 0) state.notes.push(Object.freeze({
+		code: "unterminated-fence",
+		line: state.suppressedMarkerLine,
+		message: "An unclosed Markdown fence made this Aura marker ordinary text. Close the fence if the marker was meant to be read."
+	}));
+	if (state.snippet !== void 0) addProblem(state.problems, "incomplete-snippet", state.snippet.startLine, `Snippet "${state.snippet.id}" has no closing marker.`);
+	if (state.block !== void 0) addProblem(state.problems, "incomplete-outer-block", state.block.start.number, "Aura managed block has no closing marker.");
+	const frozenNotes = Object.freeze(state.notes);
+	if (state.problems.length > 0) return {
+		notes: frozenNotes,
+		problems: Object.freeze(state.problems),
+		status: "invalid"
+	};
+	const managedBlock = state.blocks[0];
+	return managedBlock === void 0 ? {
+		notes: frozenNotes,
+		status: "absent"
+	} : {
+		block: managedBlock,
+		notes: frozenNotes,
+		status: "present"
+	};
+}
+function collectPlainLine(source, line, protectedByFence, block, snippet, notes) {
+	if (block === void 0 || snippet !== void 0) return;
+	if (!protectedByFence && block.acceptsNotice && line.text === "Managed by Aura. Edit via the Aura CLI; manual edits to this block are overwritten.") {
+		block.acceptsNotice = false;
+		return;
+	}
+	block.acceptsNotice = false;
+	block.unmanaged.push(source.slice(line.start, line.end));
+	notes.push(Object.freeze({
+		code: "unmanaged-content",
+		line: line.number,
+		message: "Content outside a tagged snippet will be moved below the Aura block."
+	}));
+}
+//#endregion
+//#region ../core/src/managed-block/scan.ts
+/**
+* Finds protocol markers the reader would honour, applying the same fence rules as
+* {@link readManagedBlock} so fenced marker examples stay ordinary text.
+*/
+function scanForMarkers(text) {
+	let fence;
+	let markerLine;
+	for (const line of splitSourceLines$1(text)) {
+		const previousFence = fence;
+		fence = advanceMarkdownFence(line.text, fence);
+		if (previousFence !== void 0 || fence !== void 0) continue;
+		if (markerLine === void 0 && parseMarker(line.text) !== void 0) markerLine = line.number;
+	}
+	return {
+		markerLine,
+		unterminatedFence: fence !== void 0
+	};
+}
+/**
+* Rejects content that would escape its own snippet. Written verbatim, a marker inside a snippet
+* body reopens or closes the protocol, and the resulting file parses as invalid forever — so the
+* damage has to be caught before the write, not after.
+*
+* Every write path shares this guard. A narrower path that skipped it would be a way to write the
+* exact bytes the wider one refuses, and the file it corrupts is the same file either way.
+*/
+function managedSnippetContentProblems(id, canonical) {
+	const scan = scanForMarkers(canonical);
+	if (scan.markerLine !== void 0) return Object.freeze([Object.freeze({
+		code: "invalid-snippet-content",
+		message: `Snippet "${id}" declares an Aura marker on content line ${String(scan.markerLine)}. Wrap marker examples in a Markdown fence.`
+	})]);
+	if (scan.unterminatedFence) return Object.freeze([Object.freeze({
+		code: "invalid-snippet-content",
+		message: `Snippet "${id}" ends inside an unclosed Markdown fence, which would hide every marker after it. Close the fence.`
+	})]);
+	return Object.freeze([]);
+}
+/**
+* Drops every protocol line the reader honours, plus the notice that follows an opening marker,
+* leaving handwritten text byte-for-byte. Fenced marker examples survive because the reader never
+* treated them as protocol in the first place.
+*/
+function stripManagedMarkers(source) {
+	const kept = [];
+	let fence;
+	let afterBlockBegin = false;
+	for (const line of splitSourceLines$1(source)) {
+		const previousFence = fence;
+		fence = advanceMarkdownFence(line.text, fence);
+		const marker = previousFence !== void 0 || fence !== void 0 ? void 0 : parseMarker(line.text);
+		if (marker !== void 0) {
+			afterBlockBegin = marker.kind === "block-begin";
+			continue;
+		}
+		if (afterBlockBegin && line.text === "Managed by Aura. Edit via the Aura CLI; manual edits to this block are overwritten.") {
+			afterBlockBegin = false;
+			continue;
+		}
+		afterBlockBegin = false;
+		kept.push(source.slice(line.start, line.end));
+	}
+	return kept.join("");
+}
+//#endregion
+//#region ../core/src/managed-block/reconcile-desired.ts
+function prepareDesiredSnippets(snippets, options) {
+	const ids = /* @__PURE__ */ new Set();
+	const preserved = new Set(options.preserveSnippetIds ?? []);
+	const prepared = [];
+	const problems = [];
+	for (const snippet of snippets) {
+		if (!isManagedSnippetId(snippet.id)) problems.push(Object.freeze({
+			code: "invalid-snippet-id",
+			message: `Snippet ID "${snippet.id}" is not safe inside an HTML comment marker.`
+		}));
+		if (ids.has(snippet.id)) problems.push(Object.freeze({
+			code: "duplicate-snippet",
+			message: `Desired snippet ID "${snippet.id}" appears more than once.`
+		}));
+		if (preserved.has(snippet.id)) problems.push(Object.freeze({
+			code: "duplicate-snippet",
+			message: `Snippet ID "${snippet.id}" is both desired and preserved; writing both would duplicate it.`
+		}));
+		ids.add(snippet.id);
+		const canonical = canonicalizeManagedSnippet(snippet.content);
+		problems.push(...managedSnippetContentProblems(snippet.id, canonical));
+		prepared.push({
+			canonical,
+			hash: hashCanonicalManagedSnippet(canonical),
+			id: snippet.id,
+			kind: "desired"
+		});
+	}
+	return {
+		prepared,
+		problems: Object.freeze(problems)
+	};
+}
+//#endregion
+//#region ../core/src/managed-block/reconcile-ledger.ts
+function renderLedgerSnippets(source, block, desired, options) {
+	if (block === void 0 || options.ownedSnippetIds === void 0) return desired;
+	const controlled = controlledSnippetIds(desired, options);
+	const preserved = new Set(options.preserveSnippetIds ?? []);
+	const remaining = [...desired];
+	const rendered = [];
+	for (const snippet of block.snippets) {
+		if (preserved.has(snippet.id) || !controlled.has(snippet.id)) {
+			rendered.push({
+				id: snippet.id,
+				kind: "preserved",
+				raw: source.slice(snippet.startOffset, snippet.endOffset)
+			});
+			continue;
+		}
+		const replacement = remaining.shift();
+		if (replacement !== void 0) rendered.push(replacement);
+	}
+	rendered.push(...remaining);
+	return rendered;
+}
+function controlledSnippetIds(desired, options) {
+	return /* @__PURE__ */ new Set([...options.ownedSnippetIds ?? [], ...desired.map((snippet) => snippet.id)]);
+}
+function preservedUnownedNotes(block, desired, options) {
+	if (block === void 0 || options.ownedSnippetIds === void 0) return [];
+	const controlled = controlledSnippetIds(desired, options);
+	return block.snippets.filter((snippet) => !controlled.has(snippet.id)).map((snippet) => Object.freeze({
+		code: "preserved-unowned-snippet",
+		line: snippet.startLine,
+		message: `Snippet "${snippet.id}" is not recorded in Aura's manifest; its section was preserved.`
+	}));
+}
+//#endregion
+//#region ../core/src/managed-block/reconcile.ts
+/**
+* Reconciles one source string against the complete ordered set of desired snippets.
+*
+* Existing hash mismatches remain observable through {@link readManagedBlock}, but reconciliation
+* deliberately replaces managed content with the desired canonical version, reporting each
+* discarded hand edit as an `overwritten-snippet` note. Invalid structures fail closed and return
+* the original source unchanged unless the caller opts into `onInvalid: "repair"`.
+*/
+function reconcileManagedBlock(source, desiredSnippets, options = {}) {
+	return reconcileParsedManagedBlock(source, readManagedBlock(source), desiredSnippets, options);
+}
+/**
+* {@link reconcileManagedBlock}, for a caller that already parsed `source`.
+*
+* `current` must be `readManagedBlock(source)` for the same string; passing a result read from
+* anything else splices content at offsets that no longer describe the source.
+*/
+function reconcileParsedManagedBlock(source, current, desiredSnippets, options = {}) {
+	const desired = prepareDesiredSnippets(desiredSnippets, options);
+	if (desired.problems.length > 0) return invalidResult(source, current.notes, desired.problems);
+	const hiddenMarker = current.notes.find((note) => note.code === "unterminated-fence");
+	if (hiddenMarker !== void 0) return invalidResult(source, current.notes, [Object.freeze({
+		code: "unterminated-fence",
+		line: hiddenMarker.line,
+		message: hiddenMarker.message
+	})]);
+	if (current.status !== "invalid") {
+		const block = current.status === "present" ? current.block : void 0;
+		const rendered = renderLedgerSnippets(source, block, desired.prepared, options);
+		const notes = [
+			...current.notes,
+			...overwrittenNotes(current, desired.prepared, options),
+			...preservedUnownedNotes(block, desired.prepared, options)
+		];
+		return settle(source, buildContent(source, rendered, current), notes);
+	}
+	if (options.onInvalid !== "repair") return invalidResult(source, current.notes, current.problems);
+	if (options.ownedSnippetIds !== void 0) return invalidResult(source, current.notes, current.problems);
+	const stripped = stripManagedMarkers(source);
+	const repaired = readManagedBlock(stripped);
+	if (repaired.status === "invalid") return invalidResult(source, current.notes, current.problems);
+	const notes = [...current.notes, ...repairNotes(current.problems)];
+	return settle(source, buildContent(stripped, desired.prepared, repaired), notes);
+}
+function buildContent(source, prepared, current) {
+	if (prepared.length === 0) return current.status === "absent" ? source : source.slice(0, current.block.startOffset) + current.block.unmanagedContent + source.slice(current.block.endOffset);
+	const lineEnding = detectLineEnding$1(source);
+	if (current.status === "absent") return `${source}${source.length === 0 || source.endsWith("\n") ? "" : lineEnding}${renderManagedBlock(prepared, lineEnding, true)}`;
+	const replacement = renderManagedBlock(prepared, lineEnding, source[current.block.endOffset - 1] === "\n" || current.block.unmanagedContent.length > 0);
+	if (current.block.unmanagedContent.length === 0 && replacement === source.slice(current.block.startOffset, current.block.endOffset)) return source;
+	return source.slice(0, current.block.startOffset) + replacement + current.block.unmanagedContent + source.slice(current.block.endOffset);
+}
+function renderManagedBlock(snippets, lineEnding, endsWithLineEnding) {
+	const parts = [
+		AURA_MANAGED_BLOCK_BEGIN,
+		lineEnding,
+		AURA_MANAGED_BLOCK_NOTICE,
+		lineEnding
+	];
+	for (const snippet of snippets) {
+		if (snippet.kind === "preserved") {
+			parts.push(snippet.raw);
+			continue;
+		}
+		const content = lineEnding === "\n" ? snippet.canonical : snippet.canonical.replaceAll("\n", lineEnding);
+		parts.push(`${AURA_MANAGED_SNIPPET_BEGIN_PREFIX}${snippet.id} sha256=${snippet.hash} -->`, lineEnding, content, `${AURA_MANAGED_SNIPPET_END_PREFIX}${snippet.id} -->`, lineEnding);
+	}
+	parts.push(AURA_MANAGED_BLOCK_END);
+	if (endsWithLineEnding) parts.push(lineEnding);
+	return parts.join("");
+}
+function overwrittenNotes(current, desired, options) {
+	if (current.status === "absent") return [];
+	const controlled = controlledSnippetIds(desired, options);
+	const desiredById = new Map(desired.map((snippet) => [snippet.id, snippet]));
+	const preserved = new Set(options.preserveSnippetIds ?? []);
+	return current.block.snippets.flatMap((snippet) => {
+		if (options.ownedSnippetIds !== void 0 && !controlled.has(snippet.id) || preserved.has(snippet.id) || !handEdited(snippet, options)) return [];
+		const replacement = desiredById.get(snippet.id);
+		if (replacement === void 0) return [Object.freeze({
+			code: "removed-snippet",
+			line: snippet.startLine,
+			message: `Snippet "${snippet.id}" was edited by hand since Aura wrote it; the edit is being removed.`
+		})];
+		if (replacement.hash === snippet.computedHash) return [];
+		return [Object.freeze({
+			code: "overwritten-snippet",
+			line: snippet.startLine,
+			message: `Snippet "${snippet.id}" was edited by hand since Aura wrote it; the edit is being replaced.`
+		})];
+	});
+}
+/**
+* Whether a section differs from what Aura last recorded for it.
+*
+* The marker hash is written by whoever wrote the marker, so a re-stamped section certifies itself
+* and `hashMatches` alone cannot tell a hand edit from a catalog upgrade. The manifest is the only
+* record the editor did not control; fall back to the marker only when there is no manifest entry.
+*/
+function handEdited(snippet, options) {
+	const previousHash = options.previousSnippetHashes?.get(snippet.id);
+	return previousHash === void 0 ? !snippet.hashMatches : previousHash !== snippet.computedHash;
+}
+function repairNotes(problems) {
+	return problems.map((problem) => Object.freeze({
+		code: "repaired-invalid-block",
+		line: problem.line,
+		message: `Rebuilt the managed block to repair: ${problem.message}`
+	}));
+}
+function invalidResult(source, notes, problems) {
+	return Object.freeze({
+		content: source,
+		notes: Object.freeze([...notes]),
+		problems,
+		status: "invalid"
+	});
+}
+function settle(source, content, notes) {
+	return content === source ? Object.freeze({
+		content: source,
+		notes: Object.freeze([...notes]),
+		status: "unchanged"
+	}) : Object.freeze({
+		content,
+		notes: Object.freeze([...notes]),
+		status: "updated"
+	});
+}
+//#endregion
+//#region ../core/src/workspace/mcp-classify.ts
+/**
+* Splits desired servers into the ones Aura may write and the collisions a person has to settle.
+*
+* Scope is part of identity here. A server named `docs` in a project `.mcp.json` is not the `docs`
+* the manifest wants in user-level configuration, and treating them as one either blocks a write
+* that would not have collided or skips one that never happened.
+*/
+function classifyDesired(desired, ledgerNames, state) {
+	const ledger = new Set(ledgerNames);
+	const owned = [];
+	const blockers = [];
+	for (const entry of desired) {
+		const blocker = collisionBlocker(entry, ledger, state);
+		if (blocker === "owned") owned.push(entry);
+		else if (blocker !== void 0) blockers.push(blocker);
+	}
+	return {
+		blockers,
+		owned
+	};
+}
+/** `owned` to write it, a blocker to refuse, `undefined` when the config already satisfies it. */
+function collisionBlocker(entry, ledger, state) {
+	if (ledger.has(entry.name)) return "owned";
+	const sameName = (candidate) => candidate.name === entry.name && candidate.scope === entry.scope;
+	const unusable = state.unusable.find(sameName);
+	if (unusable !== void 0) return {
+		message: unusable.reason === "disabled" ? `MCP server ${entry.name} is already declared in this application's ${entry.scope} configuration but is turned off there. Remove or enable it, then run the fix again.` : `MCP server ${entry.name} is already declared in this application's ${entry.scope} configuration in a form Aura does not recognize, so Aura left it unchanged.`,
+		scope: entry.scope,
+		sourceId: unusable.sourceId
+	};
+	const existing = state.servers.filter(sameName);
+	if (existing.length === 0) return "owned";
+	const normalized = normalizeDesired(entry);
+	if ("message" in normalized) return normalized;
+	return existing.every((server) => isDeepStrictEqual(server.transport, normalized.transport)) ? void 0 : {
+		message: `MCP server ${entry.name} already exists outside Aura's ownership ledger and differs from the manifest.`,
+		scope: entry.scope
+	};
+}
+/**
+* Normalizes one desired transport, reporting a manifest Aura refuses to write as a blocker.
+*
+* The manifest is a file a person can edit. One that has acquired a credential literal is not a
+* crash in a check's `detect`; it is something to say out loud and decline to propagate.
+*/
+function normalizeDesired(entry) {
+	try {
+		return { transport: normalizeMcpServerDefinition(entry.transport) };
+	} catch (error) {
+		return {
+			message: error instanceof McpWriteError ? `MCP server ${entry.name} cannot be written as the manifest defines it: ${error.message}` : `MCP server ${entry.name} has a manifest definition Aura cannot represent.`,
+			scope: entry.scope
+		};
+	}
+}
+//#endregion
+//#region ../core/src/workspace/mcp-convergence.ts
+/** Captures adapter source bytes behind a function, keeping them out of the model entirely. */
+function createAppMcpConvergence(adapter, files, state) {
+	const writer = adapter.mcpWrite;
+	if (writer === void 0) return;
+	const targets = [...files.values()].filter((file) => file.spec.kind === "mcp");
+	return (desired, ledgerNames) => {
+		const classified = classifyDesired(desired, ledgerNames, state);
+		if (classified.blockers.length > 0) return blocked(classified.blockers);
+		const scopes = ["global", "project"].map((scope) => planScope(adapter, writer, targets, classified.owned, ledgerNames, scope, state.secretSightings));
+		const blockers = scopes.flatMap((result) => result.blockers);
+		const operations = scopes.flatMap((result) => result.operations);
+		return blockers.length > 0 ? blocked(blockers) : {
+			blockers: [],
+			operations,
+			ownedNames: [...new Set(classified.owned.map((entry) => entry.name))].sort()
+		};
+	};
+}
+function planScope(adapter, writer, targets, desired, ledgerNames, scope, sightings) {
+	const scopedDesired = desired.filter((entry) => entry.scope === scope);
+	const scopedTargets = targets.filter((target) => target.spec.scope === scope);
+	if (scopedDesired.length > 0 && scopedTargets.length === 0) return blockedScope(`${adapter.displayName} has no ${scope}-scope MCP configuration target.`, scope);
+	if (scopedTargets.length > 1) return blockedScope(`${adapter.displayName} declares more than one ${scope}-scope MCP write target.`, scope);
+	const target = scopedTargets[0];
+	return target === void 0 ? {
+		blockers: [],
+		operations: []
+	} : writeScopeTarget(adapter, writer, target, scopedDesired, ledgerNames, scope, sightings);
+}
+function writeScopeTarget(adapter, writer, target, desired, ledgerNames, scope, sightings) {
+	if (!needsTargetWrite(target, desired, ledgerNames)) return {
+		blockers: [],
+		operations: []
+	};
+	const unwritable = targetRefusal(target);
+	if (unwritable !== void 0) return {
+		blockers: [{
+			...unwritable,
+			scope,
+			sourceId: target.spec.id
+		}],
+		operations: []
+	};
+	const written = runWriter(writer, target, desired, ledgerNames);
+	if ("refusal" in written) return {
+		blockers: [{
+			message: written.refusal,
+			path: target.spec.path,
+			scope,
+			sourceId: target.spec.id
+		}],
+		operations: []
+	};
+	if (Buffer.byteLength(written.content, "utf8") > 4194304) return {
+		blockers: [{
+			message: `${adapter.displayName}'s MCP configuration at ${target.spec.path} is larger than Aura will rewrite in one operation, so Aura left it unchanged.`,
+			path: target.spec.path,
+			scope,
+			sourceId: target.spec.id
+		}],
+		operations: []
+	};
+	const operation = {
+		content: written.content,
+		mode: scope === "global" ? 384 : 420,
+		path: target.spec.path,
+		precondition: targetPrecondition(target),
+		type: "write"
+	};
+	rememberMcpRedactor(adapter, operation, target, sightings);
+	return {
+		blockers: [],
+		operations: [operation]
+	};
+}
+/**
+* Registers preview masking only for a target that actually holds an inline credential.
+*
+* Registering unconditionally would cost every convergence preview its diff, because masking has
+* no previous side to project when the fix is creating the file — which is what most MCP-001 fixes
+* do, on a file that by definition has no credentials in it yet.
+*/
+function rememberMcpRedactor(adapter, operation, target, sightings) {
+	const transform = adapter.mcpSecrets;
+	const scoped = sightings.filter((sighting) => sighting.sourceId === target.spec.id);
+	if (transform === void 0 || scoped.length === 0) return;
+	rememberWriteRedactor(operation, mcpSecretRedactor(transform, scoped));
+}
+/** Runs a plugin serializer, treating a thrown error as the refusal it forgot to return. */
+function runWriter(writer, target, desired, ledgerNames) {
+	try {
+		return writer({
+			desired,
+			...target.content === void 0 ? {} : { existingContent: target.content },
+			ledgerNames
+		});
+	} catch {
+		return { refusal: "The MCP configuration serializer failed, so Aura left the file unchanged." };
+	}
+}
+/**
+* What the file must still look like when the plan is applied.
+*
+* The rendered content is this file's own previous bytes with one section replaced, so applying it
+* against a file the application has since rewritten would silently revert that work. Declaring
+* what was read turns the race into a reported conflict.
+*/
+function targetPrecondition(target) {
+	return target.content === void 0 ? { kind: "absent" } : {
+		digest: createHash("sha256").update(target.content, "utf8").digest("hex"),
+		kind: "sha256"
+	};
+}
+function needsTargetWrite(target, desired, ledgerNames) {
+	return (desired.length > 0 || ledgerNames.length > 0) && (target.exists || desired.length > 0);
+}
+/** Why this target cannot be rewritten safely, before a serializer is asked to try. */
+function targetRefusal(target) {
+	const path = target.spec.path;
+	if (target.problem !== void 0 || target.exists && target.content === void 0) return {
+		message: `MCP configuration at ${path} could not be read safely, so Aura left it unchanged.`,
+		path
+	};
+	return (target.size ?? 0) > 4194304 ? {
+		message: `MCP configuration at ${path} is larger than Aura will rewrite in one operation, so Aura left it unchanged.`,
+		path
+	} : void 0;
+}
+function blockedScope(message, scope) {
+	return {
+		blockers: [{
+			message,
+			scope
+		}],
+		operations: []
+	};
+}
+function blocked(blockers) {
+	return {
+		blockers,
+		operations: [],
+		ownedNames: []
+	};
+}
+//#endregion
+//#region ../core/src/workspace/mcp-plan-manifest.ts
+/**
+* Merges preset-required servers under the manifest's own, keyed by scope and name.
+*
+* The manifest is written last and wins, matching the layer precedence everywhere else. A preset
+* that requires a server the user already configured must not silently repoint its transport:
+* a required entry fills a gap, it does not overrule a decision the user recorded.
+*/
+function desiredEntries(model, manifest, appId) {
+	const result = /* @__PURE__ */ new Map();
+	for (const server of [...model.requiredMcpServers ?? [], ...manifest.mcpServers]) if (server.apps.includes(appId)) result.set(`${server.scope}\0${server.name}`, {
+		name: server.name,
+		scope: server.scope,
+		transport: server.transport
+	});
+	return Object.freeze([...result.values()]);
+}
+/** Restates one application's ownership ledger without disturbing the files it also records. */
+function withOwnership(manifest, appId, mcpServerNames) {
+	const previous = manifest.ownership[appId];
+	const ownership = {
+		...manifest.ownership,
+		[appId]: {
+			...previous,
+			files: previous?.files ?? [],
+			mcpServerNames
+		}
+	};
+	return {
+		...manifest,
+		ownership
+	};
+}
+/** Drops one application from a desired server, and the entry entirely once nobody wants it. */
+function withoutServer(manifest, server) {
+	const mcpServers = manifest.mcpServers.flatMap((entry) => {
+		if (entry.name !== server.name || entry.scope !== server.scope) return [entry];
+		const apps = entry.apps.filter((appId) => appId !== server.appId);
+		return apps.length === 0 ? [] : [{
+			...entry,
+			apps
+		}];
+	});
+	return {
+		...manifest,
+		mcpServers
+	};
+}
+//#endregion
+//#region ../core/src/workspace/mcp-plan.ts
+/**
+* Planners for the applications in one scan, held outside the model they belong to.
+*
+* A planner closes over the configuration bytes core read. {@link AppModel} promises those are not
+* retained beside the documents parsed out of them, and a check holds an `AppModel`, so the
+* association lives here instead of on the object: reaching a planner takes this module, which
+* plugin code cannot import.
+*/
+const PLANNERS$1 = /* @__PURE__ */ new WeakMap();
+/** Per-scan memo of what convergence planning produced, keyed by the model it was computed from. */
+const PLANS$1 = /* @__PURE__ */ new WeakMap();
+/** Associates a planner with the app model core just built for it. */
+function rememberMcpConvergence(app, convergence) {
+	PLANNERS$1.set(app, convergence);
+}
+/**
+* Reports only why convergence is impossible, without rendering any file.
+*
+* What a check needs at detect time. The result is shared with {@link planManifestMcpConvergence},
+* so asking two checks and then a fix costs one evaluation rather than three — which matters
+* because evaluating it serializes every declared MCP target in full.
+*/
+function mcpConvergenceBlockers(model, appId) {
+	return planManifestMcpConvergence(model, appId).blockers;
+}
+/** Builds application writes and the ownership-ledger update as one atomic fix plan. */
+function planManifestMcpConvergence(model, appId) {
+	const memo = PLANS$1.get(model) ?? /* @__PURE__ */ new Map();
+	PLANS$1.set(model, memo);
+	const cached = memo.get(appId);
+	if (cached !== void 0) return cached;
+	const computed = computeConvergence(model, appId);
+	memo.set(appId, computed);
+	return computed;
+}
+/**
+* Plans one application's MCP configuration without writing the Aura manifest.
+*
+* Setup uses this primitive to converge several targets and then fold all returned ownership into
+* exactly one manifest write.
+*/
+function planDesiredMcpConvergence(model, desiredManifest, appId) {
+	const manifestState = model.manifest;
+	if (manifestState.status === "read-only") return {
+		blockers: [{
+			message: manifestState.problem.message,
+			path: manifestState.path
+		}],
+		operations: [],
+		ownedNames: desiredManifest.ownership[appId]?.mcpServerNames ?? []
+	};
+	const target = resolvePlanner(model, appId);
+	if ("blockers" in target) return {
+		blockers: target.blockers,
+		operations: [],
+		ownedNames: desiredManifest.ownership[appId]?.mcpServerNames ?? []
+	};
+	if (desiredManifest.apps[appId]?.managed !== true) return {
+		blockers: [],
+		operations: [],
+		ownedNames: desiredManifest.ownership[appId]?.mcpServerNames ?? []
+	};
+	return target.convergence(desiredEntries(model, desiredManifest, appId), desiredManifest.ownership[appId]?.mcpServerNames ?? []);
+}
+/**
+* Removes one Aura-owned server from one application while preserving its selection elsewhere.
+*
+* The configuration write and updated manifest/ownership ledger share one fix plan. Names outside
+* the ledger, unmanaged applications, and identities a name-only ledger cannot distinguish are
+* returned as blockers for a guided check to turn into manual steps.
+*/
+function planMcpServerRemoval(model, server) {
+	const state = model.manifest;
+	if (state.status !== "ready") return {
+		blockers: [{
+			message: state.status === "read-only" ? state.problem.message : "The Aura manifest does not exist, so this server is outside Aura's ownership ledger.",
+			path: state.path
+		}],
+		owned: false
+	};
+	const manifest = state.value;
+	const owned = manifest.ownership[server.appId]?.mcpServerNames.includes(server.name) === true;
+	if (!owned) return {
+		blockers: [{
+			message: `MCP server ${server.name} is outside Aura's ownership ledger.`,
+			scope: server.scope,
+			sourceId: server.sourceId
+		}],
+		owned: false
+	};
+	if (manifest.apps[server.appId]?.managed !== true) return {
+		blockers: [{
+			message: `Application ${server.appId} is not managed by Aura, so Aura will not rewrite its MCP configuration.`,
+			scope: server.scope,
+			sourceId: server.sourceId
+		}],
+		owned: true
+	};
+	if (ambiguousRemoval(model, server)) return {
+		blockers: [{
+			message: `MCP server name ${server.name} identifies more than one configured or desired entry for ${server.appId}, and Aura's ledger cannot remove only one safely.`,
+			scope: server.scope,
+			sourceId: server.sourceId
+		}],
+		owned: true
+	};
+	return {
+		...computeConvergence(model, server.appId, withoutServer(manifest, server)),
+		owned
+	};
+}
+function computeConvergence(model, appId, desiredManifest) {
+	const manifestState = model.manifest;
+	if (manifestState.status === "read-only") return { blockers: [{
+		message: manifestState.problem.message,
+		path: manifestState.path
+	}] };
+	if (manifestState.status === "missing") return { blockers: [] };
+	const manifest = desiredManifest ?? manifestState.value;
+	if (manifest.apps[appId]?.managed !== true) return { blockers: [] };
+	const planned = planDesiredMcpConvergence(model, manifest, appId);
+	const displayName = model.apps.find((app) => app.adapterId === appId)?.displayName ?? appId;
+	return planned.blockers.length > 0 ? { blockers: planned.blockers } : {
+		blockers: [],
+		plan: {
+			operations: ledgeredOperations(manifestState, manifest, appId, planned),
+			summary: `Converge ${displayName}'s MCP configuration from the Aura manifest.`
+		}
+	};
+}
+/** The application writes, plus the ledger update when what Aura owns actually changed. */
+function ledgeredOperations(state, manifest, appId, planned) {
+	const next = withOwnership(manifest, appId, planned.ownedNames);
+	return [...planned.operations, ...isDeepStrictEqual(next, state.value) ? [] : [createAuraManifestWriteOperation(state, next)]];
+}
+function ambiguousRemoval(model, server) {
+	const configured = model.mcpServers.filter((candidate) => candidate.appId === server.appId && candidate.name === server.name);
+	if (configured.length > 1 || configured.some((candidate) => candidate.scope !== server.scope || candidate.sourceId !== server.sourceId)) return true;
+	if (model.manifest.status !== "ready") return false;
+	return model.manifest.value.mcpServers.filter((entry) => entry.name === server.name && entry.apps.includes(server.appId)).length > 1;
+}
+function resolvePlanner(model, appId) {
+	const app = model.apps.find((candidate) => candidate.adapterId === appId);
+	if (app === void 0) return { blockers: [{ message: `Application ${appId} was not detected.` }] };
+	const convergence = PLANNERS$1.get(app);
+	return convergence === void 0 ? { blockers: [{ message: `${app.displayName}'s adapter cannot write MCP configuration.` }] } : {
+		app,
+		convergence
+	};
+}
+//#endregion
+//#region ../core/src/workspace/mcp-secret-plan.ts
+const PLANNERS = /* @__PURE__ */ new WeakMap();
+const PLANS = /* @__PURE__ */ new WeakMap();
+/** Captures raw MCP bytes for remediation behind the same private boundary as convergence. */
+function createAppMcpSecretPlanner(adapter, files, sightings) {
+	const transform = adapter.mcpSecrets;
+	if (transform === void 0) return;
+	return {
+		plan: (sourceId) => {
+			const target = files.get(sourceId);
+			const sourceSightings = sightings.filter((sighting) => sighting.sourceId === sourceId);
+			const supported = sourceSightings.filter(transform.supports);
+			if (target === void 0 || target.spec.kind !== "mcp" || target.content === void 0 || targetRefusal(target) !== void 0 || supported.length === 0) return;
+			let rewritten;
+			try {
+				rewritten = transform.rewrite({
+					content: target.content,
+					sightings: supported
+				});
+			} catch {
+				return;
+			}
+			if ("refusal" in rewritten || rewritten.rewrittenFields.length !== supported.length) return;
+			if (Buffer.byteLength(rewritten.content, "utf8") > 4194304) return;
+			const operation = {
+				content: rewritten.content,
+				mode: target.spec.scope === "global" ? 384 : 420,
+				path: target.spec.path,
+				precondition: targetPrecondition(target),
+				type: "write"
+			};
+			rememberWriteRedactor(operation, mcpSecretRedactor(transform, sourceSightings));
+			return {
+				manualSteps: remediationSteps(target.spec.path, supported),
+				operations: [operation],
+				summary: `Replace inline MCP credentials in ${target.spec.path} with environment references.`
+			};
+		},
+		supports: transform.supports
+	};
+}
+/** Associates a private planner with the app model that exposes only safe sightings. */
+function rememberMcpSecretPlanner(app, planner) {
+	PLANNERS.set(app, planner);
+}
+/**
+* Whether this occurrence has a behavior-preserving adapter rewrite that a plan can actually carry.
+*
+* `supports` only reads the locator's shape, so it answers "could this kind of field be rewritten",
+* not "was this one". Planning is what discovers that the document is spelled in a form the writer
+* cannot edit, and a finding that advertises a guided fix the planner then declines to produce is
+* a dead end for the user. The plan is memoized, so asking it here costs nothing.
+*/
+function canPlanMcpSecretRemediation(model, sighting) {
+	const app = model.apps.find((candidate) => candidate.adapterId === sighting.appId);
+	if ((app === void 0 ? void 0 : PLANNERS.get(app))?.supports(sighting) !== true) return false;
+	return planMcpSecretRemediation(model, sighting) !== void 0;
+}
+/** Builds the one whole-file plan shared by every representable sighting in a source file. */
+function planMcpSecretRemediation(model, sighting) {
+	const key = `${sighting.appId}:${sighting.sourceId}`;
+	const memo = PLANS.get(model) ?? /* @__PURE__ */ new Map();
+	PLANS.set(model, memo);
+	if (memo.has(key)) return memo.get(key);
+	const app = model.apps.find((candidate) => candidate.adapterId === sighting.appId);
+	const plan = (app === void 0 ? void 0 : PLANNERS.get(app))?.plan(sighting.sourceId);
+	memo.set(key, plan);
+	return plan;
+}
+/**
+* What the user has to do around the rewrite, in the order the rewrite makes them possible.
+*
+* Rotation leads the list because moving a credential out of the file does not undo where it has
+* already been. A value that sat inline in configuration is a value that may have reached source
+* control, a shell history, a log, or a copied snippet — which is the reason this check exists, and
+* the reason the same value put behind an environment reference is still the wrong value to keep.
+*/
+function remediationSteps(path, sightings) {
+	const copies = sightings.map((sighting) => `Copy the current value for ${sighting.serverName}.${sighting.field} from ${path} now; Aura will replace it with ${sighting.suggestedEnvName}.`);
+	const exports = [...new Set(sightings.map((sighting) => sighting.suggestedEnvName))].sort().map((name) => `Run \`export ${name}=…\` in the environment that starts the MCP client.`);
+	return [
+		...copies,
+		...exports,
+		"Rotate each credential at its issuer: an inline value may already have been copied elsewhere.",
+		"Run `aura check` again."
+	];
+}
+//#endregion
+//#region ../core/src/workspace/shared-link-plan.ts
+const SHARED_LINK_SNIPPET_ID = "shared-instructions";
+/** Builds the same safe shared-instruction link plan for checks and setup. */
+function planSharedInstructionLink(app, model, options = {}) {
+	const link = options.link ?? app.sharedLink;
+	if (link === void 0) return { blocked: "This adapter does not declare an automatic shared-link mechanism." };
+	const status = entryStatus(app, link.entryPath);
+	const refusal = refuseBefore(app, status);
+	if (refusal !== void 0) return { blocked: refusal };
+	switch (link.kind) {
+		case "import-line": return planImportLine(app, model, link, status, options.sourceContent);
+		case "native-copy": return planNativeCopy(app, model, link, status, options.sourceContent);
+		case "symlink": return planSymlink(app, model, link, status, options);
+	}
+}
+function planImportLine(app, model, link, status, sourceContent) {
+	const source = instructionEntry(app, link.entryPath);
+	if (unreadableInstructionEntry(status, source, sourceContent)) return { blocked: `Something is at ${link.entryPath} that the adapter could not read as an instruction file, so Aura will not replace it. Check whether it is a broken symbolic link.` };
+	const reconciled = reconcileManagedBlock(selectedContent(sourceContent, source), [{
+		content: link.content ?? "",
+		id: SHARED_LINK_SNIPPET_ID
+	}]);
+	if (reconciled.status === "invalid") return { blocked: `The Aura-managed block in ${link.entryPath} is malformed, so Aura will not rewrite the file. Repair or delete the block and run check --fix again.` };
+	if (reconciled.status === "unchanged" && observedStateHolds(sourceContent)) return { plan: convergedPlan$1(app) };
+	return { plan: writePlan(app, link, reconciled.content, model.homeDir) };
+}
+/**
+* Whether what the scan saw still describes the file when this plan is applied.
+*
+* A caller that supplies `sourceContent` is telling us it is about to replace the entry — setup
+* passes `""` for a path it is archiving in the same plan. Reporting "already converged" from the
+* pre-archive state would drop the operation the archive needs as its replacement, and an archive
+* with no replacement removes the original outright.
+*/
+function observedStateHolds(sourceContent) {
+	return sourceContent === void 0;
+}
+function unreadableInstructionEntry(status, source, sourceContent) {
+	return status?.exists === true && source === void 0 && sourceContent === void 0;
+}
+function selectedContent(sourceContent, source) {
+	return sourceContent ?? source?.content ?? "";
+}
+function planNativeCopy(app, model, link, status, sourceContent) {
+	const content = sourceContent ?? instructionEntry(app, link.entryPath)?.content;
+	const refusal = nativeCopyRefusal(status, sourceContent, content, link.content);
+	if (refusal !== void 0) return { blocked: refusal };
+	if (status?.exists === true && content === link.content && observedStateHolds(sourceContent)) return { plan: convergedPlan$1(app) };
+	return { plan: writePlan(app, link, link.content ?? "", model.homeDir) };
+}
+function nativeCopyRefusal(status, sourceContent, content, desired) {
+	return status?.exists === true && sourceContent === void 0 && content !== desired ? "The Aura wrapper path contains different content, so it is treated as user-owned and preserved." : void 0;
+}
+function planSymlink(app, model, link, status, options) {
+	if (status?.exists === true && status.pathKind !== "symlink" && options.sourceContent === void 0) return { blocked: "The existing file is user-owned. Consolidate its content before replacing it with a symlink." };
+	const target = options.symlinkTarget ?? model.sharedInstructions.path;
+	if (observedStateHolds(options.sourceContent) && pointsAt(status, target)) return { plan: convergedPlan$1(app) };
+	return { plan: {
+		operations: [{
+			path: link.entryPath,
+			target,
+			type: "symlink"
+		}],
+		summary: `Link ${app.displayName} to the shared instruction source.`
+	} };
+}
+/**
+* Whether the entry is already a symbolic link to `target`.
+*
+* Both sides are resolved, as everywhere else in this file: `symlinkTarget` is the raw `readlink`
+* result, so comparing it verbatim would re-plan an identical link whenever the same path happens
+* to be spelled differently.
+*/
+function pointsAt(status, target) {
+	if (status?.pathKind !== "symlink" || status.symlinkTarget === void 0) return false;
+	return resolve(status.symlinkTarget) === resolve(target);
+}
+/** No work: the entry already loads the shared source, so the summary says so rather than promising a link. */
+function convergedPlan$1(app) {
+	return {
+		operations: [],
+		summary: `${app.displayName} already loads the shared instruction source.`
+	};
+}
+function refuseBefore(app, status) {
+	if (app.support.status !== "supported") return "Aura does not modify instruction files for an application version it cannot verify.";
+	if (status?.problem !== void 0) return `Aura could not safely read the instruction entry (${status.problem}) and will not overwrite it.`;
+	return status?.pathKind === "directory" ? "The instruction entry is a directory and cannot be replaced automatically." : void 0;
+}
+function writePlan(app, link, content, homeDir) {
+	return {
+		...link.scope === "project" && content.includes(homeDir) ? { manualSteps: [`${link.entryPath} points at the shared source by absolute path, which is specific to this machine and this user. Keep it out of version control — add it to .gitignore or .git/info/exclude.`] } : {},
+		operations: [{
+			content,
+			mode: 420,
+			path: link.entryPath,
+			type: "write"
+		}],
+		summary: `Link ${app.displayName} to the shared instruction source.`
+	};
+}
+function instructionEntry(app, path) {
+	return app.instructionFiles.find((document) => resolve(document.path) === resolve(path));
+}
+function entryStatus(app, path) {
+	return app.sourceFiles.find((file) => resolve(file.spec.path) === resolve(path));
+}
+//#endregion
+//#region ../core/src/workspace/skill-deployment-plan.ts
+/** Plans one manifest skill's link into one adapter-declared directory. */
+function planSkillDeployment(app, model, skillId, directoryId, options = {}) {
+	const directory = app.skillDirectories?.find((candidate) => candidate.id === directoryId);
+	if (directory === void 0) return {
+		kind: "blocked",
+		path: skillId,
+		reason: "The application no longer declares this skills directory."
+	};
+	const path = join(directory.path, skillId);
+	const target = join(sharedSkillsRoot(model.homeDir), skillId);
+	if (!(model.sharedSkills?.some((skill) => skill.id === skillId) === true) && options.assumeShared !== true) return {
+		kind: "blocked",
+		path,
+		reason: `The shared copy at ${target} is missing. Reinstall skill "${skillId}" before deploying it.`
+	};
+	const status = skillDeploymentStatus(app, directory, skillId);
+	if (status === void 0 || !status.exists) return {
+		kind: "planned",
+		path,
+		plan: symlinkPlan(app, path, target)
+	};
+	if (status.problem !== void 0) return {
+		kind: "blocked",
+		path,
+		reason: `Aura could not safely inspect ${path} (${status.problem}) and will not replace it.`
+	};
+	if (status.pathKind !== "symlink" || status.symlinkTarget === void 0) return {
+		kind: "blocked",
+		path,
+		reason: `${path} is not an Aura-managed skill link. Move it aside before deploying skill "${skillId}" there.`
+	};
+	const actualTarget = absoluteTarget(path, status.symlinkTarget);
+	if (actualTarget === resolve(target)) return {
+		kind: "planned",
+		path,
+		plan: convergedPlan(app, skillId)
+	};
+	if (!isAuraOwnedSkillTarget(model.homeDir, actualTarget)) return {
+		kind: "blocked",
+		path,
+		reason: `${path} is not an Aura-managed skill link because it points outside Aura's shared skills directory. It was preserved.`
+	};
+	return {
+		kind: "planned",
+		path,
+		plan: symlinkPlan(app, path, target)
+	};
+}
+/** Finds the captured status for one deployed skill path. */
+function skillDeploymentStatus(app, directory, skillId) {
+	const path = resolve(join(directory.path, skillId));
+	return app.sourceFiles.find((file) => resolve(file.spec.path) === path);
+}
+/** Whether a lexical target lies within Aura's canonical shared skills root. */
+function isAuraOwnedSkillTarget(homeDir, targetPath) {
+	const root = resolve(sharedSkillsRoot(homeDir));
+	const target = resolve(targetPath);
+	const fromRoot = relative(root, target);
+	return fromRoot !== "" && fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`);
+}
+/** Canonical location Aura uses for shared skill trees. */
+function sharedSkillsRoot(homeDir) {
+	return join(homeDir, "agents", "skills");
+}
+function absoluteTarget(path, target) {
+	return isAbsolute(target) ? resolve(target) : resolve(dirname(path), target);
+}
+function symlinkPlan(app, path, target) {
+	return {
+		operations: [{
+			path,
+			target,
+			type: "symlink"
+		}],
+		summary: `Deploy the shared skill to ${app.displayName}.`
+	};
+}
+function convergedPlan(app, skillId) {
+	return {
+		operations: [],
+		summary: `${app.displayName} already loads shared skill "${skillId}".`
+	};
+}
+//#endregion
+export { MAX_MUTABLE_FILE_BYTES as A, AuraManifestError as B, renderRedactedWriteDiff as C, renderRemoveDiff as D, renderMoveDiff as E, parseAuraManifest as F, src_default as H, errorCode as I, errorMessage as L, assertAuraManifestWritable as M, createAuraManifestWriteOperation as N, renderSymlinkDiff as O, createEmptyAuraManifest as P, isRecord as R, hashManagedSnippet as S, renderConflict as T, pluralize as U, SHARED_INSTRUCTIONS_TEMPLATE as V, managedSnippetContentProblems as _, planSharedInstructionLink as a, canonicalizeManagedSnippet as b, planMcpSecretRemediation as c, planDesiredMcpConvergence as d, planManifestMcpConvergence as f, reconcileParsedManagedBlock as g, createAppMcpConvergence as h, skillDeploymentStatus as i, MAX_RETAINED_PLAN_BYTES as j, FILE_MODES as k, rememberMcpSecretPlanner as l, rememberMcpConvergence as m, planSkillDeployment as n, canPlanMcpSecretRemediation as o, planMcpServerRemoval as p, sharedSkillsRoot as r, createAppMcpSecretPlanner as s, isAuraOwnedSkillTarget as t, mcpConvergenceBlockers as u, readManagedBlock as v, renderArchiveDiff as w, hashCanonicalManagedSnippet as x, AURA_MANAGED_SNIPPET_BEGIN_PREFIX as y, resolveAuraManifestPath as z };