@agent-profile/web 0.1.5 → 0.3.0

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

@@ -16222,9 +16222,22 @@ var ai_profile_schema_default = {
 			"properties": {
 				"sdd": { "type": "boolean" },
 				"tdd": { "type": "boolean" },
-				"finalReview": { "type": "boolean" }
+				"finalReview": { "type": "boolean" },
+				"codeReview": { "type": "boolean" },
+				"refactoring": { "type": "boolean" },
+				"documentation": { "type": "boolean" },
+				"subagentDrivenDevelopment": { "type": "boolean" }
 			}
 		},
+		"capabilities": {
+			"type": "object",
+			"additionalProperties": false,
+			"properties": { "delegation": {
+				"type": "object",
+				"additionalProperties": false,
+				"properties": { "subagents": { "$ref": "#/definitions/subagents" } }
+			} }
+		},
 		"permissions": {
 			"type": "object",
 			"additionalProperties": false,
@@ -16310,11 +16323,315 @@ var ai_profile_schema_default = {
 			"minItems": 1,
 			"uniqueItems": true,
 			"items": { "$ref": "#/definitions/slug" }
+		},
+		"subagents": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["enabled"],
+			"properties": {
+				"enabled": { "type": "boolean" },
+				"defaults": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": {
+						"maxConcurrent": {
+							"type": "integer",
+							"minimum": 1
+						},
+						"maxDepth": {
+							"type": "integer",
+							"minimum": 1
+						}
+					}
+				},
+				"agents": {
+					"type": "array",
+					"items": { "$ref": "#/definitions/subagent" }
+				}
+			},
+			"if": {
+				"properties": { "enabled": { "const": true } },
+				"required": ["enabled"]
+			},
+			"then": {
+				"required": ["agents"],
+				"properties": { "agents": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/definitions/subagent" }
+				} }
+			}
+		},
+		"subagent": { "oneOf": [{ "$ref": "#/definitions/subagentTemplateRef" }, { "$ref": "#/definitions/subagentInline" }] },
+		"subagentTemplateRef": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["useTemplate"],
+			"properties": { "useTemplate": {
+				"type": "string",
+				"enum": [
+					"implementer",
+					"spec-reviewer",
+					"code-quality-reviewer"
+				]
+			} }
+		},
+		"subagentInline": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": [
+				"name",
+				"description",
+				"purpose",
+				"prompt",
+				"toolScope"
+			],
+			"properties": {
+				"name": {
+					"type": "string",
+					"minLength": 1,
+					"pattern": "^[a-z0-9][a-z0-9-]*$",
+					"not": { "enum": [
+						"default",
+						"worker",
+						"explorer",
+						"explore",
+						"plan",
+						"general-purpose",
+						"codebase_investigator",
+						"remote-codebase-investigator",
+						"generalist",
+						"browser_agent"
+					] }
+				},
+				"description": {
+					"type": "string",
+					"minLength": 1,
+					"pattern": "^[^\\r\\n]+$"
+				},
+				"purpose": {
+					"type": "string",
+					"minLength": 1,
+					"pattern": "^[^\\r\\n]+$"
+				},
+				"prompt": {
+					"type": "string",
+					"minLength": 1
+				},
+				"toolScope": {
+					"type": "string",
+					"enum": ["read-only", "workspace-write"]
+				},
+				"modelPreference": {
+					"type": "string",
+					"enum": [
+						"inherit",
+						"fast",
+						"balanced",
+						"capable"
+					]
+				},
+				"maxTurns": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"timeoutMinutes": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"mcpServers": {
+					"type": "array",
+					"items": { "type": "string" },
+					"maxItems": 0
+				}
+			}
 		}
 	}
 };
 //#endregion
 //#region ../../packages/core/src/profile.ts
+var SUBAGENT_TEMPLATE_NAMES = [
+	"implementer",
+	"spec-reviewer",
+	"code-quality-reviewer"
+];
+function isSubagentTemplateRef(entry) {
+	return typeof entry.useTemplate === "string";
+}
+function freezeTemplate(template) {
+	if (template.mcpServers !== void 0) Object.freeze(template.mcpServers);
+	return Object.freeze(template);
+}
+function cloneTemplate(template) {
+	const clone = {
+		name: template.name,
+		description: template.description,
+		purpose: template.purpose,
+		prompt: template.prompt,
+		toolScope: template.toolScope
+	};
+	if (template.modelPreference !== void 0) clone.modelPreference = template.modelPreference;
+	if (template.maxTurns !== void 0) clone.maxTurns = template.maxTurns;
+	if (template.timeoutMinutes !== void 0) clone.timeoutMinutes = template.timeoutMinutes;
+	if (template.mcpServers !== void 0) clone.mcpServers = [...template.mcpServers];
+	return clone;
+}
+var SUBAGENT_TEMPLATES_RAW = {
+	implementer: {
+		name: "implementer",
+		description: "Use for a bounded implementation task after the parent agent has provided the full task text, relevant spec excerpts, file ownership, constraints, and expected tests. Returns an explicit status and does not commit or push unless the parent request includes that requirement.",
+		purpose: "Implement one scoped task with tests, self-review, and honest escalation when requirements or architecture are unclear.",
+		prompt: `You are implementing one bounded task.
+
+Work only from the task text, spec excerpts, file ownership, constraints,
+and allowed commands provided in the prompt. Do not assume hidden chat
+history. If essential context is missing, report NEEDS_CONTEXT instead of
+guessing.
+
+Before editing, restate the goal, non-goals, acceptance criteria, and files
+you expect to touch. If the task is ambiguous, architectural, or broader than
+the prompt says, stop and report BLOCKED or NEEDS_CONTEXT.
+
+Implement exactly what the task specifies. Follow the repository's SDD/TDD
+workflow. Add or update focused tests where practical, verify RED before
+behavior changes when the task changes behavior, implement the smallest
+passing change, then verify GREEN. Preserve existing patterns and avoid
+unrelated refactors.
+
+Do not commit, push, create branches, install dependencies, access secrets,
+contact production systems, or upload source unless the parent prompt
+explicitly authorizes that action.
+
+Before reporting back, self-review for completeness, quality, scope control,
+and test validity. Fix issues you find if they are inside the assigned scope.
+
+Report exactly:
+- Status: DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT
+- What changed
+- Tests run and results
+- Files changed
+- Self-review findings
+- Concerns, missing context, or follow-up work`,
+		toolScope: "workspace-write",
+		modelPreference: "balanced",
+		maxTurns: 18,
+		timeoutMinutes: 20,
+		mcpServers: []
+	},
+	"spec-reviewer": {
+		name: "spec-reviewer",
+		description: "Use after an implementation worker reports DONE or DONE_WITH_CONCERNS to verify the actual changed files against the task text, approved spec, acceptance criteria, and claimed result. Reads code and docs only; does not edit.",
+		purpose: "Catch missing requirements, extra scope, and misunderstandings before code-quality review.",
+		prompt: `You are reviewing whether an implementation matches its specification.
+
+Work only from the full task text, approved spec excerpts, acceptance
+criteria, changed-file list, and implementer report provided in the prompt.
+Do not assume hidden chat history and do not trust the implementer report
+without checking the actual files.
+
+Read the changed code and documentation. Compare actual behavior against the
+requested behavior line by line. Look for missing requirements, extra
+unrequested work, changed contracts, wrong interpretation, and fixture or
+documentation drift.
+
+Do not edit files, run broad commands, install dependencies, read secrets,
+contact production systems, or upload source. If the prompt lacks enough
+context to review, report NEEDS_CONTEXT.
+
+Report exactly:
+- Status: COMPLIANT | ISSUES_FOUND | NEEDS_CONTEXT
+- Requirements checked
+- Findings with severity, path, and line or symbol when available
+- Extra or out-of-scope work, if any
+- Missing tests or docs tied to acceptance criteria
+- Recommendation: proceed to code-quality review, fix first, or request context`,
+		toolScope: "read-only",
+		modelPreference: "capable",
+		maxTurns: 10,
+		timeoutMinutes: 8,
+		mcpServers: []
+	},
+	"code-quality-reviewer": {
+		name: "code-quality-reviewer",
+		description: "Use only after spec review passes to assess maintainability, decomposition, tests, naming, risky mocks, and local code quality in the changed files. Reads code and docs only; does not edit.",
+		purpose: "Catch maintainability and test-quality risks after the implementation is known to match the spec.",
+		prompt: `You are reviewing code quality after spec compliance has passed.
+
+Work only from the full task text, approved spec excerpts, changed-file list,
+spec-review result, test results, and implementer report provided in the
+prompt. Do not assume hidden chat history.
+
+Review only the change's contribution. Do not flag pre-existing file size or
+architecture unless the change makes it materially worse. Check whether each
+touched file has a clear responsibility, whether names describe intent,
+whether complex predicates should be named, whether tests verify behavior
+rather than mocks, whether mocks preserve required real side effects, and
+whether new APIs exist only for tests.
+
+Do not edit files, run broad commands, install dependencies, read secrets,
+contact production systems, or upload source. If the prompt lacks enough
+context to review, report NEEDS_CONTEXT.
+
+Report exactly:
+- Status: ACCEPTABLE | ISSUES_FOUND | NEEDS_CONTEXT
+- Strengths
+- Issues grouped as Critical, Important, or Minor
+- Test-quality concerns
+- Maintainability concerns
+- Assessment: ready, fix first, or request context`,
+		toolScope: "read-only",
+		modelPreference: "capable",
+		maxTurns: 10,
+		timeoutMinutes: 8,
+		mcpServers: []
+	}
+};
+var SUBAGENT_TEMPLATES = {
+	implementer: freezeTemplate(SUBAGENT_TEMPLATES_RAW.implementer),
+	"spec-reviewer": freezeTemplate(SUBAGENT_TEMPLATES_RAW["spec-reviewer"]),
+	"code-quality-reviewer": freezeTemplate(SUBAGENT_TEMPLATES_RAW["code-quality-reviewer"])
+};
+function expandSubagentEntry(entry) {
+	if (isSubagentTemplateRef(entry)) return cloneTemplate(SUBAGENT_TEMPLATES[entry.useTemplate]);
+	return entry;
+}
+function getSubagentTemplateRefs(profile) {
+	const block = profile.capabilities?.delegation?.subagents;
+	if (!block || block.enabled !== true) return [];
+	const refs = [];
+	for (const entry of block.agents ?? []) if (isSubagentTemplateRef(entry)) refs.push(entry.useTemplate);
+	return refs;
+}
+function normalizeSubagentName(name) {
+	return name.toLowerCase().replace(/_/gu, "-");
+}
+function getSubagentDefaults(profile) {
+	const defaults = profile.capabilities?.delegation?.subagents?.defaults;
+	return {
+		maxConcurrent: defaults?.maxConcurrent ?? 3,
+		maxDepth: defaults?.maxDepth ?? 1
+	};
+}
+function getEnabledSubagents(profile) {
+	const block = profile.capabilities?.delegation?.subagents;
+	if (!block || block.enabled !== true) return [];
+	return (block.agents ?? []).map((entry) => expandSubagentEntry(entry));
+}
+var SUBAGENT_BUILTIN_NAMES_NORMALIZED = new Set([
+	"default",
+	"worker",
+	"explorer",
+	"explore",
+	"plan",
+	"general-purpose",
+	"codebase-investigator",
+	"remote-codebase-investigator",
+	"generalist",
+	"browser-agent"
+]);
+function isSubagentBuiltinNameCollision(name) {
+	return SUBAGENT_BUILTIN_NAMES_NORMALIZED.has(normalizeSubagentName(name));
+}
 var compiledValidator;
 var DEFAULT_SAFETY = {
 	mode: "guarded",
@@ -16398,6 +16715,11 @@ function validateProfileValue(value) {
 	const validate = getValidator();
 	if (validate(value)) {
 		const profile = value;
+		const subagentIssues = validateSubagentSemantics(profile);
+		if (subagentIssues.length > 0) return {
+			ok: false,
+			issues: subagentIssues.sort((left, right) => compareIssues$1(left, right))
+		};
 		return {
 			ok: true,
 			profile,
@@ -16410,6 +16732,38 @@ function validateProfileValue(value) {
 		issues: toValidationIssues(validate.errors ?? [], value)
 	};
 }
+function validateSubagentSemantics(profile) {
+	const subagents = profile.capabilities?.delegation?.subagents;
+	if (!subagents || subagents.enabled !== true) return [];
+	const entries = subagents.agents ?? [];
+	const issues = [];
+	const seenRaw = /* @__PURE__ */ new Map();
+	const seenNormalized = /* @__PURE__ */ new Map();
+	entries.forEach((entry, index) => {
+		const name = expandSubagentEntry(entry).name;
+		const rawIndex = seenRaw.get(name);
+		if (rawIndex !== void 0) issues.push({
+			code: "schema_validation_error",
+			path: `/capabilities/delegation/subagents/agents/${index}/name`,
+			expected: "unique subagent name",
+			actual: "duplicate",
+			message: `/capabilities/delegation/subagents/agents/${index}/name duplicates the name used at index ${rawIndex}.`
+		});
+		else seenRaw.set(name, index);
+		const normalized = normalizeSubagentName(name);
+		const normalizedIndex = seenNormalized.get(normalized);
+		if (normalizedIndex !== void 0 && normalizedIndex !== index) {
+			if (!(rawIndex !== void 0)) issues.push({
+				code: "schema_validation_error",
+				path: `/capabilities/delegation/subagents/agents/${index}/name`,
+				expected: "unique normalized subagent id",
+				actual: "duplicate after hyphen/underscore folding",
+				message: `/capabilities/delegation/subagents/agents/${index}/name collides with the name used at index ${normalizedIndex} after normalization.`
+			});
+		} else if (normalizedIndex === void 0) seenNormalized.set(normalized, index);
+	});
+	return issues;
+}
 function normalizeSafety(profile) {
 	return {
 		mode: profile.safety?.mode ?? DEFAULT_SAFETY.mode,
@@ -16449,11 +16803,17 @@ function renderProfileYaml(profile) {
 		if (profile.safety.requiresSandbox !== void 0) safety["requiresSandbox"] = profile.safety.requiresSandbox;
 		doc["safety"] = safety;
 	}
-	doc["workflow"] = {
+	const workflow = {
 		sdd: profile.workflow.sdd,
 		tdd: profile.workflow.tdd,
 		finalReview: profile.workflow.finalReview
 	};
+	if (profile.workflow.codeReview !== void 0) workflow["codeReview"] = profile.workflow.codeReview;
+	if (profile.workflow.refactoring !== void 0) workflow["refactoring"] = profile.workflow.refactoring;
+	if (profile.workflow.documentation !== void 0) workflow["documentation"] = profile.workflow.documentation;
+	if (profile.workflow.subagentDrivenDevelopment !== void 0) workflow["subagentDrivenDevelopment"] = profile.workflow.subagentDrivenDevelopment;
+	doc["workflow"] = workflow;
+	if (profile.capabilities !== void 0) doc["capabilities"] = buildCapabilitiesDoc(profile.capabilities);
 	if (profile.permissions !== void 0) doc["permissions"] = buildPermissionsDoc(profile.permissions);
 	return distExports.stringify(doc, {
 		lineWidth: 0,
@@ -16461,6 +16821,40 @@ function renderProfileYaml(profile) {
 		sortMapEntries: false
 	}).replace(/\n+$/, "") + "\n";
 }
+function buildCapabilitiesDoc(capabilities) {
+	const doc = {};
+	if (capabilities.delegation !== void 0) {
+		const delegation = {};
+		const subagents = capabilities.delegation.subagents;
+		if (subagents !== void 0) {
+			const block = { enabled: subagents.enabled };
+			if (subagents.defaults !== void 0) {
+				const defaults = {};
+				if (subagents.defaults.maxConcurrent !== void 0) defaults["maxConcurrent"] = subagents.defaults.maxConcurrent;
+				if (subagents.defaults.maxDepth !== void 0) defaults["maxDepth"] = subagents.defaults.maxDepth;
+				if (Object.keys(defaults).length > 0) block["defaults"] = defaults;
+			}
+			if (subagents.agents !== void 0) block["agents"] = subagents.agents.map((entry) => isSubagentTemplateRef(entry) ? { useTemplate: entry.useTemplate } : buildSubagentDoc(entry));
+			delegation["subagents"] = block;
+		}
+		if (Object.keys(delegation).length > 0) doc["delegation"] = delegation;
+	}
+	return doc;
+}
+function buildSubagentDoc(agent) {
+	const out = {
+		name: agent.name,
+		description: agent.description,
+		purpose: agent.purpose,
+		prompt: agent.prompt,
+		toolScope: agent.toolScope
+	};
+	if (agent.modelPreference !== void 0) out["modelPreference"] = agent.modelPreference;
+	if (agent.maxTurns !== void 0) out["maxTurns"] = agent.maxTurns;
+	if (agent.timeoutMinutes !== void 0) out["timeoutMinutes"] = agent.timeoutMinutes;
+	if (agent.mcpServers !== void 0) out["mcpServers"] = agent.mcpServers;
+	return out;
+}
 function buildPermissionsDoc(p) {
 	const doc = {};
 	if (p.filesystem !== void 0) {
@@ -16654,12 +17048,15 @@ function getDefaultTargetIds() {
 		"lockfile",
 		"tabnine-guidelines",
 		"tabnine-mcp-config",
+		"tabnine-subagents",
 		"codex-config",
 		"codex-workflow-skills",
+		"codex-subagents",
 		"claude-settings",
 		"claude-mcp",
 		"claude-md",
-		"claude-workflow-skills"
+		"claude-workflow-skills",
+		"claude-subagents"
 	];
 }
 function createGeneratedTextFile(path, target, templateId, text) {
@@ -16694,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) {
@@ -16713,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));
@@ -16731,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) {
@@ -16749,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;
@@ -16765,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)) {
@@ -16823,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;
@@ -16856,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"));
@@ -16913,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
 	};
 }
@@ -16927,106 +17499,663 @@ function compareLockTemplates(left, right) {
 function compareLockOutputs(left, right) {
 	return compareText(left.path, right.path) || compareText(left.target, right.target);
 }
-//#endregion
-//#region ../../packages/compiler/src/compiler.ts
-var WORKFLOW_SKILLS = [
-	{
-		id: "sdd-change",
-		workflowFlag: "sdd"
-	},
-	{
-		id: "tdd-change",
-		workflowFlag: "tdd"
-	},
-	{
-		id: "final-review",
-		workflowFlag: "finalReview"
-	}
-];
-var TEMPLATE_SOURCES = [
-	{
-		id: "targets/agents-md@1",
-		target: "agents-md",
-		version: "1",
-		source: renderAgentsMdTemplateSource()
-	},
-	{
-		id: "targets/lockfile@1",
-		target: "lockfile",
-		version: "1",
-		source: renderLockfileTemplateSource()
-	},
-	guidelineTemplateSource("targets/tabnine-guidelines/00-general-agent-behavior@1", renderGeneralAgentBehaviorTemplateSource),
-	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),
-	guidelineTemplateSource("targets/tabnine-guidelines/40-stack-java-spring@1", renderJavaSpringGuideline),
-	guidelineTemplateSource("targets/tabnine-guidelines/50-testing-playwright-junit@1", renderPlaywrightJunitGuideline),
-	guidelineTemplateSource("targets/tabnine-guidelines/90-final-review@1", renderFinalReviewGuideline),
-	{
-		id: "targets/tabnine-mcp-config@1",
-		target: "tabnine-mcp-config",
-		version: "1",
-		source: JSON.stringify({ mcpServers: {} }, null, 2)
-	},
-	{
-		id: "targets/codex-config@1",
-		target: "codex-config",
-		version: "1",
-		source: renderCodexConfigToml()
-	},
-	workflowSkillTemplateSource("targets/codex-workflow-skills/sdd-change@1", "codex-workflow-skills", "sdd-change"),
-	workflowSkillTemplateSource("targets/codex-workflow-skills/tdd-change@1", "codex-workflow-skills", "tdd-change"),
-	workflowSkillTemplateSource("targets/codex-workflow-skills/final-review@1", "codex-workflow-skills", "final-review"),
-	{
-		id: "targets/claude-settings@1",
-		target: "claude-settings",
-		version: "1",
-		source: renderClaudeSettingsJson()
-	},
-	{
-		id: "targets/claude-mcp@1",
-		target: "claude-mcp",
-		version: "1",
-		source: JSON.stringify({ mcpServers: {} }, null, 2)
-	},
-	{
-		id: "targets/claude-md@1",
-		target: "claude-md",
-		version: "1",
-		source: renderClaudeMd()
-	},
-	workflowSkillTemplateSource("targets/claude-workflow-skills/sdd-change@1", "claude-workflow-skills", "sdd-change"),
-	workflowSkillTemplateSource("targets/claude-workflow-skills/tdd-change@1", "claude-workflow-skills", "tdd-change"),
-	workflowSkillTemplateSource("targets/claude-workflow-skills/final-review@1", "claude-workflow-skills", "final-review")
-];
-function getDefaultTemplates() {
-	return TEMPLATE_SOURCES.map(({ id, target, version, source }) => ({
-		id,
-		target,
-		version,
-		sha256: sha256Hex(normalizeGeneratedText(source))
-	})).sort(compareTemplates);
+function compareLockOutputsV2(left, right) {
+	return compareText(left.path, right.path) || compareText(left.target, right.target);
 }
-function compileProfile(request) {
-	const targets = uniqueTargets(request.targets ?? getEnabledTargetIds(request.profile));
-	const templates = request.templates ?? getDefaultTemplates();
-	const issues = validateTargets(request.profile, targets, templates);
-	if (issues.length > 0) return {
-		ok: false,
-		issues: issues.sort(compareIssues)
-	};
-	return {
-		ok: true,
-		files: targets.flatMap((target) => renderTarget(target, request.profile)).sort(compareGeneratedFiles),
-		templates: templates.filter((template) => targets.includes(template.target)).sort(compareTemplates)
-	};
+/**
+* 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 = {
+	tabnineTitle: "TypeScript and React Stack",
+	agentsMdTitle: "Stack Guidance — React",
+	intro: "Use the existing TypeScript and React conventions in the repository.",
+	subsections: [
+		{
+			heading: "TypeScript Discipline",
+			bullets: [
+				"Do not use `any` without a documented reason.",
+				"Declare explicit types for exported functions, props, and return values.",
+				"Reuse existing types and utilities before adding new ones."
+			]
+		},
+		{
+			heading: "Component Conventions",
+			bullets: [
+				"Use function components with typed props.",
+				"Co-locate components with the modules that own them.",
+				"Keep render-only components free of side effects."
+			]
+		},
+		{
+			heading: "Hook Discipline",
+			bullets: [
+				"Add memoization (`useMemo`, `useCallback`) only when a measured re-render or referential-identity problem exists.",
+				"Keep state local; do not introduce a global store by default.",
+				"Honor the rules of hooks; never call hooks conditionally."
+			]
+		},
+		{
+			heading: "Styling",
+			bullets: ["Follow the existing styling approach in the repository.", "Do not introduce a new CSS framework or component library."]
+		},
+		{
+			heading: "API Calls",
+			bullets: [
+				"Reuse existing client utilities for HTTP and data access.",
+				"Type both request payloads and response bodies.",
+				"Handle error and loading states explicitly."
+			]
+		},
+		{
+			heading: "SDD and TDD Focus",
+			bullets: [
+				"Cover state transitions, API success, error, and loading paths.",
+				"Cover accessibility-affecting behavior (focus, keyboard, ARIA).",
+				"Add or update focused tests before changing observable behavior."
+			]
+		}
+	],
+	tabnineChecklistReference: "See `90-final-review.md` for the shared final-review checklist.",
+	agentsMdChecklistReference: "See the `## Completion Checklist` section for shared review steps."
+};
+var CODE_REVIEW_TOPIC = {
+	tabnineTitle: "Code Review",
+	agentsMdTitle: "Code Review",
+	intro: "Use these rules when reviewing a pull request or proposed change.",
+	subsections: [
+		{
+			heading: "Review Focus",
+			bullets: [
+				"Correctness and edge cases.",
+				"Security, including input validation and secret handling.",
+				"Performance hotspots and obvious complexity regressions.",
+				"Unnecessary complexity or premature abstraction.",
+				"Consistency with existing project style.",
+				"Missing or weakened tests.",
+				"Weak typing or unjustified `any`.",
+				"Accessibility-affecting behavior in user-facing changes.",
+				"Error handling and observability gaps.",
+				"Dependency risk and license concerns.",
+				"Spec compliance."
+			]
+		},
+		{
+			heading: "Severity Labels",
+			bullets: [
+				"Blocker: must fix before merge (correctness, security, contract break).",
+				"High: must fix before merge unless explicitly deferred.",
+				"Medium: should fix before merge or open a tracked follow-up.",
+				"Low: nit or polish; safe to defer."
+			]
+		},
+		{
+			heading: "Output Format",
+			bullets: [
+				"Summary: one paragraph of intent and overall verdict.",
+				"Spec Compliance: cite the spec and any deviation.",
+				"Findings: grouped by severity, each with file, function, and concrete suggestion.",
+				"Tests: list coverage gaps and whether tests were run.",
+				"Safety Review: secrets, production access, dependency installs, network access.",
+				"Final recommendation: approve, request changes, or block with reason."
+			]
+		},
+		{
+			heading: "Review Discipline",
+			bullets: [
+				"Skip nitpicks the autoformatter or linter already handles.",
+				"Do not propose broad rewrites; keep suggestions actionable.",
+				"Reference the specific file, function, or component in every finding."
+			]
+		}
+	],
+	tabnineChecklistReference: "See `90-final-review.md` for the shared final-review checklist.",
+	agentsMdChecklistReference: "See the `## Completion Checklist` section for shared review steps."
+};
+var REFACTORING_TOPIC = {
+	tabnineTitle: "Refactoring",
+	agentsMdTitle: "Refactoring",
+	intro: "Use these rules when restructuring code without changing observable behavior.",
+	subsections: [
+		{
+			heading: "Principles",
+			bullets: [
+				"Refactor to remove duplication, clarify intent, or unlock a planned change.",
+				"Do not refactor for style preference alone or to chase a new pattern.",
+				"Keep refactoring commits separate from behavior changes."
+			]
+		},
+		{
+			heading: "Safe Refactoring Workflow",
+			bullets: [
+				"Identify the code smell or constraint that motivates the change.",
+				"Check existing abstractions before introducing a new one.",
+				"Define expected behavior in tests before restructuring.",
+				"Make the smallest extraction that solves the problem.",
+				"Preserve public behavior; run tests and golden fixtures after each step.",
+				"Summarize what was intentionally not changed in the review notes."
+			]
+		},
+		{
+			heading: "Restrictions",
+			bullets: [
+				"Do not rename public APIs without explicit approval.",
+				"Do not move files across modules without explicit approval.",
+				"Do not change schemas, endpoint contracts, or build tooling without explicit approval.",
+				"Do not refactor and add features in the same change."
+			]
+		}
+	],
+	tabnineChecklistReference: "See `90-final-review.md` for the shared final-review checklist.",
+	agentsMdChecklistReference: "See the `## Completion Checklist` section for shared review steps."
+};
+var DOCUMENTATION_TOPIC = {
+	tabnineTitle: "Documentation",
+	agentsMdTitle: "Documentation",
+	intro: "Use these rules when adding or updating project documentation.",
+	subsections: [
+		{
+			heading: "When to Update Documentation",
+			bullets: [
+				"Setup or onboarding steps changed.",
+				"Workflow, command, or build step changed.",
+				"Public API surface changed.",
+				"Configuration or environment variables changed.",
+				"Testing command changed.",
+				"Deployment or release procedure changed.",
+				"Troubleshooting guidance is newly known."
+			]
+		},
+		{
+			heading: "Style",
+			bullets: [
+				"Write for maintainers, not marketing.",
+				"Provide copy-pasteable commands where applicable.",
+				"Keep examples current; remove examples that no longer run.",
+				"Reference file paths when they help a reader navigate."
+			]
+		},
+		{
+			heading: "README Rules",
+			bullets: [
+				"Keep the existing structure intact.",
+				"Add only relevant new sections.",
+				"Do not rewrite the README without an explicit request."
+			]
+		},
+		{
+			heading: "Code Comment Policy",
+			bullets: [
+				"Comment non-obvious business rules and invariants.",
+				"Comment tricky edge cases the code alone does not reveal.",
+				"Comment surprising technical constraints and security-sensitive behavior.",
+				"Do not write comments that restate the code."
+			]
+		}
+	],
+	tabnineChecklistReference: "See `90-final-review.md` for the shared final-review checklist.",
+	agentsMdChecklistReference: "See the `## Completion Checklist` section for shared review steps."
+};
+function renderTopicAsTabnineGuideline(topic) {
+	const sections = topic.subsections.map((subsection) => `## ${subsection.heading}\n\n${subsection.bullets.map((bullet) => `- ${bullet}`).join("\n")}\n`).join("\n");
+	return `<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# ${topic.tabnineTitle}
+
+${topic.intro}
+
+${sections}
+${topic.tabnineChecklistReference}
+`;
+}
+function renderTopicAsAgentsMdSection(topic) {
+	const subsections = topic.subsections.map((subsection) => `**${subsection.heading}**\n\n${subsection.bullets.map((bullet) => `- ${bullet}`).join("\n")}`).join("\n\n");
+	return `## ${topic.agentsMdTitle}
+
+${topic.intro}
+
+${subsections}
+
+${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"
+	},
+	{
+		id: "tdd-change",
+		workflowFlag: "tdd"
+	},
+	{
+		id: "final-review",
+		workflowFlag: "finalReview"
+	},
+	{
+		id: "subagent-driven-change",
+		workflowFlag: "subagentDrivenDevelopment"
+	}
+];
+var TEMPLATE_SOURCES = [
+	{
+		id: "targets/agents-md@1",
+		target: "agents-md",
+		version: "1",
+		source: renderAgentsMdTemplateSource()
+	},
+	agentsMdTopicTemplateSource("targets/agents-md/30-stack-typescript-react@1", REACT_STACK_TOPIC),
+	agentsMdTopicTemplateSource("targets/agents-md/60-code-review@1", CODE_REVIEW_TOPIC),
+	agentsMdTopicTemplateSource("targets/agents-md/70-refactoring@1", REFACTORING_TOPIC),
+	agentsMdTopicTemplateSource("targets/agents-md/80-documentation@1", DOCUMENTATION_TOPIC),
+	{
+		id: "targets/lockfile@1",
+		target: "lockfile",
+		version: "1",
+		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),
+	guidelineTemplateSource("targets/tabnine-guidelines/30-stack-typescript-react@1", renderTypeScriptReactGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/40-stack-java-spring@1", renderJavaSpringGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/50-testing-playwright-junit@1", renderPlaywrightJunitGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/60-code-review@1", renderCodeReviewGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/70-refactoring@1", renderRefactoringGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/80-documentation@1", renderDocumentationGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/90-final-review@1", renderFinalReviewGuideline),
+	{
+		id: "targets/tabnine-mcp-config@1",
+		target: "tabnine-mcp-config",
+		version: "1",
+		source: JSON.stringify({ mcpServers: {} }, null, 2)
+	},
+	{
+		id: "targets/codex-config@1",
+		target: "codex-config",
+		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"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/subagent-driven-change@1", "codex-workflow-skills", "subagent-driven-change"),
+	{
+		id: "targets/claude-settings@1",
+		target: "claude-settings",
+		version: "1",
+		source: renderClaudeSettingsJson()
+	},
+	{
+		id: "targets/claude-mcp@1",
+		target: "claude-mcp",
+		version: "1",
+		source: JSON.stringify({ mcpServers: {} }, null, 2)
+	},
+	{
+		id: "targets/claude-md@1",
+		target: "claude-md",
+		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"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/subagent-driven-change@1", "claude-workflow-skills", "subagent-driven-change")
+];
+function getDefaultTemplates() {
+	return TEMPLATE_SOURCES.map(({ id, target, version, source }) => ({
+		id,
+		target,
+		version,
+		sha256: sha256Hex(normalizeGeneratedText(source))
+	})).sort(compareTemplates);
+}
+function compileProfile(request) {
+	const targets = uniqueTargets(request.targets ?? getEnabledTargetIds(request.profile));
+	const templates = request.templates ?? mergeTemplates(getDefaultTemplates(), getSubagentTemplates(request.profile));
+	const issues = validateTargets(request.profile, targets, templates);
+	if (issues.length > 0) return {
+		ok: false,
+		issues: issues.sort(compareIssues)
+	};
+	const files = targets.flatMap((target) => renderTarget(target, request.profile));
+	const requiredTemplateIds = getRequiredTemplateIdSet(targets, request.profile);
+	return {
+		ok: true,
+		files: files.sort(compareGeneratedFiles),
+		templates: templates.filter((template) => requiredTemplateIds.has(template.id)).sort(compareTemplates)
+	};
+}
+function mergeTemplates(base, extra) {
+	const seen = new Set(base.map((template) => template.id));
+	const result = [...base];
+	for (const template of extra) if (!seen.has(template.id)) {
+		seen.add(template.id);
+		result.push(template);
+	}
+	return result.sort(compareTemplates);
+}
+function getSubagentTemplates(profile) {
+	const agents = getEnabledSubagents(profile);
+	if (agents.length === 0) return [];
+	const effective = deriveEffectivePermissions(profile);
+	const templates = [];
+	if (profile.clients.claude.enabled) for (const agent of agents) templates.push({
+		id: `targets/claude-subagents/${agent.name}@1`,
+		target: "claude-subagents",
+		version: "1",
+		sha256: sha256Hex(normalizeGeneratedText(renderClaudeSubagent(agent, effective)))
+	});
+	if (profile.clients.codex.enabled) for (const agent of agents) templates.push({
+		id: `targets/codex-subagents/${agent.name}@1`,
+		target: "codex-subagents",
+		version: "1",
+		sha256: sha256Hex(normalizeGeneratedText(renderCodexSubagent(agent, effective)))
+	});
+	if (profile.clients.tabnine.enabled) for (const agent of agents) {
+		if (agent.toolScope !== "read-only") continue;
+		templates.push({
+			id: `targets/tabnine-subagents/${agent.name}@1`,
+			target: "tabnine-subagents",
+			version: "1",
+			sha256: sha256Hex(normalizeGeneratedText(renderTabnineSubagent(agent)))
+		});
+	}
+	return templates;
 }
 function renderAgentsMd(profile) {
 	const effectivePermissions = deriveEffectivePermissions(profile);
 	const enabledClients = renderEnabledClients(profile);
+	const reactSection = profile.stack.frameworks.includes("react") ? `\n${renderTopicAsAgentsMdSection(REACT_STACK_TOPIC)}` : "";
+	const codeReviewSection = profile.workflow.codeReview === true ? `\n${renderTopicAsAgentsMdSection(CODE_REVIEW_TOPIC)}` : "";
+	const refactoringSection = profile.workflow.refactoring === true ? `\n${renderTopicAsAgentsMdSection(REFACTORING_TOPIC)}` : "";
+	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)}
@@ -17039,7 +18168,7 @@ Description: ${escapeMarkdownText(profile.profile.description)}
 - Frameworks: ${renderList(profile.stack.frameworks)}
 - Package managers: ${renderList(profile.stack.packageManagers)}
 - Testing: ${renderList(profile.stack.testing)}
-
+${reactSection}
 ## Enabled AI Clients
 
 ${enabledClients}
@@ -17049,7 +18178,7 @@ ${enabledClients}
 - SDD: ${renderRequired(profile.workflow.sdd)}
 - TDD: ${renderRequired(profile.workflow.tdd)}
 - Final implementation review: ${renderRequired(profile.workflow.finalReview)}
-
+${codeReviewSection}${refactoringSection}${documentationSection}
 ## Permissions
 
 | Permission         | Mode  |
@@ -17086,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
@@ -17117,7 +18250,10 @@ function renderTarget(target, profile) {
 		case "tabnine-guidelines": return renderTabnineGuidelines(profile);
 		case "lockfile": return [];
 		case "tabnine-mcp-config": return [createGeneratedTextFile(".tabnine/mcp_servers.json", "tabnine-mcp-config", "targets/tabnine-mcp-config@1", JSON.stringify({ mcpServers: {} }, null, 2))];
-		case "codex-config": return [createGeneratedTextFile(".codex/config.toml", "codex-config", "targets/codex-config@1", renderCodexConfigToml())];
+		case "codex-config": return [createGeneratedTextFile(".codex/config.toml", "codex-config", "targets/codex-config@1", renderCodexConfigToml(profile))];
+		case "codex-subagents": return renderCodexSubagentFiles(profile);
+		case "claude-subagents": return renderClaudeSubagentFiles(profile);
+		case "tabnine-subagents": return renderTabnineSubagentFiles(profile);
 		case "codex-workflow-skills": return renderWorkflowSkillFiles(profile, "codex-workflow-skills", ".agents/skills");
 		case "claude-settings": return [createGeneratedTextFile(".claude/settings.json", "claude-settings", "targets/claude-settings@1", renderClaudeSettingsJson())];
 		case "claude-mcp": return [createGeneratedTextFile(".mcp.json", "claude-mcp", "targets/claude-mcp@1", JSON.stringify({ mcpServers: {} }, null, 2))];
@@ -17128,19 +18264,216 @@ 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()));
 	if (hasStack(profile, "languages", "java") && hasStack(profile, "frameworks", "spring-boot")) files.push(createGeneratedTextFile(".tabnine/guidelines/40-stack-java-spring.md", common.target, "targets/tabnine-guidelines/40-stack-java-spring@1", renderJavaSpringGuideline()));
 	if (hasAnyStack(profile, "testing", ["playwright", "junit"])) files.push(createGeneratedTextFile(".tabnine/guidelines/50-testing-playwright-junit.md", common.target, "targets/tabnine-guidelines/50-testing-playwright-junit@1", renderPlaywrightJunitGuideline()));
+	if (profile.workflow.codeReview === true) files.push(createGeneratedTextFile(".tabnine/guidelines/60-code-review.md", common.target, "targets/tabnine-guidelines/60-code-review@1", renderCodeReviewGuideline()));
+	if (profile.workflow.refactoring === true) files.push(createGeneratedTextFile(".tabnine/guidelines/70-refactoring.md", common.target, "targets/tabnine-guidelines/70-refactoring@1", renderRefactoringGuideline()));
+	if (profile.workflow.documentation === true) files.push(createGeneratedTextFile(".tabnine/guidelines/80-documentation.md", common.target, "targets/tabnine-guidelines/80-documentation@1", renderDocumentationGuideline()));
 	if (profile.workflow.finalReview) files.push(createGeneratedTextFile(".tabnine/guidelines/90-final-review.md", common.target, "targets/tabnine-guidelines/90-final-review@1", renderFinalReviewGuideline()));
 	return files;
 }
 function renderWorkflowSkillFiles(profile, target, rootPath) {
-	return WORKFLOW_SKILLS.filter((skill) => profile.workflow[skill.workflowFlag]).map((skill) => createGeneratedTextFile(`${rootPath}/${skill.id}/SKILL.md`, target, `targets/${target}/${skill.id}@1`, renderWorkflowSkill(skill.id)));
+	return WORKFLOW_SKILLS.filter((skill) => profile.workflow[skill.workflowFlag]).map((skill) => createGeneratedTextFile(`${rootPath}/${skill.id}/SKILL.md`, target, getWorkflowSkillTemplateId(target, skill.id), renderWorkflowSkill(skill.id)));
+}
+function getWorkflowSkillTemplateId(target, skill) {
+	return `targets/${target}/${skill}@${skill === "tdd-change" ? "2" : "1"}`;
 }
 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.
@@ -17168,7 +18501,7 @@ description: Use when implementing a meaningful repository change that requires
 `;
 		case "tdd-change": return `---
 name: tdd-change
-description: Use when changing behavior where a focused failing test or golden fixture should lead the implementation.
+description: Use when changing behavior where a focused failing test or golden fixture must prove RED before implementation and GREEN after the minimal fix.
 ---
 
 <!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
@@ -17178,11 +18511,24 @@ description: Use when changing behavior where a focused failing test or golden f
 ## Instructions
 
 1. Identify the smallest observable behavior covered by the approved spec.
-2. Add or update the focused failing test first when practical.
-3. For generated outputs, add or review the golden fixture intentionally.
-4. Implement the smallest change that satisfies the test and spec.
-5. Run the relevant test command and report any test that cannot be run.
-6. Do not update golden files only to hide an unexplained behavior change.
+2. Add or update one focused failing test or golden fixture before changing behavior code.
+3. Run the narrowest relevant test command and confirm RED: the test fails for the expected reason, not because of a typo, setup error, or unrelated failure.
+4. Implement the smallest change that satisfies the failing test and the spec.
+5. Run the same focused test command and confirm GREEN: the test passes without new warnings or unrelated failures.
+6. Refactor only after GREEN, then rerun the focused test command.
+7. Do not update golden files only to hide an unexplained behavior change.
+
+## Testing Anti-Patterns
+
+- Do not assert on mock elements or mock call counts when a real behavior assertion is possible.
+- Do not add production methods, flags, or exports that exist only for tests.
+- Do not mock a dependency until you understand the side effects the test needs.
+- Keep test doubles structurally complete enough to match the real data shape consumed by the code.
+- If mock setup is larger than the behavior under test, consider a narrower integration test or a simpler production boundary.
+
+## Output
+
+Report the RED command and expected failure, the GREEN command and passing result, any refactor rerun, and any TDD exception that required human approval.
 
 ## Safety
 
@@ -17211,6 +18557,55 @@ description: Use before handing off an implementation to compare the diff agains
 ## Output
 
 Return a concise final review with spec compliance, tests run, contract impact, security impact, and remaining risks.
+`;
+		case "subagent-driven-change": return `---
+name: subagent-driven-change
+description: Use when a scoped implementation can be delegated to an implementation subagent and then independently reviewed for spec compliance before code quality.
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# Subagent-Driven Change
+
+## Preconditions
+
+Use this workflow only when the task has a clear spec, acceptance criteria, and file ownership. Keep tightly coupled or architectural decisions in the parent session unless the user explicitly asks for delegation.
+
+Required subagents: \`implementer\`, \`spec-reviewer\`, and \`code-quality-reviewer\`.
+
+## Fresh Context
+
+Each subagent prompt must include the full task text, relevant spec excerpts, non-goals, acceptance criteria, file ownership, constraints, expected tests, and any command limits. Do not rely on hidden chat history or a previous subagent's memory.
+
+## Flow
+
+1. Dispatch \`implementer\` with one bounded task and the complete context it needs.
+2. If \`implementer\` returns \`BLOCKED\` or \`NEEDS_CONTEXT\`, resolve that before continuing.
+3. If \`implementer\` returns \`DONE_WITH_CONCERNS\`, read the concerns before review and decide whether to fix, narrow scope, or continue.
+4. Dispatch \`spec-reviewer\` with the original task, relevant spec excerpts, changed files, and implementer report.
+5. Fix or escalate every spec-review issue before requesting code-quality review.
+6. Dispatch \`code-quality-reviewer\` only after spec review reports compliance.
+7. Fix Critical and Important code-quality issues before handoff, or document why a finding is intentionally deferred.
+8. Run the relevant tests, golden tests, and doctor/check commands required by the spec before final response.
+
+## Status Values
+
+Implementation worker status values: \`DONE\`, \`DONE_WITH_CONCERNS\`, \`BLOCKED\`, \`NEEDS_CONTEXT\`.
+
+Spec reviewer status values: \`COMPLIANT\`, \`ISSUES_FOUND\`, \`NEEDS_CONTEXT\`.
+
+Code-quality reviewer status values: \`ACCEPTABLE\`, \`ISSUES_FOUND\`, \`NEEDS_CONTEXT\`.
+
+## Safety
+
+- Do not ask subagents to commit, push, create branches, install dependencies, read secrets, contact production systems, or upload source unless the user explicitly requested that action.
+- Do not accept an implementation report without reading reviewer findings.
+- Do not run code-quality review before spec-compliance review passes.
+- Keep generated files deterministic and lockfile-tracked.
+
+## Output
+
+Final handoff must list what changed, tests run, contract impact, security impact, remaining risks or TODOs, and whether the spec acceptance criteria are fully met.
 `;
 	}
 }
@@ -17248,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. -->
 
@@ -17276,6 +18688,18 @@ Test-driven development is required for this project.
 - Do not update golden fixtures to hide an unexplained behavior change.
 `;
 }
+function renderTypeScriptReactGuideline() {
+	return renderTopicAsTabnineGuideline(REACT_STACK_TOPIC);
+}
+function renderCodeReviewGuideline() {
+	return renderTopicAsTabnineGuideline(CODE_REVIEW_TOPIC);
+}
+function renderRefactoringGuideline() {
+	return renderTopicAsTabnineGuideline(REFACTORING_TOPIC);
+}
+function renderDocumentationGuideline() {
+	return renderTopicAsTabnineGuideline(DOCUMENTATION_TOPIC);
+}
 function renderTypeScriptSvelteGuideline() {
 	return `<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
 
@@ -17334,14 +18758,115 @@ Final implementation review is required for this project.
 - List remaining risks or TODOs before considering the task complete.
 `;
 }
-function renderCodexConfigToml() {
-	return `approval_policy = "on-request"
+function renderCodexConfigToml(profile) {
+	const base = `approval_policy = "on-request"
 sandbox_mode = "workspace-write"
 allow_login_shell = false
 
 [sandbox_workspace_write]
 network_access = false
 `;
+	if (!profile || getEnabledSubagents(profile).length === 0) return base;
+	const defaults = getSubagentDefaults(profile);
+	return `${base}
+[agents]
+max_threads = ${defaults.maxConcurrent}
+max_depth = ${defaults.maxDepth}
+`;
+}
+function renderClaudeSubagentFiles(profile) {
+	const agents = getEnabledSubagents(profile);
+	const effective = deriveEffectivePermissions(profile);
+	return agents.map((agent) => createGeneratedTextFile(`.claude/agents/${agent.name}.md`, "claude-subagents", `targets/claude-subagents/${agent.name}@1`, renderClaudeSubagent(agent, effective)));
+}
+function renderCodexSubagentFiles(profile) {
+	const agents = getEnabledSubagents(profile);
+	const effective = deriveEffectivePermissions(profile);
+	return agents.map((agent) => createGeneratedTextFile(`.codex/agents/${agent.name}.toml`, "codex-subagents", `targets/codex-subagents/${agent.name}@1`, renderCodexSubagent(agent, effective)));
+}
+function renderTabnineSubagentFiles(profile) {
+	return getEnabledSubagents(profile).filter((agent) => agent.toolScope === "read-only").map((agent) => createGeneratedTextFile(`.tabnine/agent/agents/${agent.name}.md`, "tabnine-subagents", `targets/tabnine-subagents/${agent.name}@1`, renderTabnineSubagent(agent)));
+}
+function titleCaseFromKebab(name) {
+	return name.split("-").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function renderClaudeSubagent(agent, effective) {
+	const lines = ["---", `name: ${yamlScalarSafe(agent.name)}`];
+	lines.push(`description: ${yamlScalarSafe(agent.description)}`);
+	if (agent.toolScope === "read-only") lines.push("tools: Read, Glob, Grep");
+	else {
+		const tools = [
+			"Read",
+			"Glob",
+			"Grep"
+		];
+		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";
+	lines.push(`model: ${model === "inherit" ? "inherit" : "inherit"}`);
+	if (agent.toolScope === "read-only") lines.push("permissionMode: plan");
+	if (agent.maxTurns !== void 0) lines.push(`maxTurns: ${agent.maxTurns}`);
+	lines.push("---", "");
+	lines.push("<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->");
+	lines.push("");
+	lines.push(`# ${titleCaseFromKebab(agent.name)}`);
+	lines.push("");
+	lines.push(agent.prompt.trim());
+	lines.push("");
+	return lines.join("\n");
+}
+function renderCodexSubagent(agent, effective) {
+	const lines = [
+		"# Generated by Agent Profile Compiler. Do not edit by hand.",
+		"",
+		`name = "${escapeTomlString(agent.name)}"`,
+		`description = "${escapeTomlString(agent.description)}"`
+	];
+	if (agent.toolScope === "workspace-write" && effective.filesystem.write !== "deny") lines.push(`sandbox_mode = "workspace-write"`);
+	else lines.push(`sandbox_mode = "read-only"`);
+	if (agent.prompt.includes(`"""`)) throw new Error(`Codex subagent ${agent.name} prompt contains a TOML triple-quote sequence; compile validation should have rejected this.`);
+	lines.push("developer_instructions = \"\"\"");
+	for (const promptLine of agent.prompt.trim().split(/\r?\n/u)) lines.push(promptLine);
+	lines.push("\"\"\"");
+	lines.push("");
+	return lines.join("\n");
+}
+function renderTabnineSubagent(agent) {
+	const lines = ["---", `name: ${yamlScalarSafe(agent.name)}`];
+	lines.push(`description: ${yamlScalarSafe(agent.description)}`);
+	lines.push("kind: local");
+	lines.push("tools:");
+	for (const tool of ["grep_search", "read_file"].sort()) lines.push(`  - ${tool}`);
+	if (agent.maxTurns !== void 0) lines.push(`max_turns: ${agent.maxTurns}`);
+	if (agent.timeoutMinutes !== void 0) lines.push(`timeout_mins: ${agent.timeoutMinutes}`);
+	lines.push("---", "");
+	lines.push("<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->");
+	lines.push("");
+	lines.push(`# ${titleCaseFromKebab(agent.name)}`);
+	lines.push("");
+	lines.push(agent.prompt.trim());
+	lines.push("");
+	return lines.join("\n");
+}
+function escapeTomlString(value) {
+	return value.replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"");
+}
+function yamlScalarSafe(value) {
+	if (yamlScalarNeedsQuoting(value)) return JSON.stringify(value);
+	return value;
+}
+function yamlScalarNeedsQuoting(value) {
+	if (value.length === 0) return true;
+	if (/[\r\n\t]/u.test(value)) return true;
+	if (/^\s|\s$/u.test(value)) return true;
+	if (/^[\-?:,\[\]{}#&*!|>'"%@`]/u.test(value)) return true;
+	if (value.includes(": ") || value.includes(" #")) return true;
+	if (/^(?:true|false|null|yes|no|on|off|~)$/iu.test(value)) return true;
+	if (/^[+\-]?\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?$/u.test(value)) return true;
+	return false;
 }
 function renderAgentsMdTemplateSource() {
 	return `# AGENTS.md
@@ -17380,6 +18905,14 @@ function guidelineTemplateSource(id, render) {
 		source: render()
 	};
 }
+function agentsMdTopicTemplateSource(id, topic) {
+	return {
+		id,
+		target: "agents-md",
+		version: "1",
+		source: renderTopicAsAgentsMdSection(topic)
+	};
+}
 function workflowSkillTemplateSource(id, target, skill) {
 	return {
 		id,
@@ -17418,9 +18951,19 @@ function renderClaudeSettingsJson() {
 }
 function getEnabledTargetIds(profile) {
 	const targets = ["agents-md"];
-	if (profile.clients.tabnine.enabled) targets.push("tabnine-guidelines", "tabnine-mcp-config");
-	if (profile.clients.codex.enabled) targets.push("codex-config", "codex-workflow-skills");
-	if (profile.clients.claude.enabled) targets.push("claude-settings", "claude-mcp", "claude-md", "claude-workflow-skills");
+	const subagentsEnabled = getEnabledSubagents(profile).length > 0;
+	if (profile.clients.tabnine.enabled) {
+		targets.push("tabnine-guidelines", "tabnine-mcp-config");
+		if (subagentsEnabled) targets.push("tabnine-subagents");
+	}
+	if (profile.clients.codex.enabled) {
+		targets.push("codex-config", "codex-workflow-skills");
+		if (subagentsEnabled) targets.push("codex-subagents");
+	}
+	if (profile.clients.claude.enabled) {
+		targets.push("claude-settings", "claude-mcp", "claude-md", "claude-workflow-skills");
+		if (subagentsEnabled) targets.push("claude-subagents");
+	}
 	return targets;
 }
 function validateTargets(profile, targets, templates) {
@@ -17428,6 +18971,56 @@ function validateTargets(profile, targets, templates) {
 	const templateIds = new Set(templates.map((template) => template.id));
 	const enabledTargets = new Set(getEnabledTargetIds(profile));
 	const issues = [];
+	if (profile.workflow.subagentDrivenDevelopment === true) {
+		const refs = new Set(getSubagentTemplateRefs(profile));
+		const missing = SUBAGENT_TEMPLATE_NAMES.filter((name) => !refs.has(name));
+		if (missing.length > 0) issues.push({
+			code: "missing_required_template_reference",
+			path: "/workflow/subagentDrivenDevelopment",
+			expected: `useTemplate references for ${SUBAGENT_TEMPLATE_NAMES.join(", ")}`,
+			actual: `missing ${missing.join(", ")}`,
+			message: `workflow.subagentDrivenDevelopment requires capabilities.delegation.subagents.agents[].useTemplate references for ${missing.join(", ")}.`
+		});
+	}
+	if (targets.includes("tabnine-subagents")) {
+		const writeAgents = getEnabledSubagents(profile).filter((agent) => agent.toolScope === "workspace-write");
+		for (const agent of writeAgents) issues.push({
+			code: "unsafe_generated_content",
+			path: `.tabnine/agent/agents/${agent.name}.md`,
+			expected: "read-only Tabnine subagent",
+			actual: "workspace-write Tabnine subagent",
+			message: `tabnine-subagents cannot emit workspace-write agent ${agent.name} while Tabnine subagents are experimental/no-confirmation.`
+		});
+	}
+	if (targets.includes("codex-subagents")) {
+		const effective = deriveEffectivePermissions(profile);
+		for (const agent of getEnabledSubagents(profile)) {
+			if (agent.toolScope === "workspace-write" && effective.filesystem.write === "deny") issues.push({
+				code: "unsafe_generated_content",
+				path: `.codex/agents/${agent.name}.toml`,
+				expected: "narrower than effectivePermissions",
+				actual: "workspace-write subagent under filesystem.write=deny",
+				message: `codex-subagents cannot emit workspace-write agent ${agent.name} because effectivePermissions.filesystem.write is deny.`
+			});
+			if (agent.prompt.includes(`"""`)) issues.push({
+				code: "unsafe_generated_content",
+				path: `.codex/agents/${agent.name}.toml`,
+				expected: "prompt without TOML triple-quote sequence",
+				actual: "prompt contains \"\"\" delimiter",
+				message: `codex-subagents prompt for ${agent.name} contains a TOML triple-quote sequence that would break developer_instructions.`
+			});
+		}
+	}
+	if (targets.includes("claude-subagents")) {
+		const effective = deriveEffectivePermissions(profile);
+		for (const agent of getEnabledSubagents(profile)) if (agent.toolScope === "workspace-write" && effective.filesystem.write === "deny") issues.push({
+			code: "unsafe_generated_content",
+			path: `.claude/agents/${agent.name}.md`,
+			expected: "narrower than effectivePermissions",
+			actual: "workspace-write subagent under filesystem.write=deny",
+			message: `claude-subagents cannot emit workspace-write agent ${agent.name} because effectivePermissions.filesystem.write is deny.`
+		});
+	}
 	for (const target of targets) {
 		if (!supportedTargets.has(target)) {
 			issues.push({
@@ -17449,7 +19042,7 @@ function validateTargets(profile, targets, templates) {
 			});
 			continue;
 		}
-		for (const templateId of getRequiredTemplateIds(target)) if (!templateIds.has(templateId)) issues.push({
+		for (const templateId of getRequiredTemplateIds(target, profile)) if (!templateIds.has(templateId)) issues.push({
 			code: "missing_template",
 			path: target,
 			expected: templateId,
@@ -17459,8 +19052,48 @@ function validateTargets(profile, targets, templates) {
 	}
 	return issues;
 }
-function getRequiredTemplateIds(target) {
-	return TEMPLATE_SOURCES.filter((template) => template.target === target).map((template) => template.id);
+function getRequiredTemplateIdSet(targets, profile) {
+	return new Set(targets.flatMap((target) => getRequiredTemplateIds(target, profile)));
+}
+function getRequiredTemplateIds(target, profile) {
+	switch (target) {
+		case "agents-md": return ["targets/agents-md@1", ...getRequiredAgentsMdTopicTemplateIds(profile)];
+		case "tabnine-guidelines": return getRequiredTabnineGuidelineTemplateIds(profile);
+		case "codex-workflow-skills": return getRequiredWorkflowSkillTemplateIds(profile, "codex-workflow-skills");
+		case "claude-workflow-skills": return getRequiredWorkflowSkillTemplateIds(profile, "claude-workflow-skills");
+		case "claude-subagents": return getEnabledSubagents(profile).map((agent) => `targets/claude-subagents/${agent.name}@1`);
+		case "codex-subagents": return getEnabledSubagents(profile).map((agent) => `targets/codex-subagents/${agent.name}@1`);
+		case "tabnine-subagents": return getEnabledSubagents(profile).filter((agent) => agent.toolScope === "read-only").map((agent) => `targets/tabnine-subagents/${agent.name}@1`);
+		default: return TEMPLATE_SOURCES.filter((template) => template.target === target).map((template) => template.id);
+	}
+}
+function getRequiredAgentsMdTopicTemplateIds(profile) {
+	const ids = [];
+	if (hasStack(profile, "frameworks", "react")) ids.push("targets/agents-md/30-stack-typescript-react@1");
+	if (profile.workflow.codeReview === true) ids.push("targets/agents-md/60-code-review@1");
+	if (profile.workflow.refactoring === true) ids.push("targets/agents-md/70-refactoring@1");
+	if (profile.workflow.documentation === true) ids.push("targets/agents-md/80-documentation@1");
+	return ids;
+}
+function getRequiredTabnineGuidelineTemplateIds(profile) {
+	const ids = ["targets/tabnine-guidelines/00-general-agent-behavior@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");
+	if (hasStack(profile, "languages", "java") && hasStack(profile, "frameworks", "spring-boot")) ids.push("targets/tabnine-guidelines/40-stack-java-spring@1");
+	if (hasAnyStack(profile, "testing", ["playwright", "junit"])) ids.push("targets/tabnine-guidelines/50-testing-playwright-junit@1");
+	if (profile.workflow.codeReview === true) ids.push("targets/tabnine-guidelines/60-code-review@1");
+	if (profile.workflow.refactoring === true) ids.push("targets/tabnine-guidelines/70-refactoring@1");
+	if (profile.workflow.documentation === true) ids.push("targets/tabnine-guidelines/80-documentation@1");
+	if (profile.workflow.finalReview) ids.push("targets/tabnine-guidelines/90-final-review@1");
+	return ids;
+}
+function getRequiredWorkflowSkillTemplateIds(profile, target) {
+	return WORKFLOW_SKILLS.filter((skill) => profile.workflow[skill.workflowFlag]).map((skill) => getWorkflowSkillTemplateId(target, skill.id));
 }
 function uniqueTargets(targets) {
 	return Array.from(new Set(targets));
@@ -17498,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);
@@ -17592,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";
 /**
@@ -17672,5 +19984,5 @@ function truncatePreview(text, capBytes = 256 * 1024) {
 	};
 }
 
-export { ProfileWriteError as P, containsSecretLikeLiteral as a, createLockfileFile as b, compileProfile as c, sha256Hex as d, deriveEffectivePermissions as e, computeFileEtag as f, validateProfileValue as g, renderProfileYaml as h, redactIfSecretLike as i, 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-Cxsfz84C.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