@agent-profile/web 0.1.3 → 0.2.0

package/build/server/chunks/{projectContext-C4-xYqFg.js → projectContext-fk5wtjwg.js}

@@ -1,9 +1,9 @@
-import { createRequire } from 'node:module';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
+import fsPromises, { readFile } from 'node:fs/promises';
 import require$$0 from 'process';
 import require$$0$1 from 'buffer';
-import { createHash } from 'node:crypto';
+import { TextDecoder } from 'node:util';
+import path from 'node:path';
+import { randomBytes, createHash } from 'node:crypto';
 
 var ajv = {exports: {}};
 
@@ -13536,8 +13536,10 @@ function requireComposer () {
 	            }
 	        }
 	        if (afterDoc) {
-	            Array.prototype.push.apply(doc.errors, this.errors);
-	            Array.prototype.push.apply(doc.warnings, this.warnings);
+	            for (let i = 0; i < this.errors.length; ++i)
+	                doc.errors.push(this.errors[i]);
+	            for (let i = 0; i < this.warnings.length; ++i)
+	                doc.warnings.push(this.warnings[i]);
 	        }
 	        else {
 	            doc.errors = this.errors;
@@ -14510,7 +14512,7 @@ function requireLexer () {
 	            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
 	            this.indentNext = this.indentValue + 1;
 	            this.indentValue += n;
-	            return yield* this.parseBlockStart();
+	            return 'block-start';
 	        }
 	        return 'doc';
 	    }
@@ -14831,32 +14833,36 @@ function requireLexer () {
 	        return 0;
 	    }
 	    *pushIndicators() {
-	        switch (this.charAt(0)) {
-	            case '!':
-	                return ((yield* this.pushTag()) +
-	                    (yield* this.pushSpaces(true)) +
-	                    (yield* this.pushIndicators()));
-	            case '&':
-	                return ((yield* this.pushUntil(isNotAnchorChar)) +
-	                    (yield* this.pushSpaces(true)) +
-	                    (yield* this.pushIndicators()));
-	            case '-': // this is an error
-	            case '?': // this is an error outside flow collections
-	            case ':': {
-	                const inFlow = this.flowLevel > 0;
-	                const ch1 = this.charAt(1);
-	                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {
-	                    if (!inFlow)
-	                        this.indentNext = this.indentValue + 1;
-	                    else if (this.flowKey)
-	                        this.flowKey = false;
-	                    return ((yield* this.pushCount(1)) +
-	                        (yield* this.pushSpaces(true)) +
-	                        (yield* this.pushIndicators()));
+	        let n = 0;
+	        loop: while (true) {
+	            switch (this.charAt(0)) {
+	                case '!':
+	                    n += yield* this.pushTag();
+	                    n += yield* this.pushSpaces(true);
+	                    continue loop;
+	                case '&':
+	                    n += yield* this.pushUntil(isNotAnchorChar);
+	                    n += yield* this.pushSpaces(true);
+	                    continue loop;
+	                case '-': // this is an error
+	                case '?': // this is an error outside flow collections
+	                case ':': {
+	                    const inFlow = this.flowLevel > 0;
+	                    const ch1 = this.charAt(1);
+	                    if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {
+	                        if (!inFlow)
+	                            this.indentNext = this.indentValue + 1;
+	                        else if (this.flowKey)
+	                            this.flowKey = false;
+	                        n += yield* this.pushCount(1);
+	                        n += yield* this.pushSpaces(true);
+	                        continue loop;
+	                    }
 	                }
 	            }
+	            break loop;
 	        }
-	        return 0;
+	        return n;
 	    }
 	    *pushTag() {
 	        if (this.charAt(1) === '<') {
@@ -15046,6 +15052,14 @@ function requireParser () {
 	    }
 	    return prev.splice(i, prev.length);
 	}
+	function arrayPushArray(target, source) {
+	    // May exhaust call stack with large `source` array
+	    if (source.length < 1e5)
+	        Array.prototype.push.apply(target, source);
+	    else
+	        for (let i = 0; i < source.length; ++i)
+	            target.push(source[i]);
+	}
 	function fixFlowSeqItems(fc) {
 	    if (fc.start.type === 'flow-seq-start') {
 	        for (const it of fc.items) {
@@ -15058,12 +15072,12 @@ function requireParser () {
 	                delete it.key;
 	                if (isFlowToken(it.value)) {
 	                    if (it.value.end)
-	                        Array.prototype.push.apply(it.value.end, it.sep);
+	                        arrayPushArray(it.value.end, it.sep);
 	                    else
 	                        it.value.end = it.sep;
 	                }
 	                else
-	                    Array.prototype.push.apply(it.start, it.sep);
+	                    arrayPushArray(it.start, it.sep);
 	                delete it.sep;
 	            }
 	        }
@@ -15483,7 +15497,7 @@ function requireParser () {
 	                        const prev = map.items[map.items.length - 2];
 	                        const end = prev?.value?.end;
 	                        if (Array.isArray(end)) {
-	                            Array.prototype.push.apply(end, it.start);
+	                            arrayPushArray(end, it.start);
 	                            end.push(this.sourceToken);
 	                            map.items.pop();
 	                            return;
@@ -15698,7 +15712,7 @@ function requireParser () {
 	                        const prev = seq.items[seq.items.length - 2];
 	                        const end = prev?.value?.end;
 	                        if (Array.isArray(end)) {
-	                            Array.prototype.push.apply(end, it.start);
+	                            arrayPushArray(end, it.start);
 	                            end.push(this.sourceToken);
 	                            seq.items.pop();
 	                            return;
@@ -16124,8 +16138,500 @@ function requireDist () {
 
 var distExports = requireDist();
 
-//#region ../../packages/core/dist/profile.js
-var aiProfileSchema = createRequire(import.meta.url)("@agent-profile/schemas/ai-profile.schema.json");
+var ai_profile_schema_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	$id: "https://agent-profile.local/schemas/ai-profile.schema.json",
+	title: "Agent Profile",
+	description: "Version 1 canonical profile for Agent Profile Compiler.",
+	type: "object",
+	additionalProperties: false,
+	required: [
+		"version",
+		"profile",
+		"stack",
+		"clients",
+		"workflow"
+	],
+	properties: {
+		"version": {
+			"type": "integer",
+			"const": 1
+		},
+		"profile": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["name", "description"],
+			"properties": {
+				"name": {
+					"type": "string",
+					"minLength": 1,
+					"pattern": "^[a-z0-9][a-z0-9._-]*$"
+				},
+				"description": {
+					"type": "string",
+					"minLength": 1
+				}
+			}
+		},
+		"stack": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": [
+				"languages",
+				"frameworks",
+				"packageManagers",
+				"testing"
+			],
+			"properties": {
+				"languages": { "$ref": "#/definitions/nonEmptySlugArray" },
+				"frameworks": { "$ref": "#/definitions/slugArray" },
+				"packageManagers": { "$ref": "#/definitions/slugArray" },
+				"testing": { "$ref": "#/definitions/slugArray" }
+			}
+		},
+		"clients": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": [
+				"tabnine",
+				"codex",
+				"claude"
+			],
+			"properties": {
+				"tabnine": { "$ref": "#/definitions/client" },
+				"codex": { "$ref": "#/definitions/client" },
+				"claude": { "$ref": "#/definitions/client" }
+			}
+		},
+		"safety": {
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"mode": { "$ref": "#/definitions/safetyMode" },
+				"requiresSandbox": { "type": "boolean" }
+			}
+		},
+		"workflow": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": [
+				"sdd",
+				"tdd",
+				"finalReview"
+			],
+			"properties": {
+				"sdd": { "type": "boolean" },
+				"tdd": { "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,
+			"properties": {
+				"filesystem": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": {
+						"read": { "$ref": "#/definitions/permissionMode" },
+						"write": { "$ref": "#/definitions/permissionMode" }
+					}
+				},
+				"shell": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "run": { "$ref": "#/definitions/permissionMode" } }
+				},
+				"secrets": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "access": {
+						"type": "string",
+						"const": "deny"
+					} }
+				},
+				"dependencies": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "install": { "$ref": "#/definitions/permissionMode" } }
+				},
+				"network": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "external": { "$ref": "#/definitions/permissionMode" } }
+				},
+				"production": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "access": {
+						"type": "string",
+						"const": "deny"
+					} }
+				}
+			}
+		}
+	},
+	definitions: {
+		"client": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["enabled"],
+			"properties": { "enabled": { "type": "boolean" } }
+		},
+		"permissionMode": {
+			"type": "string",
+			"enum": [
+				"allow",
+				"ask",
+				"deny"
+			]
+		},
+		"safetyMode": {
+			"type": "string",
+			"enum": [
+				"guarded",
+				"balanced",
+				"autonomous",
+				"plan-only"
+			]
+		},
+		"slug": {
+			"type": "string",
+			"minLength": 1,
+			"pattern": "^[a-z0-9][a-z0-9._-]*$"
+		},
+		"slugArray": {
+			"type": "array",
+			"uniqueItems": true,
+			"items": { "$ref": "#/definitions/slug" }
+		},
+		"nonEmptySlugArray": {
+			"type": "array",
+			"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",
@@ -16209,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,
@@ -16221,12 +16732,164 @@ 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,
 		requiresSandbox: profile.safety?.requiresSandbox ?? DEFAULT_SAFETY.requiresSandbox
 	};
 }
+/**
+* Serialize a validated AiProfile to deterministic YAML.
+*
+* - UTF-8, single trailing newline.
+* - Schema field order: version, profile, stack, clients, safety, workflow, permissions.
+* - Optional safety / permissions omitted when absent on the input object.
+* - Empty arrays render as [].
+* - Deterministic: two calls on the same object produce byte-identical output.
+*/
+function renderProfileYaml(profile) {
+	const doc = {};
+	doc["version"] = profile.version;
+	doc["profile"] = {
+		name: profile.profile.name,
+		description: profile.profile.description
+	};
+	doc["stack"] = {
+		languages: profile.stack.languages,
+		frameworks: profile.stack.frameworks,
+		packageManagers: profile.stack.packageManagers,
+		testing: profile.stack.testing
+	};
+	doc["clients"] = {
+		tabnine: { enabled: profile.clients.tabnine.enabled },
+		codex: { enabled: profile.clients.codex.enabled },
+		claude: { enabled: profile.clients.claude.enabled }
+	};
+	if (profile.safety !== void 0) {
+		const safety = {};
+		if (profile.safety.mode !== void 0) safety["mode"] = profile.safety.mode;
+		if (profile.safety.requiresSandbox !== void 0) safety["requiresSandbox"] = profile.safety.requiresSandbox;
+		doc["safety"] = safety;
+	}
+	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,
+		indent: 2,
+		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) {
+		const fs = {};
+		if (p.filesystem.read !== void 0) fs["read"] = p.filesystem.read;
+		if (p.filesystem.write !== void 0) fs["write"] = p.filesystem.write;
+		if (Object.keys(fs).length > 0) doc["filesystem"] = fs;
+	}
+	if (p.shell !== void 0) {
+		const sh = {};
+		if (p.shell.run !== void 0) sh["run"] = p.shell.run;
+		if (Object.keys(sh).length > 0) doc["shell"] = sh;
+	}
+	if (p.secrets !== void 0) {
+		const sec = {};
+		if (p.secrets.access !== void 0) sec["access"] = p.secrets.access;
+		if (Object.keys(sec).length > 0) doc["secrets"] = sec;
+	}
+	if (p.dependencies !== void 0) {
+		const dep = {};
+		if (p.dependencies.install !== void 0) dep["install"] = p.dependencies.install;
+		if (Object.keys(dep).length > 0) doc["dependencies"] = dep;
+	}
+	if (p.network !== void 0) {
+		const net = {};
+		if (p.network.external !== void 0) net["external"] = p.network.external;
+		if (Object.keys(net).length > 0) doc["network"] = net;
+	}
+	if (p.production !== void 0) {
+		const prod = {};
+		if (p.production.access !== void 0) prod["access"] = p.production.access;
+		if (Object.keys(prod).length > 0) doc["production"] = prod;
+	}
+	return doc;
+}
 function deriveEffectivePermissions(profile) {
 	const safety = normalizeSafety(profile);
 	const permissions = profile.permissions ?? {};
@@ -16252,7 +16915,7 @@ function getRemoteRefs(schema) {
 	collectRemoteRefs(schema, refs);
 	return refs.sort();
 }
-function compileProfileSchema(schema = aiProfileSchema) {
+function compileProfileSchema(schema = ai_profile_schema_default) {
 	assertNoRemoteRefs(schema);
 	return new ajvExports.Ajv({
 		allErrors: true,
@@ -16368,12 +17031,13 @@ function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region ../../packages/core/dist/security.js
+//#region ../../packages/core/src/security.ts
 function containsSecretLikeLiteral(text) {
 	return text.includes("SECRET_TOKEN_VALUE") || /-----BEGIN [A-Z ]*PRIVATE KEY-----/u.test(text) || /\b(?:api[_-]?key|token|secret|password)\b\s*[:=]\s*["']?(?!\$)[A-Za-z0-9_./+=-]{10,}/iu.test(text);
 }
-//#endregion
-//#region ../../packages/compiler/dist/shared.js
+new TextDecoder("utf-8", { fatal: true });
+
+//#region ../../packages/compiler/src/shared.ts
 var AGENT_PROFILE_COMPILER = {
 	name: "agent-profile",
 	version: "0.1.0"
@@ -16384,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) {
@@ -16423,7 +17090,7 @@ function compareText(left, right) {
 	return 0;
 }
 //#endregion
-//#region ../../packages/compiler/dist/lockfile.js
+//#region ../../packages/compiler/src/lockfile.ts
 function buildLockfile(input) {
 	return {
 		version: 1,
@@ -16658,7 +17325,222 @@ function compareLockOutputs(left, right) {
 	return compareText(left.path, right.path) || compareText(left.target, right.target);
 }
 //#endregion
-//#region ../../packages/compiler/dist/compiler.js
+//#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: "sdd-change",
@@ -16671,6 +17553,10 @@ var WORKFLOW_SKILLS = [
 	{
 		id: "final-review",
 		workflowFlag: "finalReview"
+	},
+	{
+		id: "subagent-driven-change",
+		workflowFlag: "subagentDrivenDevelopment"
 	}
 ];
 var TEMPLATE_SOURCES = [
@@ -16680,6 +17566,10 @@ var TEMPLATE_SOURCES = [
 		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",
@@ -16690,8 +17580,12 @@ var TEMPLATE_SOURCES = [
 	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",
@@ -16706,8 +17600,9 @@ var TEMPLATE_SOURCES = [
 		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/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",
@@ -16727,8 +17622,9 @@ var TEMPLATE_SOURCES = [
 		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")
+	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 }) => ({
@@ -16740,21 +17636,64 @@ function getDefaultTemplates() {
 }
 function compileProfile(request) {
 	const targets = uniqueTargets(request.targets ?? getEnabledTargetIds(request.profile));
-	const templates = request.templates ?? getDefaultTemplates();
+	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: targets.flatMap((target) => renderTarget(target, request.profile)).sort(compareGeneratedFiles),
-		templates: templates.filter((template) => targets.includes(template.target)).sort(compareTemplates)
+		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
 
 ## Project
@@ -16769,7 +17708,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}
@@ -16779,7 +17718,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  |
@@ -16847,7 +17786,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))];
@@ -16861,13 +17803,20 @@ function renderTabnineGuidelines(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.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) {
@@ -16898,7 +17847,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. -->
@@ -16908,11 +17857,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
 
@@ -16941,6 +17903,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.
 `;
 	}
 }
@@ -17006,6 +18017,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. -->
 
@@ -17064,14 +18087,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 === "allow") tools.push("Edit", "Write");
+		if (effective.shell.run === "allow") tools.push("Bash");
+		if (effective.network.external === "allow") 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
@@ -17110,6 +18234,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,
@@ -17148,9 +18280,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) {
@@ -17158,6 +18300,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({
@@ -17179,7 +18371,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,
@@ -17189,8 +18381,45 @@ 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/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));
@@ -17227,6 +18456,101 @@ function compareIssues(left, right) {
 	return compareText(left.path, right.path) || compareText(left.code, right.code) || compareText(left.message, right.message);
 }
 //#endregion
+//#region ../../packages/compiler/src/write-plan.ts
+function isContainedBy(rootPath, candidatePath) {
+	const relative = path.relative(rootPath, candidatePath);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+var PROFILE_FILENAME$1 = "ai-profile.yaml";
+var ProfileWriteError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ProfileWriteError";
+	}
+};
+/**
+* Atomically write ai-profile.yaml after verifying:
+*  - the target resolves within rootDir (path containment)
+*  - the target is not a symlink
+*  - the current on-disk ETag matches baseEtag (stale-check)
+*
+* Writes via temp-file + rename for atomicity.
+* Returns the new ETag of the written file.
+*
+* Phase 8 does NOT create a missing profile; callers must ensure the file
+* already exists.
+*/
+async function writeProfileAtomic(rootDir, candidateBytes, baseEtag) {
+	const rootRealPath = await fsPromises.realpath(path.resolve(rootDir));
+	const targetAbsolute = path.join(rootRealPath, PROFILE_FILENAME$1);
+	if (!isContainedBy(rootRealPath, targetAbsolute)) throw new ProfileWriteError("traversal", "Profile path escapes root.");
+	let targetStat;
+	try {
+		targetStat = await fsPromises.lstat(targetAbsolute);
+	} catch (err) {
+		if (isNodeError(err) && err.code === "ENOENT") throw new ProfileWriteError("not_found", "ai-profile.yaml not found; run agent-profile init --write.");
+		throw err;
+	}
+	if (targetStat.isSymbolicLink()) throw new ProfileWriteError("symlink", "ai-profile.yaml is a symlink; refusing to write.");
+	const currentEtag = computeFileEtag(await fsPromises.readFile(targetAbsolute));
+	if (currentEtag !== baseEtag) throw new ProfileWriteError("stale", "Profile has changed since last read; reload and retry.");
+	const candidateEtag = computeFileEtag(candidateBytes);
+	if (candidateEtag === currentEtag) return {
+		action: "unchanged",
+		bytes: candidateBytes.length,
+		etag: candidateEtag
+	};
+	const tempName = `ai-profile.yaml.tmp-${randomBytes(8).toString("hex")}`;
+	const tempAbsolute = path.join(rootRealPath, tempName);
+	try {
+		const fd = await fsPromises.open(tempAbsolute, "wx", 420);
+		try {
+			await fd.write(candidateBytes);
+			await fd.sync();
+		} finally {
+			await fd.close();
+		}
+		await fsPromises.rename(tempAbsolute, targetAbsolute);
+		await fsyncParentDirectory(rootRealPath);
+	} catch (err) {
+		try {
+			await fsPromises.rm(tempAbsolute, { force: true });
+		} catch {}
+		throw err;
+	}
+	const writtenEtag = computeFileEtag(await fsPromises.readFile(targetAbsolute));
+	if (writtenEtag !== candidateEtag) throw new ProfileWriteError("verify_failed", "Written bytes do not match expected hash.");
+	return {
+		action: "change",
+		bytes: candidateBytes.length,
+		etag: writtenEtag
+	};
+}
+async function fsyncParentDirectory(directoryPath) {
+	if (process.platform === "win32") return;
+	let fd;
+	try {
+		fd = await fsPromises.open(directoryPath, "r");
+		await fd.sync();
+	} catch (err) {
+		if (!isNodeError(err) || err.code !== "EINVAL" && err.code !== "EPERM") throw err;
+	} finally {
+		await fd?.close();
+	}
+}
+/**
+* Compute an ETag for a file's bytes.  Format: "sha256:<hex>".
+* Exposed so callers can compute the ETag for GET /api/profile responses.
+*/
+function computeFileEtag(bytes) {
+	return "sha256:" + createHash("sha256").update(bytes).digest("hex");
+}
+//#endregion
 //#region src/lib/server/projectContext.ts
 var PROFILE_FILENAME = "ai-profile.yaml";
 /**
@@ -17307,5 +18631,5 @@ function truncatePreview(text, capBytes = 256 * 1024) {
 	};
 }
 
-export { resolveProjectRoot as a, safeOutputPath as b, compileProfile as c, containsSecretLikeLiteral as d, createLockfileFile as e, deriveEffectivePermissions as f, loadProjectContext as l, normalizeSafety as n, parseProfileYaml as p, redactIfSecretLike as r, sha256Hex as s, truncatePreview as t, validateLockfileText as v };
-//# sourceMappingURL=projectContext-C4-xYqFg.js.map
+export { ProfileWriteError as P, containsSecretLikeLiteral as a, createLockfileFile as b, compileProfile as c, deriveEffectivePermissions as d, sha256Hex as e, computeFileEtag as f, getEnabledSubagents as g, validateProfileValue as h, isSubagentBuiltinNameCollision as i, renderProfileYaml as j, redactIfSecretLike as k, loadProjectContext as l, normalizeSafety as n, parseProfileYaml as p, resolveProjectRoot as r, safeOutputPath as s, truncatePreview as t, validateLockfileText as v, writeProfileAtomic as w };
+//# sourceMappingURL=projectContext-fk5wtjwg.js.map