@agent-profile/web 0.2.0 → 0.3.1

package/build/server/chunks/{projectContext-fk5wtjwg.js → projectContext-B1D-bieW.js}

@@ -17091,17 +17091,20 @@ function compareText(left, right) {
 }
 //#endregion
 //#region ../../packages/compiler/src/lockfile.ts
+var SUPPORTED_VERSIONS = new Set([1, 2]);
 function buildLockfile(input) {
+	const profilePath = safeOutputPath(input.profilePath ?? "ai-profile.yaml");
+	const mixedByPath = new Map((input.mixedOutputs ?? []).map((entry) => [safeOutputPath(entry.path), entry]));
 	return {
-		version: 1,
+		version: 2,
 		profile: {
-			path: safeOutputPath(input.profilePath ?? "ai-profile.yaml"),
+			path: profilePath,
 			schemaVersion: 1,
 			sha256: sha256Hex(input.profileBytes)
 		},
 		compiler: input.compiler ?? AGENT_PROFILE_COMPILER,
 		templates: input.templates.map(toLockTemplate).sort(compareLockTemplates),
-		outputs: input.files.map(toLockOutput).sort(compareLockOutputs)
+		outputs: input.files.map((file) => toLockOutputV2(file, mixedByPath)).sort(compareLockOutputsV2)
 	};
 }
 function serializeLockfile(lockfile) {
@@ -17110,6 +17113,28 @@ function serializeLockfile(lockfile) {
 function createLockfileFile(input) {
 	return createGeneratedTextFile("ai-profile.lock", "lockfile", "targets/lockfile@1", serializeLockfile(buildLockfile(input)));
 }
+/**
+* Migrate a parsed v1 lockfile to v2 by promoting every v1 output to
+* `generated-owned`. Order, hashes, target, and template ids are copied
+* unchanged. The migration is deterministic and idempotent: calling it on the
+* result of `buildLockfile(input)` for the same inputs produces byte-identical
+* v2 bytes.
+*/
+function migrateLockfileV1ToV2(lockfile) {
+	return {
+		version: 2,
+		profile: lockfile.profile,
+		compiler: lockfile.compiler,
+		templates: [...lockfile.templates].sort(compareLockTemplates),
+		outputs: lockfile.outputs.map((output) => ({
+			path: output.path,
+			target: output.target,
+			templateId: output.templateId,
+			ownership: "generated-owned",
+			sha256: output.sha256
+		})).sort(compareLockOutputsV2)
+	};
+}
 function validateLockfileText(source) {
 	try {
 		return validateLockfileValue(JSON.parse(source));
@@ -17128,14 +17153,48 @@ function validateLockfileText(source) {
 }
 function validateLockfileValue(value) {
 	const issues = [];
-	validateLockfileObject(value, issues);
+	if (!isRecord(value)) {
+		issues.push(schemaIssue("/", "object", describeValue(value)));
+		return {
+			ok: false,
+			issues
+		};
+	}
+	const version = value.version;
+	if (typeof version !== "number" || !SUPPORTED_VERSIONS.has(version)) {
+		issues.push({
+			code: "lockfile_unsupported_version",
+			path: "/version",
+			expected: "supported lockfile version (1 or 2)",
+			actual: describeValue(version),
+			message: `/version is not a supported lockfile version.`
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	if (version === 1) {
+		validateLockfileV1Object(value, issues);
+		if (issues.length > 0) return {
+			ok: false,
+			issues: issues.sort(compareLockfileIssues)
+		};
+		return {
+			ok: true,
+			lockfile: value,
+			version: 1
+		};
+	}
+	validateLockfileV2Object(value, issues);
 	if (issues.length > 0) return {
 		ok: false,
 		issues: issues.sort(compareLockfileIssues)
 	};
 	return {
 		ok: true,
-		lockfile: value
+		lockfile: value,
+		version: 2
 	};
 }
 function toLockTemplate(template) {
@@ -17146,7 +17205,7 @@ function toLockTemplate(template) {
 		sha256: template.sha256
 	};
 }
-function validateLockfileObject(value, issues) {
+function validateLockfileV1Object(value, issues) {
 	if (!isRecord(value)) {
 		issues.push(schemaIssue("/", "object", describeValue(value)));
 		return;
@@ -17162,7 +17221,25 @@ function validateLockfileObject(value, issues) {
 	validateProfile(value.profile, issues);
 	validateCompiler(value.compiler, issues);
 	validateTemplates(value.templates, issues);
-	validateOutputs(value.outputs, issues);
+	validateOutputsV1(value.outputs, issues);
+}
+function validateLockfileV2Object(value, issues) {
+	if (!isRecord(value)) {
+		issues.push(schemaIssue("/", "object", describeValue(value)));
+		return;
+	}
+	requireExactKeys(value, "/", [
+		"version",
+		"profile",
+		"compiler",
+		"templates",
+		"outputs"
+	], issues);
+	if (value.version !== 2) issues.push(schemaIssue("/version", "constant 2", describeValue(value.version)));
+	validateProfile(value.profile, issues);
+	validateCompiler(value.compiler, issues);
+	validateTemplates(value.templates, issues);
+	validateOutputsV2(value.outputs, issues);
 }
 function validateProfile(value, issues) {
 	if (!isRecord(value)) {
@@ -17220,7 +17297,7 @@ function validateTemplates(value, issues) {
 		previous = current;
 	});
 }
-function validateOutputs(value, issues) {
+function validateOutputsV1(value, issues) {
 	if (!Array.isArray(value)) {
 		issues.push(schemaIssue("/outputs", "array", describeValue(value)));
 		return;
@@ -17253,6 +17330,89 @@ function validateOutputs(value, issues) {
 		previous = current;
 	});
 }
+function validateOutputsV2(value, issues) {
+	if (!Array.isArray(value)) {
+		issues.push(schemaIssue("/outputs", "array", describeValue(value)));
+		return;
+	}
+	let previous;
+	value.forEach((item, index) => {
+		const path = `/outputs/${index}`;
+		if (!isRecord(item)) {
+			issues.push(schemaIssue(path, "object", describeValue(item)));
+			return;
+		}
+		const ownership = item.ownership;
+		if (ownership === "generated-owned") {
+			requireExactKeys(item, path, [
+				"path",
+				"target",
+				"templateId",
+				"ownership",
+				"sha256"
+			], issues);
+			validatePath(item.path, `${path}/path`, issues);
+			validateString(item.target, `${path}/target`, issues);
+			validateString(item.templateId, `${path}/templateId`, issues);
+			validateHash(item.sha256, `${path}/sha256`, issues);
+		} else if (ownership === "mixed") {
+			requireExactKeys(item, path, [
+				"path",
+				"target",
+				"templateId",
+				"ownership",
+				"regions"
+			], issues);
+			validatePath(item.path, `${path}/path`, issues);
+			validateString(item.target, `${path}/target`, issues);
+			validateString(item.templateId, `${path}/templateId`, issues);
+			validateRegions(item.regions, `${path}/regions`, issues);
+		} else if (ownership === "manual-owned") {
+			requireExactKeys(item, path, [
+				"path",
+				"target",
+				"templateId",
+				"ownership"
+			], issues);
+			validatePath(item.path, `${path}/path`, issues);
+			if (item.target !== "manual") issues.push(schemaIssue(`${path}/target`, "\"manual\"", describeValue(item.target)));
+			if (item.templateId !== "manual") issues.push(schemaIssue(`${path}/templateId`, "\"manual\"", describeValue(item.templateId)));
+		} else issues.push(schemaIssue(`${path}/ownership`, "\"generated-owned\" | \"mixed\" | \"manual-owned\"", describeValue(ownership)));
+		const current = item;
+		if (previous && compareLockOutputsV2(previous, current) > 0) issues.push({
+			code: "lockfile_order_error",
+			path,
+			expected: "outputs sorted by path then target",
+			actual: "out of order",
+			message: `${path} is not in deterministic order.`
+		});
+		previous = current;
+	});
+}
+function validateRegions(value, pathPrefix, issues) {
+	if (!Array.isArray(value)) {
+		issues.push(schemaIssue(pathPrefix, "array", describeValue(value)));
+		return;
+	}
+	if (value.length !== 1) issues.push(schemaIssue(pathPrefix, "exactly one generated region", `${value.length} regions`));
+	value.forEach((item, index) => {
+		const path = `${pathPrefix}/${index}`;
+		if (!isRecord(item)) {
+			issues.push(schemaIssue(path, "object", describeValue(item)));
+			return;
+		}
+		requireExactKeys(item, path, [
+			"id",
+			"target",
+			"templateId",
+			"sha256"
+		], issues);
+		if (item.id !== "agent-profile:generated") issues.push(schemaIssue(`${path}/id`, "\"agent-profile:generated\"", describeValue(item.id)));
+		validateString(item.target, `${path}/target`, issues);
+		validateString(item.templateId, `${path}/templateId`, issues);
+		validateHash(item.sha256, `${path}/sha256`, issues);
+	});
+}
 function requireExactKeys(value, path, keys, issues) {
 	const allowed = new Set(keys);
 	for (const key of keys) if (!Object.prototype.hasOwnProperty.call(value, key)) issues.push(schemaIssue(`${path}/${escapeJsonPointerSegment(key)}`, "required property", "missing"));
@@ -17310,11 +17470,26 @@ function escapeJsonPointerSegment(segment) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function toLockOutput(file) {
+function toLockOutputV2(file, mixedByPath) {
+	const safePath = safeOutputPath(file.path);
+	const mixed = mixedByPath.get(safePath);
+	if (mixed) return {
+		path: safePath,
+		target: file.target,
+		templateId: file.templateId,
+		ownership: "mixed",
+		regions: [{
+			id: "agent-profile:generated",
+			target: mixed.target,
+			templateId: mixed.templateId,
+			sha256: mixed.regionHash
+		}]
+	};
 	return {
-		path: safeOutputPath(file.path),
+		path: safePath,
 		target: file.target,
 		templateId: file.templateId,
+		ownership: "generated-owned",
 		sha256: file.sha256
 	};
 }
@@ -17324,6 +17499,274 @@ function compareLockTemplates(left, right) {
 function compareLockOutputs(left, right) {
 	return compareText(left.path, right.path) || compareText(left.target, right.target);
 }
+function compareLockOutputsV2(left, right) {
+	return compareText(left.path, right.path) || compareText(left.target, right.target);
+}
+/**
+* Normalize a v1 or v2 lockfile to a uniform v2 view for consumers. v1
+* outputs are promoted to `generated-owned` outputs.
+*/
+function toLockfileV2View(lockfile) {
+	if (lockfile.version === 2) return lockfile;
+	return migrateLockfileV1ToV2(lockfile);
+}
+//#endregion
+//#region ../../packages/compiler/src/regions.ts
+var GENERATED_START_MARKER = "<!-- agent-profile:generated:start -->";
+var GENERATED_END_MARKER = "<!-- agent-profile:generated:end -->";
+var MANUAL_START_MARKER = "<!-- agent-profile:manual:start -->";
+var MANUAL_END_MARKER = "<!-- agent-profile:manual:end -->";
+var LEGACY_GENERATED_MARKER = "<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->";
+var GENERATED_START_RE = /^<!-- agent-profile:generated:start -->$/u;
+var GENERATED_END_RE = /^<!-- agent-profile:generated:end -->$/u;
+var MANUAL_START_RE = /^<!-- agent-profile:manual:start -->$/u;
+var MANUAL_END_RE = /^<!-- agent-profile:manual:end -->$/u;
+/**
+* Parse a mixed-ownership instruction file (AGENTS.md or CLAUDE.md) into its
+* generated and manual regions. Raw bytes are preserved; no normalization is
+* applied so that hashes match the on-disk content exactly.
+*
+* The Phase 14 spec defines a strict file shape: the file begins with the
+* generated start marker, the two regions are separated by exactly one blank
+* line, and the file ends with the manual end marker plus a single trailing
+* newline. Markers that appear inside fenced code blocks (``` ... ```) are
+* not counted as region markers.
+*/
+function parseMixedFile(bytes) {
+	const text = bytes.toString("utf8");
+	const lineEndings = [];
+	const lines = [];
+	let position = 0;
+	while (position < text.length) {
+		const newlineIndex = text.indexOf("\n", position);
+		if (newlineIndex === -1) {
+			lines.push(text.slice(position));
+			lineEndings.push("");
+			break;
+		}
+		let lineEnd = newlineIndex;
+		let ending = "\n";
+		if (lineEnd > position && text[lineEnd - 1] === "\r") {
+			lineEnd = newlineIndex - 1;
+			ending = "\r\n";
+		}
+		lines.push(text.slice(position, lineEnd));
+		lineEndings.push(ending);
+		position = newlineIndex + 1;
+	}
+	const inFence = computeCodeFenceMask(lines);
+	const matches = {
+		generatedStart: [],
+		generatedEnd: [],
+		manualStart: [],
+		manualEnd: []
+	};
+	lines.forEach((line, index) => {
+		if (inFence[index]) return;
+		if (GENERATED_START_RE.test(line)) matches.generatedStart.push(index);
+		if (GENERATED_END_RE.test(line)) matches.generatedEnd.push(index);
+		if (MANUAL_START_RE.test(line)) matches.manualStart.push(index);
+		if (MANUAL_END_RE.test(line)) matches.manualEnd.push(index);
+	});
+	const issues = [];
+	if (matches.generatedStart.length > 1 || matches.generatedEnd.length > 1 || matches.manualStart.length > 1 || matches.manualEnd.length > 1) {
+		issues.push({
+			code: "duplicate-markers",
+			message: "Mixed instruction file contains duplicate generated/manual region markers."
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	if (matches.generatedStart.length !== 1 || matches.generatedEnd.length !== 1 || matches.manualStart.length !== 1 || matches.manualEnd.length !== 1) {
+		issues.push({
+			code: "missing-markers",
+			message: "Mixed instruction file is missing one or more required region markers."
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	const gs = matches.generatedStart[0];
+	const ge = matches.generatedEnd[0];
+	const ms = matches.manualStart[0];
+	const me = matches.manualEnd[0];
+	if (!(gs < ge && ge < ms && ms < me)) {
+		issues.push({
+			code: "out-of-order",
+			message: "Mixed instruction file region markers must appear in generated-start, generated-end, manual-start, manual-end order."
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	if (gs !== 0) {
+		issues.push({
+			code: "preamble",
+			message: "Mixed instruction file must begin with the generated start marker; no preamble bytes are allowed."
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	if (ms !== ge + 2 || (lines[ge + 1] ?? "") !== "") {
+		issues.push({
+			code: "missing-blank-line",
+			message: "Mixed instruction file must have exactly one blank line between the generated and manual regions."
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	if (!(lines.length === me + 1 && (lineEndings[me] ?? "").length > 0)) {
+		issues.push({
+			code: "missing-trailing-newline",
+			message: "Mixed instruction file must end with the manual end marker followed by exactly one trailing newline."
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	const generatedInnerBytes = computeRangeBytes(bytes, lines, lineEndings, gs, ge);
+	return {
+		ok: true,
+		generatedInner: generatedInnerBytes,
+		manualInner: computeRangeBytes(bytes, lines, lineEndings, ms, me),
+		generatedInnerHash: sha256Hex(generatedInnerBytes)
+	};
+}
+function computeCodeFenceMask(lines) {
+	const mask = new Array(lines.length).fill(false);
+	let open = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		if (/^\s{0,3}(?:```|~~~)/u.test(line)) {
+			mask[index] = open || true;
+			open = !open;
+			continue;
+		}
+		mask[index] = open;
+	}
+	return mask;
+}
+function computeRangeBytes(bytes, lines, lineEndings, startMarkerIndex, endMarkerIndex) {
+	const startByte = computeByteOffsetAfterLine(lines, lineEndings, startMarkerIndex);
+	const endByte = computeByteOffsetAtLineStart(lines, lineEndings, endMarkerIndex);
+	return bytes.subarray(startByte, endByte);
+}
+function computeByteOffsetAfterLine(lines, lineEndings, lineIndex) {
+	let offset = 0;
+	for (let index = 0; index <= lineIndex; index += 1) {
+		offset += Buffer.byteLength(lines[index] ?? "", "utf8");
+		offset += Buffer.byteLength(lineEndings[index] ?? "", "utf8");
+	}
+	return offset;
+}
+function computeByteOffsetAtLineStart(lines, lineEndings, lineIndex) {
+	let offset = 0;
+	for (let index = 0; index < lineIndex; index += 1) {
+		offset += Buffer.byteLength(lines[index] ?? "", "utf8");
+		offset += Buffer.byteLength(lineEndings[index] ?? "", "utf8");
+	}
+	return offset;
+}
+/**
+* Quick predicate: do any of the four region markers appear in the file?
+* Used to detect partial markers and choose ownership. Marker lines inside
+* fenced code blocks (``` ... ``` / ~~~ ... ~~~) are not counted.
+*/
+function hasAnyRegionMarker(bytes) {
+	const lines = bytes.toString("utf8").split(/\r?\n/u);
+	const fence = computeCodeFenceMask(lines);
+	return lines.some((line, index) => !fence[index] && (GENERATED_START_RE.test(line) || GENERATED_END_RE.test(line) || MANUAL_START_RE.test(line) || MANUAL_END_RE.test(line)));
+}
+function hasAllRegionMarkers(bytes) {
+	const lines = bytes.toString("utf8").split(/\r?\n/u);
+	const fence = computeCodeFenceMask(lines);
+	const present = (re) => lines.some((line, index) => !fence[index] && re.test(line));
+	return present(GENERATED_START_RE) && present(GENERATED_END_RE) && present(MANUAL_START_RE) && present(MANUAL_END_RE);
+}
+function hasLegacyGeneratedMarker(bytes) {
+	return bytes.toString("utf8").split(/\r?\n/u).some((line) => line === LEGACY_GENERATED_MARKER);
+}
+/**
+* Build a mixed-ownership file from a generated inner body and a manual inner
+* body. The output uses LF line endings between markers and ends with a single
+* trailing newline.
+*
+* `generatedInner` is treated as the bytes strictly between the generated
+* markers (excluding marker lines). It is emitted verbatim; callers are
+* responsible for ensuring it is LF-normalized.
+*
+* `manualInner` is the bytes strictly between the manual markers and is
+* emitted verbatim with no normalization.
+*/
+function serializeMixedFile(input) {
+	const manualInner = endsWithNewline(input.manualInner) ? input.manualInner : Buffer.concat([input.manualInner, Buffer.from("\n", "utf8")]);
+	const parts = [
+		Buffer.from(`${GENERATED_START_MARKER}\n`, "utf8"),
+		input.generatedInner,
+		Buffer.from(`${GENERATED_END_MARKER}\n`, "utf8"),
+		Buffer.from("\n", "utf8"),
+		Buffer.from(`${MANUAL_START_MARKER}\n`, "utf8"),
+		manualInner,
+		Buffer.from(`${MANUAL_END_MARKER}\n`, "utf8")
+	];
+	return Buffer.concat(parts);
+}
+function endsWithNewline(bytes) {
+	if (bytes.length === 0) return false;
+	return bytes[bytes.length - 1] === 10;
+}
+/**
+* Replace only the generated region of an existing mixed file with a new
+* generated inner body. The manual region bytes and surrounding shape are
+* preserved byte-for-byte.
+*
+* Returns `undefined` if the existing bytes are not a valid mixed file; the
+* caller must refuse to write in that case.
+*/
+function replaceGeneratedRegion(existing, newGeneratedInner) {
+	if (!parseMixedFile(existing).ok) return void 0;
+	const text = existing.toString("utf8");
+	let cursor = 0;
+	let position = 0;
+	let generatedStartInnerByte = -1;
+	let generatedEndLineStartByte = -1;
+	while (position < text.length) {
+		const newlineIndex = text.indexOf("\n", position);
+		const hasNewline = newlineIndex !== -1;
+		let lineEnd = hasNewline ? newlineIndex : text.length;
+		let endingLength = 0;
+		if (hasNewline) {
+			endingLength = 1;
+			if (lineEnd > position && text[lineEnd - 1] === "\r") {
+				lineEnd -= 1;
+				endingLength = 2;
+			}
+		}
+		const line = text.slice(position, lineEnd);
+		const lineBytes = Buffer.byteLength(line, "utf8");
+		if (line === "<!-- agent-profile:generated:start -->" && generatedStartInnerByte === -1) generatedStartInnerByte = cursor + lineBytes + endingLength;
+		if (line === "<!-- agent-profile:generated:end -->" && generatedEndLineStartByte === -1) generatedEndLineStartByte = cursor;
+		cursor += lineBytes + endingLength;
+		position = hasNewline ? newlineIndex + 1 : text.length;
+	}
+	if (generatedStartInnerByte === -1 || generatedEndLineStartByte === -1) return;
+	const before = existing.subarray(0, generatedStartInnerByte);
+	const after = existing.subarray(generatedEndLineStartByte);
+	return Buffer.concat([
+		before,
+		newGeneratedInner,
+		after
+	]);
+}
 //#endregion
 //#region ../../packages/compiler/src/guidance-content.ts
 var REACT_STACK_TOPIC = {
@@ -17542,6 +17985,14 @@ ${topic.agentsMdChecklistReference}
 //#endregion
 //#region ../../packages/compiler/src/compiler.ts
 var WORKFLOW_SKILLS = [
+	{
+		id: "grill-change",
+		workflowFlag: "sdd"
+	},
+	{
+		id: "request-to-spec-issues",
+		workflowFlag: "sdd"
+	},
 	{
 		id: "sdd-change",
 		workflowFlag: "sdd"
@@ -17577,6 +18028,7 @@ var TEMPLATE_SOURCES = [
 		source: renderLockfileTemplateSource()
 	},
 	guidelineTemplateSource("targets/tabnine-guidelines/00-general-agent-behavior@1", renderGeneralAgentBehaviorTemplateSource),
+	guidelineTemplateSource("targets/tabnine-guidelines/05-planning-workflow@1", renderPlanningWorkflowGuideline),
 	guidelineTemplateSource("targets/tabnine-guidelines/10-sdd-workflow@1", renderSddWorkflowGuideline),
 	guidelineTemplateSource("targets/tabnine-guidelines/20-tdd-workflow@1", renderTddWorkflowGuideline),
 	guidelineTemplateSource("targets/tabnine-guidelines/30-stack-typescript-svelte@1", renderTypeScriptSvelteGuideline),
@@ -17599,6 +18051,8 @@ var TEMPLATE_SOURCES = [
 		version: "1",
 		source: renderCodexConfigToml()
 	},
+	workflowSkillTemplateSource("targets/codex-workflow-skills/grill-change@1", "codex-workflow-skills", "grill-change"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/request-to-spec-issues@1", "codex-workflow-skills", "request-to-spec-issues"),
 	workflowSkillTemplateSource("targets/codex-workflow-skills/sdd-change@1", "codex-workflow-skills", "sdd-change"),
 	workflowSkillTemplateSource("targets/codex-workflow-skills/tdd-change@2", "codex-workflow-skills", "tdd-change"),
 	workflowSkillTemplateSource("targets/codex-workflow-skills/final-review@1", "codex-workflow-skills", "final-review"),
@@ -17621,6 +18075,8 @@ var TEMPLATE_SOURCES = [
 		version: "1",
 		source: renderClaudeMd()
 	},
+	workflowSkillTemplateSource("targets/claude-workflow-skills/grill-change@1", "claude-workflow-skills", "grill-change"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/request-to-spec-issues@1", "claude-workflow-skills", "request-to-spec-issues"),
 	workflowSkillTemplateSource("targets/claude-workflow-skills/sdd-change@1", "claude-workflow-skills", "sdd-change"),
 	workflowSkillTemplateSource("targets/claude-workflow-skills/tdd-change@2", "claude-workflow-skills", "tdd-change"),
 	workflowSkillTemplateSource("targets/claude-workflow-skills/final-review@1", "claude-workflow-skills", "final-review"),
@@ -17696,6 +18152,10 @@ function renderAgentsMd(profile) {
 	const documentationSection = profile.workflow.documentation === true ? `\n${renderTopicAsAgentsMdSection(DOCUMENTATION_TOPIC)}` : "";
 	return normalizeGeneratedText(`# AGENTS.md
 
+## Instruction Precedence
+
+If generated and manual instructions conflict, follow the manual project instructions unless they would weaken safety, privacy, or permission limits. Safety, privacy, and explicit deny rules always win.
+
 ## Project
 
 Name: ${escapeMarkdownText(profile.profile.name)}
@@ -17755,6 +18215,10 @@ Cursor, Aider, Copilot, hosted gateways, enterprise RBAC, SIEM integrations, and
 function renderClaudeMd() {
 	return `<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
 
+## Instruction Precedence
+
+If generated and manual instructions conflict, follow the manual project instructions unless they would weaken safety, privacy, or permission limits. Safety, privacy, and explicit deny rules always win.
+
 @AGENTS.md
 
 # Claude Code
@@ -17800,7 +18264,10 @@ function renderTarget(target, profile) {
 function renderTabnineGuidelines(profile) {
 	const common = { target: "tabnine-guidelines" };
 	const files = [createGeneratedTextFile(".tabnine/guidelines/00-general-agent-behavior.md", common.target, "targets/tabnine-guidelines/00-general-agent-behavior@1", renderGeneralAgentBehaviorGuideline(profile))];
-	if (profile.workflow.sdd) files.push(createGeneratedTextFile(".tabnine/guidelines/10-sdd-workflow.md", common.target, "targets/tabnine-guidelines/10-sdd-workflow@1", renderSddWorkflowGuideline()));
+	if (profile.workflow.sdd) {
+		files.push(createGeneratedTextFile(".tabnine/guidelines/05-planning-workflow.md", common.target, "targets/tabnine-guidelines/05-planning-workflow@1", renderPlanningWorkflowGuideline()));
+		files.push(createGeneratedTextFile(".tabnine/guidelines/10-sdd-workflow.md", common.target, "targets/tabnine-guidelines/10-sdd-workflow@1", renderSddWorkflowGuideline()));
+	}
 	if (profile.workflow.tdd) files.push(createGeneratedTextFile(".tabnine/guidelines/20-tdd-workflow.md", common.target, "targets/tabnine-guidelines/20-tdd-workflow@1", renderTddWorkflowGuideline()));
 	if (hasStack(profile, "languages", "typescript") && hasStack(profile, "frameworks", "sveltekit")) files.push(createGeneratedTextFile(".tabnine/guidelines/30-stack-typescript-svelte.md", common.target, "targets/tabnine-guidelines/30-stack-typescript-svelte@1", renderTypeScriptSvelteGuideline()));
 	if (hasStack(profile, "frameworks", "react")) files.push(createGeneratedTextFile(".tabnine/guidelines/30-stack-typescript-react.md", common.target, "targets/tabnine-guidelines/30-stack-typescript-react@1", renderTypeScriptReactGuideline()));
@@ -17820,6 +18287,193 @@ function getWorkflowSkillTemplateId(target, skill) {
 }
 function renderWorkflowSkill(skill) {
 	switch (skill) {
+		case "grill-change": return `---
+name: grill-change
+description: Use when a stakeholder request is rough, ambiguous, or underspecified and needs clarification before planning, writing a spec, or creating issues.
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# Grill Change
+
+## Purpose
+
+Clarify a stakeholder request before any spec, issue plan, or implementation work starts. The output is an agreement record for a follow-up synthesis workflow; it is not an implementation plan.
+
+## Operating Rules
+
+1. Ask one focused question, then wait for the user's answer.
+2. Include a recommended answer with the question and explain why that answer is safest for the project.
+3. Inspect relevant local specs, ADRs, docs, fixtures, and code before asking questions that local context can answer.
+4. Challenge vague terms, overloaded words, and claims that conflict with repository evidence.
+5. Prefer concrete examples, edge cases, and tradeoff choices over broad brainstorming.
+6. Keep implementation details provisional until the product intent and non-goals are settled.
+7. Capture durable terms and hard-to-reverse decisions in the agreement record when they crystallize.
+8. Do not create issue lists, edit files, or start implementation during the grill.
+
+## Question Format
+
+Use this shape for each question:
+
+Question: \`<one decision or missing fact>\`
+Recommended answer: \`<the default direction you would choose>\`
+Why: \`<short reason based on product intent, safety, contracts, or repo evidence>\`
+
+## Decision Checks
+
+Before ending the grill, confirm:
+
+- the problem in the stakeholder's terms
+- the desired outcome
+- explicit non-goals
+- product intent and why the change matters
+- tradeoff direction for ambiguous implementation choices
+- user-visible behavior changes
+- compatibility and migration expectations
+- durable terminology and hard-to-reverse decisions
+- safety and privacy constraints
+- unresolved unknowns, if any
+
+## Output
+
+When the user agrees the grill is complete, return:
+
+- Problem
+- Intent
+- Non-goals
+- Decisions made
+- Durable terms and hard-to-reverse decisions
+- Decision rules for implementation tradeoffs
+- Open questions or risks
+- Confirmation that post-grill synthesis can run next
+
+## Safety
+
+- Do not upload source code.
+- Do not read or print secrets.
+- Do not ask for credentials, environment values, production data, or private endpoints.
+- Do not propose \`bypassPermissions\`, tool pre-approval, dependency auto-installation, hosted execution, or remote MCP behavior.
+- Do not write files, create issues, commit changes, or run implementation commands during the grill.
+`;
+		case "request-to-spec-issues": return `---
+name: request-to-spec-issues
+description: Use after a grill-change session is complete to turn the agreement record into an intent-first spec candidate and vertical TDD-ready issue briefs.
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# Request To Spec Issues
+
+## Purpose
+
+Convert a completed \`grill-change\` agreement record into an intent-first spec candidate and vertical TDD-ready issue briefs. Preserve product intent and decision rules so implementation choices follow the agreed direction.
+
+## Preconditions
+
+- The grill is complete.
+- The user has confirmed the direction is ready for synthesis.
+- Relevant local specs, ADRs, docs, fixtures, and code context have been checked.
+- If there is no completed grill agreement, stop and run \`grill-change\` first.
+
+## Synthesis Rules
+
+1. Do not re-interview the user unless the grill record contains a contradiction or a genuinely missing decision.
+2. Keep product intent, non-goals, durable terms, and hard-to-reverse decisions above implementation mechanics.
+3. Preserve existing spec contracts and safety rules unless the user explicitly approved changing them.
+4. Split work into vertical behavior slices, not file layers.
+5. Make every issue small enough for a focused RED, GREEN, refactor loop.
+6. Mark dependencies and parallel-safe work explicitly.
+7. Propose architecture rescue candidates before feature slices when a change would deepen an already fragmented codebase.
+
+## Architecture Rescue Candidates
+
+When architecture rescue is needed, propose candidates before feature issues. Each candidate must include:
+
+- Files or modules involved
+- Current friction
+- Proposed deeper module or clearer interface
+- Expected locality and leverage improvement
+- Expected test improvement
+- ADR or spec conflicts
+- Recommended dependency state: prerequisite, parallel, or later cleanup
+
+## Spec Candidate
+
+Include these sections:
+
+- Status
+- Problem
+- Goal
+- Intent
+- Decision Rules
+- Non-Goals
+- User Flow
+- Inputs
+- Outputs
+- Contracts
+- Security Rules
+- Acceptance Criteria
+- Tests
+- TDD Strategy
+- Issue Plan
+- Documentation Updates
+- Final Review Checklist
+
+\`TDD Strategy\` complements \`Tests\`; it must not replace the required \`Tests\`
+section from \`docs/specs/SPEC_TEMPLATE.md\`.
+
+## Issue Brief Format
+
+Each issue brief must include:
+
+- Title
+- Parent spec or request
+- Intent summary
+- Behavior slice
+- Non-goals
+- Acceptance criteria
+- Expected RED proof
+- Expected GREEN proof
+- Test command guidance
+- Likely file ownership
+- Dependencies
+- Parallelism notes
+- Contract impact
+- Security impact
+- Documentation impact
+- Implementation context
+- Review expectations
+
+## Dependency States
+
+Use these states:
+
+- \`ready\`
+- \`blocked\`
+- \`parallel-safe\`
+- \`sequenced\`
+- \`human-gate\`
+
+## Output
+
+Return:
+
+- Spec candidate or spec patch
+- Vertical issue briefs
+- Dependency map
+- Parallelism map
+- Human gates
+- Recommended next step
+
+## Safety
+
+- Do not upload source code.
+- Do not read or print secrets.
+- Do not include credentials, environment values, production data, or private endpoints.
+- Do not create GitHub issues, labels, projects, or milestones.
+- Do not write files unless the user explicitly asks for local file writes after reviewing the synthesis.
+- Do not propose \`bypassPermissions\`, tool pre-approval, dependency auto-installation, hosted execution, or remote MCP behavior.
+`;
 		case "sdd-change": return `---
 name: sdd-change
 description: Use when implementing a meaningful repository change that requires an approved spec before code edits.
@@ -17989,6 +18643,23 @@ Use the repository-local profile as the source of truth for agent behavior.
 - Ask before mutating files, running shell commands, installing dependencies, or using external network access.
 `;
 }
+function renderPlanningWorkflowGuideline() {
+	return `<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# Planning Workflow
+
+Use this before implementation when a stakeholder request is rough, ambiguous, or not yet tied to an approved spec.
+
+- Clarify the request one decision at a time before writing or changing specs.
+- Provide a recommended answer and short rationale for each open decision.
+- Check local specs, ADRs, docs, fixtures, and generated artifacts before asking questions.
+- Preserve product intent, non-goals, tradeoffs, durable terms, and hard-to-reverse decisions.
+- If no completed clarification exists, complete the grill-style clarification first.
+- After clarification, prepare an intent-first spec candidate and vertical TDD-ready issue briefs.
+- Include dependencies, expected RED proof, expected GREEN proof, file ownership, contract impact, security impact, and review expectations in each issue brief.
+- Do not create GitHub issues, write files, upload source, read secrets, install dependencies, or change runtime permissions unless explicitly requested and allowed.
+`;
+}
 function renderSddWorkflowGuideline() {
 	return `<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
 
@@ -18129,9 +18800,9 @@ function renderClaudeSubagent(agent, effective) {
 			"Glob",
 			"Grep"
 		];
-		if (effective.filesystem.write === "allow") tools.push("Edit", "Write");
-		if (effective.shell.run === "allow") tools.push("Bash");
-		if (effective.network.external === "allow") tools.push("WebFetch");
+		if (effective.filesystem.write !== "deny") tools.push("Edit", "Write");
+		if (effective.shell.run !== "deny") tools.push("Bash");
+		if (effective.network.external !== "deny") tools.push("WebFetch");
 		lines.push(`tools: ${tools.join(", ")}`);
 	}
 	const model = agent.modelPreference ?? "inherit";
@@ -18406,7 +19077,10 @@ function getRequiredAgentsMdTopicTemplateIds(profile) {
 }
 function getRequiredTabnineGuidelineTemplateIds(profile) {
 	const ids = ["targets/tabnine-guidelines/00-general-agent-behavior@1"];
-	if (profile.workflow.sdd) ids.push("targets/tabnine-guidelines/10-sdd-workflow@1");
+	if (profile.workflow.sdd) {
+		ids.push("targets/tabnine-guidelines/05-planning-workflow@1");
+		ids.push("targets/tabnine-guidelines/10-sdd-workflow@1");
+	}
 	if (profile.workflow.tdd) ids.push("targets/tabnine-guidelines/20-tdd-workflow@1");
 	if (hasStack(profile, "languages", "typescript") && hasStack(profile, "frameworks", "sveltekit")) ids.push("targets/tabnine-guidelines/30-stack-typescript-svelte@1");
 	if (hasStack(profile, "frameworks", "react")) ids.push("targets/tabnine-guidelines/30-stack-typescript-react@1");
@@ -18457,6 +19131,92 @@ function compareIssues(left, right) {
 }
 //#endregion
 //#region ../../packages/compiler/src/write-plan.ts
+async function planWrites(request) {
+	return planWritesWithResolvedRoot(await fsPromises.realpath(path.resolve(request.rootDir)), request.writes);
+}
+async function planWritesWithResolvedRoot(rootRealPath, plannedWrites) {
+	const writes = normalizeWrites(plannedWrites);
+	const actions = [];
+	for (const write of writes) {
+		const current = await readOptionalFile(await assertWritePathContained(rootRealPath, write.path));
+		const action = current ? Buffer.from(current).equals(Buffer.from(write.bytes)) ? "unchanged" : "change" : "create";
+		actions.push({
+			path: write.path,
+			action,
+			plannedBytes: write.bytes.byteLength
+		});
+	}
+	return {
+		actions,
+		counts: countActions(actions)
+	};
+}
+async function applyWritePlan(request) {
+	const rootRealPath = await fsPromises.realpath(path.resolve(request.rootDir));
+	const writes = normalizeWrites(request.writes);
+	const plan = await planWritesWithResolvedRoot(rootRealPath, writes);
+	const writesByPath = new Map(writes.map((write) => [write.path, write]));
+	for (const action of plan.actions) {
+		if (action.action === "unchanged") continue;
+		const write = writesByPath.get(action.path);
+		if (!write) continue;
+		const absolutePath = await assertWritePathContained(rootRealPath, write.path);
+		await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+		await fsPromises.writeFile(absolutePath, write.bytes);
+	}
+	return plan;
+}
+function normalizeWrites(writes) {
+	return writes.map((write) => ({
+		path: safeOutputPath(write.path),
+		bytes: typeof write.bytes === "string" ? Buffer.from(write.bytes, "utf8") : write.bytes
+	})).sort((left, right) => compareText(left.path, right.path));
+}
+function countActions(actions) {
+	return {
+		create: actions.filter((action) => action.action === "create").length,
+		change: actions.filter((action) => action.action === "change").length,
+		unchanged: actions.filter((action) => action.action === "unchanged").length
+	};
+}
+async function assertWritePathContained(rootRealPath, relativePath) {
+	const safePath = safeOutputPath(relativePath);
+	const absolutePath = path.resolve(rootRealPath, ...safePath.split("/").filter(Boolean));
+	if (!isContainedBy(rootRealPath, absolutePath)) throw new Error(`Planned write escapes root: ${safePath}`);
+	const existingTarget = await lstatOptional$1(absolutePath);
+	if (existingTarget) {
+		if (existingTarget.isSymbolicLink()) throw new Error(`Planned write target is a symlink (refusing to follow): ${safePath}`);
+		if (!isContainedBy(rootRealPath, await fsPromises.realpath(absolutePath))) throw new Error(`Planned write target escapes root: ${safePath}`);
+	}
+	const existingParent = await findExistingAncestor(path.dirname(absolutePath));
+	if (!isContainedBy(rootRealPath, await fsPromises.realpath(existingParent))) throw new Error(`Planned write parent escapes root: ${safePath}`);
+	return absolutePath;
+}
+async function findExistingAncestor(startPath) {
+	let current = startPath;
+	while (true) {
+		if (await lstatOptional$1(current)) return current;
+		const parent = path.dirname(current);
+		if (parent === current) throw new Error(`No existing parent directory for ${startPath}`);
+		current = parent;
+	}
+}
+async function readOptionalFile(absolutePath) {
+	try {
+		return await fsPromises.readFile(absolutePath);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function lstatOptional$1(absolutePath) {
+	try {
+		return await fsPromises.lstat(absolutePath);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+}
 function isContainedBy(rootPath, candidatePath) {
 	const relative = path.relative(rootPath, candidatePath);
 	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
@@ -18551,6 +19311,599 @@ function computeFileEtag(bytes) {
 	return "sha256:" + createHash("sha256").update(bytes).digest("hex");
 }
 //#endregion
+//#region ../../packages/compiler/src/import-report.ts
+var PHASE_14_SUPPORTED_PATHS = [
+	{
+		path: "AGENTS.md",
+		kind: "root-instructions",
+		isLocalRuntime: false
+	},
+	{
+		path: "CLAUDE.md",
+		kind: "root-instructions",
+		isLocalRuntime: false
+	},
+	{
+		path: ".claude/settings.json",
+		kind: "client-config",
+		isLocalRuntime: false
+	},
+	{
+		path: ".claude/settings.local.json",
+		kind: "client-config",
+		isLocalRuntime: true
+	},
+	{
+		path: ".codex/config.toml",
+		kind: "client-config",
+		isLocalRuntime: true
+	},
+	{
+		path: ".codex/hooks.json",
+		kind: "client-config",
+		isLocalRuntime: true
+	},
+	{
+		path: ".mcp.json",
+		kind: "mcp-config",
+		isLocalRuntime: true
+	}
+];
+var PHASE_14_SCAN_DIRS = [
+	{
+		root: ".agents/skills",
+		kind: "workflow-skill",
+		fileFilter: (rel) => rel.endsWith("/SKILL.md"),
+		recursive: true
+	},
+	{
+		root: ".claude/skills",
+		kind: "workflow-skill",
+		fileFilter: (rel) => rel.endsWith("/SKILL.md"),
+		recursive: true
+	},
+	{
+		root: ".claude/agents",
+		kind: "subagent",
+		fileFilter: (rel) => rel.endsWith(".md"),
+		recursive: false
+	},
+	{
+		root: ".codex/agents",
+		kind: "subagent",
+		fileFilter: (rel) => rel.endsWith(".toml"),
+		recursive: false
+	},
+	{
+		root: ".tabnine/agent/agents",
+		kind: "subagent",
+		fileFilter: (rel) => rel.endsWith(".md"),
+		recursive: false
+	}
+];
+var RECOMMENDED_IGNORE_LINES = [
+	".cce/",
+	".mcp.json",
+	".claude/settings.local.json",
+	".claude/worktrees/",
+	".codex/config.toml",
+	".codex/hooks.json"
+];
+async function buildPhase14ImportReport(input) {
+	const files = [];
+	let wouldUpdateRegions = 0;
+	let preservedManualFiles = 0;
+	let conflicts = 0;
+	const collisionsByKey = /* @__PURE__ */ new Map();
+	const lockfile = await readLockfileForRegions(input.rootDir);
+	const ownershipByPath = /* @__PURE__ */ new Map();
+	if (lockfile) for (const output of lockfile.outputs) ownershipByPath.set(output.path, output.ownership);
+	for (const entry of PHASE_14_SUPPORTED_PATHS) {
+		const read = await readRegionAwareFile(input.rootDir, entry.path);
+		if (read.refused) {
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership: "unknown",
+				tags: [],
+				action: "refuse-conflict",
+				notes: ["symlinked; Phase 14 refuses to follow file symlinks"]
+			});
+			conflicts += 1;
+			continue;
+		}
+		const existing = read.bytes;
+		if (!existing) {
+			if (entry.kind === "root-instructions") files.push({
+				path: entry.path,
+				exists: false,
+				kind: entry.kind,
+				ownership: "unknown",
+				tags: [],
+				action: "create",
+				notes: []
+			});
+			continue;
+		}
+		const bytes = Buffer.from(existing);
+		const tags = [];
+		if (entry.isLocalRuntime) tags.push("local-runtime");
+		if (containsAbsolutePathLiteral(bytes)) tags.push("contains-absolute-path");
+		if (entry.kind === "client-config" && !entry.isLocalRuntime) {
+			const ownership = ownershipByPath.get(entry.path) ?? "generated-owned";
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership,
+				tags,
+				action: "preserve",
+				notes: ["generated client config; refresh via `agent-profile compile --write`"]
+			});
+			preservedManualFiles += 1;
+			continue;
+		}
+		if (entry.kind !== "root-instructions") {
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership: "manual-owned",
+				tags,
+				action: "ignore-local-runtime",
+				notes: entry.kind === "mcp-config" ? ["contains MCP entries; not imported into ai-profile.yaml in Phase 14"] : ["local runtime config; not adopted by Phase 14"]
+			});
+			preservedManualFiles += 1;
+			continue;
+		}
+		if (hasAllRegionMarkers(bytes)) {
+			const parsed = parseMixedFile(bytes);
+			if (!parsed.ok) {
+				files.push({
+					path: entry.path,
+					exists: true,
+					kind: entry.kind,
+					ownership: "unknown",
+					tags,
+					action: "refuse-conflict",
+					notes: parsed.issues.map((item) => item.message)
+				});
+				conflicts += 1;
+				continue;
+			}
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership: "mixed",
+				tags,
+				action: "update-generated-region",
+				notes: []
+			});
+			if (input.strategy === "regions") wouldUpdateRegions += 1;
+			continue;
+		}
+		if (hasAnyRegionMarker(bytes)) {
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership: "unknown",
+				tags,
+				action: "refuse-conflict",
+				notes: ["partial region markers; manual repair required"]
+			});
+			conflicts += 1;
+			continue;
+		}
+		if (hasLegacyGeneratedMarker(bytes)) tags.push("generated-looking");
+		if (input.strategy === "regions") {
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership: "unknown",
+				tags,
+				action: "insert-regions",
+				notes: ["existing content will be preserved in manual region"]
+			});
+			wouldUpdateRegions += 1;
+		} else {
+			files.push({
+				path: entry.path,
+				exists: true,
+				kind: entry.kind,
+				ownership: "unknown",
+				tags,
+				action: "preserve",
+				notes: ["Run init --import --strategy regions --write to adopt into mixed ownership"]
+			});
+			preservedManualFiles += 1;
+		}
+	}
+	for (const scan of PHASE_14_SCAN_DIRS) {
+		const { files: discovered, refusals: scanRefusals } = await listFilesUnder(input.rootDir, scan.root, scan.recursive);
+		for (const refusedPath of scanRefusals) {
+			files.push({
+				path: refusedPath,
+				exists: true,
+				kind: scan.kind,
+				ownership: "unknown",
+				tags: [],
+				action: "refuse-conflict",
+				notes: ["symlinked; Phase 14 refuses to follow file symlinks"]
+			});
+			conflicts += 1;
+		}
+		for (const relativePath of discovered) {
+			if (!scan.fileFilter(relativePath)) continue;
+			const read = await readRegionAwareFile(input.rootDir, relativePath);
+			const tags = [];
+			if (read.bytes) {
+				const name = extractDeclaredName(Buffer.from(read.bytes), relativePath);
+				if (name) recordName(scan.kind === "workflow-skill" ? "workflow-skill" : "subagent", name, relativePath, collisionsByKey);
+			}
+			if (read.refused) {
+				files.push({
+					path: relativePath,
+					exists: true,
+					kind: scan.kind,
+					ownership: "unknown",
+					tags,
+					action: "refuse-conflict",
+					notes: ["symlinked; Phase 14 refuses to follow file symlinks"]
+				});
+				conflicts += 1;
+				continue;
+			}
+			if (!read.bytes) continue;
+			const lockOwnership = ownershipByPath.get(relativePath);
+			if (lockOwnership === "generated-owned") {
+				files.push({
+					path: relativePath,
+					exists: true,
+					kind: scan.kind,
+					ownership: "generated-owned",
+					tags,
+					action: "preserve",
+					notes: ["lockfile-owned generated output; refresh via `agent-profile compile --write`"]
+				});
+				preservedManualFiles += 1;
+				continue;
+			}
+			if (lockOwnership === "mixed") {
+				files.push({
+					path: relativePath,
+					exists: true,
+					kind: scan.kind,
+					ownership: "mixed",
+					tags,
+					action: "update-generated-region",
+					notes: ["lockfile-owned mixed file; generated region is updated on compile --write"]
+				});
+				if (input.strategy === "regions") wouldUpdateRegions += 1;
+				continue;
+			}
+			files.push({
+				path: relativePath,
+				exists: true,
+				kind: scan.kind,
+				ownership: "manual-owned",
+				tags,
+				action: "preserve",
+				notes: [scan.kind === "workflow-skill" ? "existing workflow skill; not adopted as generated output" : "existing subagent file; not adopted as generated output"]
+			});
+			preservedManualFiles += 1;
+		}
+	}
+	const gitignore = (await getLocalRuntimeGitignoreFindings(input.rootDir)).map((finding) => ({
+		path: ".gitignore",
+		line: finding.line,
+		action: finding.action === "already-present" ? "already-present" : input.mode === "write" ? "would-add" : "suggest-add",
+		reason: finding.reason
+	}));
+	const collisions = [];
+	for (const [key, paths] of collisionsByKey) {
+		if (paths.length < 2) continue;
+		const [kindPart, name] = key.split("\0");
+		collisions.push({
+			name,
+			kind: kindPart === "workflow-skill" ? "workflow-skill" : "subagent",
+			paths: [...paths].sort()
+		});
+		for (const collidingPath of paths) {
+			const row = files.find((f) => f.path === collidingPath);
+			if (row && !row.notes.some((n) => n.startsWith("name collision"))) {
+				const others = paths.filter((p) => p !== collidingPath).sort();
+				row.notes.push(`name collision: \"${name}\" also declared by ${others.join(", ")}`);
+			}
+		}
+	}
+	collisions.sort((left, right) => {
+		if (left.kind !== right.kind) return left.kind === "workflow-skill" ? -1 : 1;
+		return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+	});
+	return {
+		command: "init",
+		mode: input.mode,
+		strategy: input.strategy,
+		root: ".",
+		profilePath: input.profilePath,
+		stack: {
+			languages: [...input.stack.languages].sort(),
+			frameworks: [...input.stack.frameworks].sort(),
+			packageManagers: [...input.stack.packageManagers].sort(),
+			testing: [...input.stack.testing].sort()
+		},
+		files: files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0),
+		gitignore,
+		collisions,
+		summary: {
+			wouldCreateProfile: input.wouldCreateProfile,
+			wouldUpdateRegions,
+			preservedManualFiles,
+			conflicts,
+			nameCollisions: collisions.length
+		}
+	};
+}
+function recordName(kind, name, path, map) {
+	const key = `${kind}\0${name}`;
+	const existing = map.get(key);
+	if (existing) existing.push(path);
+	else map.set(key, [path]);
+}
+/**
+* Extract the declared `name:` value from a SKILL.md / claude-style
+* subagent (.md with YAML frontmatter) or codex-style subagent (.toml).
+*
+* This deliberately avoids pulling in a YAML or TOML parser — the
+* relevant section is small, the line shape is fixed, and we want the
+* shared report module to stay dependency-light. Returns undefined when
+* no name is found; callers treat that as "this file does not
+* participate in collision detection."
+*/
+function extractDeclaredName(bytes, relativePath) {
+	const text = bytes.toString("utf8");
+	if (relativePath.endsWith(".toml")) return findTomlTopLevelName(text);
+	if (relativePath.endsWith(".md")) return findYamlFrontmatterName(text);
+}
+function findYamlFrontmatterName(text) {
+	const lines = text.split(/\r?\n/u);
+	if (lines.length === 0 || lines[0].trim() !== "---") return void 0;
+	for (let index = 1; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line.trim() === "---") return void 0;
+		if (!line.startsWith("name")) continue;
+		const match = line.match(/^name\s*:\s*(.+?)\s*$/u);
+		if (!match) continue;
+		return stripYamlQuotes(match[1]);
+	}
+}
+function findTomlTopLevelName(text) {
+	const lines = text.split(/\r?\n/u);
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("#") || trimmed === "") continue;
+		if (trimmed.startsWith("[")) break;
+		const match = trimmed.match(/^name\s*=\s*(.+?)\s*$/u);
+		if (!match) continue;
+		return stripTomlQuotes(stripInlineTomlComment(match[1]));
+	}
+}
+function stripInlineTomlComment(value) {
+	let inDoubleQuote = false;
+	let inSingleQuote = false;
+	for (let index = 0; index < value.length; index += 1) {
+		const char = value[index];
+		if (char === "\"" && !inSingleQuote) {
+			if (inDoubleQuote && value[index - 1] === "\\") continue;
+			inDoubleQuote = !inDoubleQuote;
+			continue;
+		}
+		if (char === "'" && !inDoubleQuote) {
+			inSingleQuote = !inSingleQuote;
+			continue;
+		}
+		if (char === "#" && !inDoubleQuote && !inSingleQuote) return value.slice(0, index).replace(/\s+$/u, "");
+	}
+	return value.replace(/\s+$/u, "");
+}
+function stripYamlQuotes(value) {
+	if (value.length >= 2) {
+		const first = value[0];
+		const last = value[value.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'") return value.slice(1, -1);
+	}
+	return value;
+}
+function stripTomlQuotes(value) {
+	if (value.startsWith("\"") && value.endsWith("\"") && value.length >= 2) return value.slice(1, -1);
+	if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) return value.slice(1, -1);
+	return value;
+}
+async function readRegionAwareFile(rootDir, relativePath) {
+	const safePath = safeOutputPath(relativePath);
+	const absolutePath = path.resolve(rootDir, ...safePath.split("/"));
+	let stat;
+	try {
+		stat = await fsPromises.lstat(absolutePath);
+	} catch (error) {
+		if (isNodeNotFound(error)) return {
+			refused: false,
+			bytes: void 0
+		};
+		throw error;
+	}
+	if (stat.isSymbolicLink()) return { refused: true };
+	if (!stat.isFile()) return {
+		refused: false,
+		bytes: void 0
+	};
+	return {
+		refused: false,
+		bytes: await fsPromises.readFile(absolutePath)
+	};
+}
+async function listFilesUnder(rootDir, relativeRoot, recursive) {
+	const files = [];
+	const refusals = [];
+	const rootStat = await lstatOptional(path.join(rootDir, relativeRoot));
+	if (!rootStat) return {
+		files: [],
+		refusals: []
+	};
+	if (rootStat.isSymbolicLink()) return {
+		files: [],
+		refusals: [relativeRoot]
+	};
+	if (!rootStat.isDirectory()) return {
+		files: [],
+		refusals: []
+	};
+	await walk(rootDir, relativeRoot, recursive, files, refusals);
+	return {
+		files: files.sort(),
+		refusals: refusals.sort()
+	};
+}
+async function walk(rootDir, relativeRoot, recursive, out, refusals) {
+	let entries;
+	try {
+		entries = await fsPromises.readdir(path.join(rootDir, relativeRoot), { withFileTypes: true });
+	} catch (error) {
+		if (isNodeNotFound(error)) return;
+		throw error;
+	}
+	for (const entry of entries) {
+		const child = `${relativeRoot}/${entry.name}`;
+		if (entry.isSymbolicLink()) {
+			refusals.push(child);
+			continue;
+		}
+		if (entry.isDirectory() && recursive) {
+			await walk(rootDir, child, recursive, out, refusals);
+			continue;
+		}
+		if (entry.isFile()) out.push(child);
+	}
+}
+async function lstatOptional(absolutePath) {
+	try {
+		return await fsPromises.lstat(absolutePath);
+	} catch (error) {
+		if (isNodeNotFound(error)) return void 0;
+		throw error;
+	}
+}
+async function readOptionalBytes(rootDir, relativePath) {
+	const result = await readRegionAwareFile(rootDir, relativePath);
+	if (result.refused) return void 0;
+	return result.bytes;
+}
+async function readOptionalText(rootDir, relativePath) {
+	const bytes = await readOptionalBytes(rootDir, relativePath);
+	if (!bytes) return void 0;
+	return Buffer.from(bytes).toString("utf8");
+}
+async function readLockfileForRegions(rootDir) {
+	const bytes = await readOptionalBytes(rootDir, "ai-profile.lock");
+	if (!bytes) return void 0;
+	const result = validateLockfileText(Buffer.from(bytes).toString("utf8"));
+	if (!result.ok) return void 0;
+	return toLockfileV2View(result.lockfile);
+}
+async function getLocalRuntimeGitignoreFindings(rootDir) {
+	const lines = (await readOptionalText(rootDir, ".gitignore").catch(() => void 0) ?? "").split(/\r?\n/u).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#"));
+	const findings = [];
+	for (const recommended of RECOMMENDED_IGNORE_LINES) {
+		const present = lines.some((line) => {
+			return line.replace(/^\//u, "").replace(/\/$/u, "") === recommended.replace(/\/$/u, "");
+		});
+		findings.push({
+			line: recommended,
+			action: present ? "already-present" : "would-add",
+			reason: "local runtime or machine-specific path"
+		});
+	}
+	return findings;
+}
+function containsAbsolutePathLiteral(bytes) {
+	const text = bytes.toString("utf8");
+	return /[A-Z]:\\\\|"\/[A-Za-z]/u.test(text);
+}
+function isNodeNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var REGION_AWARE_ROOT_PATHS = ["AGENTS.md", "CLAUDE.md"];
+async function planRootInstructionsAdoption(rootDir, generatedBytesByPath = /* @__PURE__ */ new Map()) {
+	const results = [];
+	for (const relativePath of REGION_AWARE_ROOT_PATHS) {
+		const read = await readRegionAwareFile(rootDir, relativePath);
+		if (read.refused) {
+			results.push({
+				ok: false,
+				path: relativePath,
+				reason: "symlink"
+			});
+			continue;
+		}
+		const existing = read.bytes;
+		if (!existing) {
+			results.push({
+				ok: false,
+				path: relativePath,
+				reason: "missing-file"
+			});
+			continue;
+		}
+		const compiled = generatedBytesByPath.get(relativePath);
+		if (!compiled) {
+			results.push({
+				ok: false,
+				path: relativePath,
+				reason: "missing-generated-bytes"
+			});
+			continue;
+		}
+		const generatedInner = Buffer.from(compiled);
+		const existingBuffer = Buffer.from(existing);
+		if (hasAllRegionMarkers(existingBuffer)) {
+			const updated = replaceGeneratedRegion(existingBuffer, generatedInner);
+			if (updated) results.push({
+				ok: true,
+				path: relativePath,
+				bytes: updated
+			});
+			else results.push({
+				ok: false,
+				path: relativePath,
+				reason: "duplicate-markers"
+			});
+			continue;
+		}
+		if (hasAnyRegionMarker(existingBuffer)) {
+			results.push({
+				ok: false,
+				path: relativePath,
+				reason: "partial-markers"
+			});
+			continue;
+		}
+		const mixed = serializeMixedFile({
+			generatedInner,
+			manualInner: existingBuffer
+		});
+		results.push({
+			ok: true,
+			path: relativePath,
+			bytes: mixed
+		});
+	}
+	return results;
+}
+//#endregion
 //#region src/lib/server/projectContext.ts
 var PROFILE_FILENAME = "ai-profile.yaml";
 /**
@@ -18631,5 +19984,5 @@ function truncatePreview(text, capBytes = 256 * 1024) {
 	};
 }
 
-export { ProfileWriteError as P, containsSecretLikeLiteral as a, createLockfileFile as b, compileProfile as c, deriveEffectivePermissions as d, sha256Hex as e, computeFileEtag as f, getEnabledSubagents as g, validateProfileValue as h, isSubagentBuiltinNameCollision as i, renderProfileYaml as j, redactIfSecretLike as k, loadProjectContext as l, normalizeSafety as n, parseProfileYaml as p, resolveProjectRoot as r, safeOutputPath as s, truncatePreview as t, validateLockfileText as v, writeProfileAtomic as w };
-//# sourceMappingURL=projectContext-fk5wtjwg.js.map
+export { writeProfileAtomic as A, ProfileWriteError as B, computeFileEtag as C, validateProfileValue as D, renderProfileYaml as E, truncatePreview as F, PHASE_14_SUPPORTED_PATHS as P, REGION_AWARE_ROOT_PATHS as R, applyWritePlan as a, buildPhase14ImportReport as b, compileProfile as c, deriveEffectivePermissions as d, containsSecretLikeLiteral as e, hasAnyRegionMarker as f, parseMixedFile as g, hasAllRegionMarkers as h, hasLegacyGeneratedMarker as i, createLockfileFile as j, sha256Hex as k, getEnabledSubagents as l, isSubagentBuiltinNameCollision as m, normalizeSafety as n, readLockfileForRegions as o, parseProfileYaml as p, planRootInstructionsAdoption as q, resolveProjectRoot as r, safeOutputPath as s, toLockfileV2View as t, planWrites as u, validateLockfileText as v, readRegionAwareFile as w, redactIfSecretLike as x, PHASE_14_SCAN_DIRS as y, loadProjectContext as z };
+//# sourceMappingURL=projectContext-B1D-bieW.js.map