@agent-profile/web 0.3.5 → 0.4.0

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

@@ -16226,17 +16226,40 @@ var ai_profile_schema_default = {
 				"codeReview": { "type": "boolean" },
 				"refactoring": { "type": "boolean" },
 				"documentation": { "type": "boolean" },
+				"memoryGuidance": { "type": "boolean" },
+				"loggingGuidance": { "type": "boolean" },
 				"subagentDrivenDevelopment": { "type": "boolean" }
 			}
 		},
 		"capabilities": {
 			"type": "object",
 			"additionalProperties": false,
-			"properties": { "delegation": {
-				"type": "object",
-				"additionalProperties": false,
-				"properties": { "subagents": { "$ref": "#/definitions/subagents" } }
-			} }
+			"properties": {
+				"skills": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "packs": {
+						"type": "array",
+						"uniqueItems": true,
+						"items": {
+							"type": "string",
+							"enum": [
+								"base",
+								"review",
+								"advanced-review",
+								"automation",
+								"mcp-recommendations"
+							]
+						}
+					} }
+				},
+				"delegation": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": { "subagents": { "$ref": "#/definitions/subagents" } }
+				},
+				"hooks": { "$ref": "#/definitions/hooks" }
+			}
 		},
 		"permissions": {
 			"type": "object",
@@ -16324,6 +16347,34 @@ var ai_profile_schema_default = {
 			"uniqueItems": true,
 			"items": { "$ref": "#/definitions/slug" }
 		},
+		"hooks": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["enabled"],
+			"properties": {
+				"enabled": { "type": "boolean" },
+				"advisory": {
+					"type": "array",
+					"uniqueItems": true,
+					"items": {
+						"type": "string",
+						"enum": [
+							"final-review-reminder",
+							"context-injection",
+							"pre-compact-checkpoint"
+						]
+					}
+				}
+			},
+			"if": {
+				"properties": { "enabled": { "const": false } },
+				"required": ["enabled"]
+			},
+			"then": { "properties": { "advisory": {
+				"type": "array",
+				"maxItems": 0
+			} } }
+		},
 		"subagents": {
 			"type": "object",
 			"additionalProperties": false,
@@ -16347,20 +16398,37 @@ var ai_profile_schema_default = {
 				"agents": {
 					"type": "array",
 					"items": { "$ref": "#/definitions/subagent" }
+				},
+				"packs": {
+					"type": "array",
+					"uniqueItems": true,
+					"items": {
+						"type": "string",
+						"enum": ["reviewer-subagents"]
+					}
 				}
 			},
 			"if": {
 				"properties": { "enabled": { "const": true } },
 				"required": ["enabled"]
 			},
-			"then": {
+			"then": { "anyOf": [{
 				"required": ["agents"],
 				"properties": { "agents": {
 					"type": "array",
-					"minItems": 1,
-					"items": { "$ref": "#/definitions/subagent" }
+					"minItems": 1
 				} }
-			}
+			}, {
+				"required": ["packs"],
+				"properties": { "packs": {
+					"type": "array",
+					"minItems": 1
+				} }
+			}] },
+			"else": { "properties": { "packs": {
+				"type": "array",
+				"maxItems": 0
+			} } }
 		},
 		"subagent": { "oneOf": [{ "$ref": "#/definitions/subagentTemplateRef" }, { "$ref": "#/definitions/subagentInline" }] },
 		"subagentTemplateRef": {
@@ -16449,12 +16517,75 @@ var ai_profile_schema_default = {
 	}
 };
 //#endregion
+//#region ../../packages/core/src/reviewer-definitions.ts
+var REVIEWER_DEFINITIONS = [
+	{
+		skillId: "security-review",
+		reviewerId: "security-reviewer",
+		title: "Security Review",
+		description: "Review exploit paths, secret exposure, unsafe permissions, injection, authentication and authorization, supply-chain risk, and data leakage.",
+		focus: [
+			"Exploit paths and trust-boundary violations.",
+			"Secret exposure, unsafe permissions, and data leakage.",
+			"Injection and authentication or authorization failures.",
+			"Supply-chain and dependency risk introduced by the change."
+		]
+	},
+	{
+		skillId: "readability-review",
+		reviewerId: "readability-reviewer",
+		title: "Readability Review",
+		description: "Review naming, decomposition, control flow, duplication, comments, error-handling clarity, and unnecessary abstraction.",
+		focus: [
+			"Names that communicate intent and domain meaning.",
+			"Decomposition, control flow, and error-handling clarity.",
+			"Duplication and comments that obscure rather than explain.",
+			"Unnecessary abstraction or indirection."
+		]
+	},
+	{
+		skillId: "test-review",
+		reviewerId: "test-reviewer",
+		title: "Test Review",
+		description: "Review missing cases, regression coverage, flaky patterns, fixture quality, edge cases, and behavior-versus-implementation testing.",
+		focus: [
+			"Missing regression and edge-case coverage.",
+			"Flaky patterns and weak fixture quality.",
+			"Assertions on observable behavior rather than implementation details.",
+			"Negative paths, validation order, and failure contracts."
+		]
+	},
+	{
+		skillId: "architecture-review",
+		reviewerId: "architecture-reviewer",
+		title: "Architecture Review",
+		description: "Review module boundaries, dependency direction, contracts, migration risk, and fit to the product architecture.",
+		focus: [
+			"Module boundaries and dependency direction.",
+			"Public contracts and compatibility impact.",
+			"Migration, rollout, and generated-artifact risk.",
+			"Fit with the documented product architecture."
+		]
+	}
+];
+//#endregion
 //#region ../../packages/core/src/profile.ts
 var SUBAGENT_TEMPLATE_NAMES = [
 	"implementer",
 	"spec-reviewer",
 	"code-quality-reviewer"
 ];
+var ADVISORY_HOOK_ROLE_IDS = [
+	"final-review-reminder",
+	"context-injection",
+	"pre-compact-checkpoint"
+];
+function getSelectedAdvisoryHookRoles(profile) {
+	const block = profile.capabilities?.hooks;
+	if (!block || block.enabled !== true) return [];
+	const selected = new Set(block.advisory ?? []);
+	return ADVISORY_HOOK_ROLE_IDS.filter((role) => selected.has(role));
+}
 function isSubagentTemplateRef(entry) {
 	return typeof entry.useTemplate === "string";
 }
@@ -16615,9 +16746,21 @@ function getSubagentDefaults(profile) {
 function getEnabledSubagents(profile) {
 	const block = profile.capabilities?.delegation?.subagents;
 	if (!block || block.enabled !== true) return [];
-	return (block.agents ?? []).map((entry) => expandSubagentEntry(entry));
+	const agents = (block.agents ?? []).map((entry) => expandSubagentEntry(entry));
+	if (block.packs?.includes("reviewer-subagents")) agents.push(...REVIEWER_DEFINITIONS.map((definition) => ({
+		name: definition.reviewerId,
+		description: definition.description,
+		purpose: `Perform a focused ${definition.title.toLowerCase()} of the requested change.`,
+		prompt: `Review the requested change as a ${definition.title.toLowerCase()} specialist.\n\nFocus on:\n${definition.focus.map((item) => `- ${item}`).join("\n")}\n\nDo not edit files, run commands, install dependencies, read secrets, contact production systems, or upload source.\n\nReport exactly:\n- Status: CLEAR | FINDINGS | NEEDS_CONTEXT\n- Findings grouped by severity with evidence and affected path or contract\n- Missing evidence or context\n- Recommendation`,
+		toolScope: "read-only",
+		modelPreference: "capable",
+		maxTurns: 10,
+		timeoutMinutes: 8,
+		mcpServers: []
+	})));
+	return agents;
 }
-var SUBAGENT_BUILTIN_NAMES_NORMALIZED = new Set([
+var SUBAGENT_BUILTIN_NAMES_NORMALIZED = /* @__PURE__ */ new Set([
 	"default",
 	"worker",
 	"explorer",
@@ -16739,8 +16882,16 @@ function validateSubagentSemantics(profile) {
 	const issues = [];
 	const seenRaw = /* @__PURE__ */ new Map();
 	const seenNormalized = /* @__PURE__ */ new Map();
+	const packNames = subagents.packs?.includes("reviewer-subagents") ? new Set(REVIEWER_DEFINITIONS.map((definition) => normalizeSubagentName(definition.reviewerId))) : /* @__PURE__ */ new Set();
 	entries.forEach((entry, index) => {
 		const name = expandSubagentEntry(entry).name;
+		if (packNames.has(normalizeSubagentName(name))) issues.push({
+			code: "schema_validation_error",
+			path: `/capabilities/delegation/subagents/agents/${index}/name`,
+			expected: "name distinct from expanded subagent packs",
+			actual: "collision with reviewer-subagents",
+			message: `/capabilities/delegation/subagents/agents/${index}/name collides with a subagent generated by the reviewer-subagents pack.`
+		});
 		const rawIndex = seenRaw.get(name);
 		if (rawIndex !== void 0) issues.push({
 			code: "schema_validation_error",
@@ -16811,6 +16962,8 @@ function renderProfileYaml(profile) {
 	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.memoryGuidance !== void 0) workflow["memoryGuidance"] = profile.workflow.memoryGuidance;
+	if (profile.workflow.loggingGuidance !== void 0) workflow["loggingGuidance"] = profile.workflow.loggingGuidance;
 	if (profile.workflow.subagentDrivenDevelopment !== void 0) workflow["subagentDrivenDevelopment"] = profile.workflow.subagentDrivenDevelopment;
 	doc["workflow"] = workflow;
 	if (profile.capabilities !== void 0) doc["capabilities"] = buildCapabilitiesDoc(profile.capabilities);
@@ -16823,6 +16976,11 @@ function renderProfileYaml(profile) {
 }
 function buildCapabilitiesDoc(capabilities) {
 	const doc = {};
+	if (capabilities.skills !== void 0) {
+		const skills = {};
+		if (capabilities.skills.packs !== void 0) skills["packs"] = capabilities.skills.packs;
+		doc["skills"] = skills;
+	}
 	if (capabilities.delegation !== void 0) {
 		const delegation = {};
 		const subagents = capabilities.delegation.subagents;
@@ -16835,10 +16993,16 @@ function buildCapabilitiesDoc(capabilities) {
 				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));
+			if (subagents.packs !== void 0) block["packs"] = subagents.packs;
 			delegation["subagents"] = block;
 		}
 		if (Object.keys(delegation).length > 0) doc["delegation"] = delegation;
 	}
+	if (capabilities.hooks !== void 0) {
+		const hooks = { enabled: capabilities.hooks.enabled };
+		if (capabilities.hooks.advisory !== void 0) hooks["advisory"] = capabilities.hooks.advisory;
+		doc["hooks"] = hooks;
+	}
 	return doc;
 }
 function buildSubagentDoc(agent) {
@@ -17050,6 +17214,7 @@ function getDefaultTargetIds() {
 		"tabnine-mcp-config",
 		"tabnine-subagents",
 		"codex-config",
+		"codex-hooks",
 		"codex-workflow-skills",
 		"codex-subagents",
 		"claude-settings",
@@ -17091,7 +17256,7 @@ function compareText(left, right) {
 }
 //#endregion
 //#region ../../packages/compiler/src/lockfile.ts
-var SUPPORTED_VERSIONS = new Set([1, 2]);
+var SUPPORTED_VERSIONS = /* @__PURE__ */ 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]));
@@ -17959,6 +18124,73 @@ var DOCUMENTATION_TOPIC = {
 	tabnineChecklistReference: "See `90-final-review.md` for the shared final-review checklist.",
 	agentsMdChecklistReference: "See the `## Completion Checklist` section for shared review steps."
 };
+var MEMORY_GUIDANCE_TOPIC = {
+	tabnineTitle: "Memory Guidance",
+	agentsMdTitle: "Memory Guidance",
+	intro: "Use these rules to decide what belongs in agent memory and where each enabled client persists it.",
+	subsections: [
+		{
+			heading: "Where Memory Lives",
+			bullets: [
+				"Claude Code keeps durable project instructions in `CLAUDE.md` and its auto-memory surface.",
+				"Codex keeps durable project instructions in `AGENTS.md` and its Memories surface.",
+				"Tabnine uses project guidelines for durable instructions; no project-local memory contract is verified, so treat Tabnine memory as unverified rather than assumed.",
+				"Precedence between these surfaces is target-specific; do not assume one client's ordering applies to another."
+			]
+		},
+		{
+			heading: "Never Store In Memory",
+			bullets: ["Never store secrets, tokens, credentials, private keys, production access, personal/customer data, or one-time debugging context in memory."]
+		},
+		{
+			heading: "Keep Memory Durable",
+			bullets: ["Store durable decisions and conventions, not session-specific or volatile state.", "Delete a wrong memory instead of adding a second memory to correct around it."]
+		}
+	],
+	tabnineChecklistReference: "See `90-final-review.md` for the shared final-review checklist.",
+	agentsMdChecklistReference: "See the `## Completion Checklist` section for shared review steps."
+};
+var LOGGING_GUIDANCE_TOPIC = {
+	tabnineTitle: "Logging Guidance",
+	agentsMdTitle: "Logging Guidance",
+	intro: "Use these rules to decide what to log, how to name it, and how to keep diagnostics safe and separate from product output.",
+	subsections: [
+		{
+			heading: "Debug vs Observability",
+			bullets: [
+				"Separate throwaway debug output from durable observability: debug prints exist only to diagnose a failure in progress.",
+				"Remove debug output before marking work done; leftover debug prints are a defect, not a feature.",
+				"Prefer a narrower failing test over debug prints to isolate a problem."
+			]
+		},
+		{
+			heading: "Project Convention Precedence",
+			bullets: ["Follow the project's existing logging convention when one exists; do not invent an ad hoc format alongside it.", "When no convention exists, propose one as an ADR candidate before adopting it; never invent a convention ad hoc."]
+		},
+		{
+			heading: "Stable Event Codes",
+			bullets: ["Attach a stable event code to each new error path instead of free text.", "Keep codes stable so support and tooling can rely on them; free-text messages are not a substitute."]
+		},
+		{
+			heading: "Redaction Rule",
+			bullets: ["Never log secrets, tokens, credentials, environment variable values, user file contents, or personal or production data. Log by allowlist: only values explicitly known to be safe."]
+		},
+		{
+			heading: "Channel Separation",
+			bullets: ["Keep diagnostics on the diagnostic channel so they never contaminate machine or product output (stderr vs stdout, or the platform equivalent)."]
+		},
+		{
+			heading: "Logs and Tests",
+			bullets: ["Treat support-relied logs as observable behavior that deserves tests.", "Never assert on incidental debug logs."]
+		},
+		{
+			heading: "Priority Order",
+			bullets: ["When these rules conflict, apply them in this order: redaction > convention > codes (redaction beats project convention beats event codes)."]
+		}
+	],
+	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. -->
@@ -17983,33 +18215,507 @@ ${topic.agentsMdChecklistReference}
 `;
 }
 //#endregion
-//#region ../../packages/compiler/src/compiler.ts
-var WORKFLOW_SKILLS = [
-	{
-		id: "grill-change",
-		workflowFlag: "sdd"
+//#region ../../packages/compiler/src/phase12-skill-content.ts
+function renderBullets(items) {
+	return items.map((item) => `- ${item}`).join("\n");
+}
+function renderReviewChangeSkill(selectedSkills) {
+	const sections = CODE_REVIEW_TOPIC.subsections.map((section) => `## ${section.heading}\n\n${renderBullets(section.bullets)}`).join("\n\n");
+	const specialists = REVIEWER_DEFINITIONS.filter((definition) => selectedSkills.has(definition.skillId));
+	const specialistSection = specialists.length === 0 ? "" : `\n\n## Specialist Reviews\n\n${specialists.map((definition) => `- For a deeper pass, run \`${definition.skillId}\`.`).join("\n")}`;
+	return `---
+name: review-change
+description: Use to review a proposed change for correctness, security-sensitive behavior, readability, tests, performance when relevant, architecture and contract impact, and generated-file drift.
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# Review Change
+
+${CODE_REVIEW_TOPIC.intro}
+
+${sections}${specialistSection}
+
+## Safety
+
+- Review only; do not rewrite or apply patches unless the user asks.
+- Do not upload source code or read or print secrets.
+- Do not install dependencies, contact production systems, or broaden permissions.
+`;
+}
+function renderSpecialistSkill(definition) {
+	return `---
+name: ${definition.skillId}
+description: ${definition.description}
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# ${definition.title}
+
+## Focus
+
+${renderBullets(definition.focus)}
+
+## Output Discipline
+
+- Lead with prioritized findings and concrete evidence.
+- Cite the affected file, symbol, or contract when available.
+- Distinguish confirmed defects from risks or missing evidence.
+- Do not edit or rewrite the change unless the user asks.
+
+## Safety
+
+- Review only; do not run scanners, install tools, or broaden permissions.
+- Do not upload source code or read or print secrets.
+- Do not contact production systems or external services.
+`;
+}
+function renderSpecialistReviewSkill(skill) {
+	const definition = REVIEWER_DEFINITIONS.find((candidate) => candidate.skillId === skill);
+	return definition === void 0 ? void 0 : renderSpecialistSkill(definition);
+}
+function renderMcpFitCheckSkill() {
+	return `---
+name: mcp-fit-check
+description: Use to assess whether current documentation through an MCP, docs, or search integration may help with a dependency that may be newer than the client's knowledge.
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# MCP Fit Check
+
+## Assessment
+
+1. Identify the dependency, framework, runtime, or SDK whose current behavior matters.
+2. Explain why it may be newer than the client's knowledge; never claim the model definitely lacks that knowledge.
+3. Recommend only the type of current documentation integration that may help and explain its risk.
+4. Keep the result informational and defer every install or configuration decision to the user.
+
+## Boundaries
+
+- Never install or configure an MCP server, documentation connector, or search integration.
+- Do not generate MCP configuration, server commands, install commands, environment variable names, tokens, or arbitrary MCP ids.
+- Do not make network calls, execute commands, or change files.
+- Do not read or print secrets.
+
+## Output
+
+Report the dependency, why current docs may help, the recommended integration category, its risk, and the explicit next decision for the user.
+`;
+}
+//#endregion
+//#region ../../packages/compiler/src/skill-selection.ts
+var SKILL_ORDER = [
+	"grill-change",
+	"request-to-spec-issues",
+	"sdd-change",
+	"tdd-change",
+	"final-review",
+	"subagent-driven-change",
+	"implement-next",
+	"review-change",
+	"security-review",
+	"readability-review",
+	"test-review",
+	"architecture-review",
+	"loop-implement-test-fix",
+	"loop-review-patch-retest",
+	"loop-security-patch-retest",
+	"loop-docs-update",
+	"loop-sdd-cycle",
+	"mcp-fit-check"
+];
+var LOOP_SKILL_IDS = [
+	"loop-implement-test-fix",
+	"loop-review-patch-retest",
+	"loop-security-patch-retest",
+	"loop-docs-update",
+	"loop-sdd-cycle"
+];
+function isLoopSkillId(skill) {
+	return LOOP_SKILL_IDS.includes(skill);
+}
+var MODEL_INVOCATION_ENTRY_POINTS = [
+	"grill-change",
+	"request-to-spec-issues",
+	"implement-next",
+	...LOOP_SKILL_IDS
+];
+var DISABLE_MODEL_INVOCATION_TARGETS = ["claude-workflow-skills"];
+function isModelInvocationEntryPoint(skill) {
+	return MODEL_INVOCATION_ENTRY_POINTS.includes(skill);
+}
+/**
+* The closed policy function: emit `disable-model-invocation: true` iff the
+* skill is an entry point AND the target verifiably supports the flag.
+* Unverified target support means the flag is omitted (skill still emitted).
+*/
+function disablesModelInvocation(skill, target) {
+	return isModelInvocationEntryPoint(skill) && DISABLE_MODEL_INVOCATION_TARGETS.includes(target);
+}
+var PACK_SKILLS = {
+	base: [
+		"sdd-change",
+		"tdd-change",
+		"final-review"
+	],
+	review: ["review-change"],
+	"advanced-review": [
+		"security-review",
+		"readability-review",
+		"test-review",
+		"architecture-review"
+	],
+	automation: [
+		"loop-implement-test-fix",
+		"loop-review-patch-retest",
+		"loop-security-patch-retest",
+		"loop-docs-update",
+		"loop-sdd-cycle"
+	],
+	"mcp-recommendations": ["mcp-fit-check"]
+};
+function resolveSkillPacks(packs) {
+	const selected = /* @__PURE__ */ new Set();
+	for (const pack of packs) for (const skill of PACK_SKILLS[pack]) selected.add(skill);
+	return SKILL_ORDER.filter((skill) => selected.has(skill));
+}
+/**
+* Phase 24 (I4): `implement-next` dispatches one ready ledger task through the
+* subagent-driven cycle. It is emitted only when both prerequisites it consumes
+* are also emitted - `request-to-spec-issues` (from `sdd`) for the persisted
+* brief/ledger format, and `subagent-driven-change` (from
+* `subagentDrivenDevelopment`) for the implementer -> spec-reviewer ->
+* code-quality-reviewer chain. The workflow-skill targets (Codex and Claude)
+* are both `confirmed-official` for that chain; Tabnine is a missing-capability
+* target and gets an informational note instead (see the compiler).
+*/
+function emitsImplementNext(workflow) {
+	return workflow.sdd === true && workflow.subagentDrivenDevelopment === true;
+}
+function resolveSkills(input) {
+	const selected = /* @__PURE__ */ new Set();
+	if (input.workflow.sdd) {
+		selected.add("grill-change");
+		selected.add("request-to-spec-issues");
+		selected.add("sdd-change");
+	}
+	if (input.workflow.tdd) selected.add("tdd-change");
+	if (input.workflow.finalReview) selected.add("final-review");
+	if (input.workflow.subagentDrivenDevelopment === true) selected.add("subagent-driven-change");
+	if (emitsImplementNext(input.workflow)) selected.add("implement-next");
+	if (input.workflow.codeReview === true) selected.add("review-change");
+	for (const skill of resolveSkillPacks(input.packs)) selected.add(skill);
+	return SKILL_ORDER.filter((skill) => selected.has(skill));
+}
+function resolveSelectedSkills(profile) {
+	return resolveSkills({
+		workflow: profile.workflow,
+		packs: profile.capabilities?.skills?.packs ?? []
+	});
+}
+//#endregion
+//#region ../../packages/compiler/src/loop-skill-content.ts
+var MAX_ITERATIONS = 3;
+var LOOP_SKILL_DEFINITIONS = {
+	"loop-implement-test-fix": {
+		description: "Use to run a bounded implement, test, and fix loop that stops on green, on no diff, or on a repeated identical failure.",
+		title: "Loop: Implement, Test, Fix",
+		intro: "Drive a small implementation to green through a bounded number of iterations. Each iteration makes one focused change, runs the relevant checks, and reacts to the result.",
+		steps: [
+			"Implement the smallest change that moves the task toward its acceptance criteria.",
+			{
+				skill: "tdd-change",
+				pointer: "Prove the change with a focused test first; run `tdd-change` for the red/green discipline.",
+				inline: "Prove the change with a focused failing test first, then make it pass."
+			},
+			"Run the narrowest relevant test or check command and read the result.",
+			"If it fails, apply one focused fix and continue to the next iteration."
+		]
 	},
-	{
-		id: "request-to-spec-issues",
-		workflowFlag: "sdd"
+	"loop-review-patch-retest": {
+		description: "Use to run a bounded review, patch, and retest loop that stops on green, on no diff, or on a repeated identical finding.",
+		title: "Loop: Review, Patch, Retest",
+		intro: "Iterate on review findings for a change until the review is clean, bounded by a hard iteration cap. Each iteration reviews, patches one finding cluster, and retests.",
+		steps: [
+			{
+				skill: "review-change",
+				pointer: "Review the change for correctness and contract impact; run `review-change` for the full pass.",
+				inline: "Review the change for correctness, tests, and contract impact."
+			},
+			"Patch the highest-priority findings with a focused change.",
+			"Rerun the relevant tests and checks and confirm the finding is resolved."
+		]
 	},
-	{
-		id: "sdd-change",
-		workflowFlag: "sdd"
+	"loop-security-patch-retest": {
+		description: "Use to run a bounded security-review, patch, and retest loop that stops on green, on no diff, or on a repeated identical finding.",
+		title: "Loop: Security Review, Patch, Retest",
+		intro: "Iterate on security-sensitive findings for a change until they are resolved, bounded by a hard iteration cap. Each iteration reviews for security risk, patches, and retests.",
+		steps: [
+			{
+				skill: "security-review",
+				pointer: "Review the change for security-sensitive behavior; run `security-review` for the focused pass.",
+				inline: "Review the change for security-sensitive behavior and injection, secret-handling, and permission risks."
+			},
+			"Patch the highest-severity finding with a focused, minimal change.",
+			"Rerun the relevant tests and checks and confirm the risk is resolved without regressions."
+		]
+	},
+	"loop-docs-update": {
+		description: "Use to run a bounded documentation drift scan, update, and re-verify loop that stops when docs match the code, on no diff, or on a repeated identical mismatch.",
+		title: "Loop: Documentation Update",
+		intro: "Bring documentation back in sync with the code through a bounded number of iterations. Each iteration scans for drift, updates one area, and re-verifies against the source.",
+		steps: [
+			"Scan the docs for statements that no longer match the current code or contracts.",
+			"Update one drifted area to match the code, keeping the change focused.",
+			"Re-verify the updated docs against the source and note any remaining drift."
+		]
 	},
+	"loop-sdd-cycle": {
+		description: "Use to run a bounded spec, tests, implementation, and verify cycle that stops on green, on no diff, or on a repeated identical failure.",
+		title: "Loop: SDD Cycle",
+		intro: "Advance one approved spec slice through spec, tests, implementation, and verification in bounded iterations. Each iteration takes the smallest slice that keeps the spec and its tests in step.",
+		steps: [
+			{
+				skill: "sdd-change",
+				pointer: "Confirm the slice against the approved spec; run `sdd-change` for the spec-first discipline.",
+				inline: "Confirm the slice against the approved spec before changing behavior."
+			},
+			{
+				skill: "tdd-change",
+				pointer: "Add or update a focused failing test for the slice; run `tdd-change` for the red/green discipline.",
+				inline: "Add or update a focused failing test for the slice before implementing."
+			},
+			"Implement the smallest change that satisfies the failing test and the spec.",
+			{
+				skill: "final-review",
+				pointer: "Verify the slice against the spec and acceptance criteria; run `final-review` before handoff.",
+				inline: "Verify the slice against the spec and its acceptance criteria before handoff."
+			}
+		]
+	}
+};
+function renderStep(step, index, selectedSkills) {
+	const text = typeof step === "string" ? step : selectedSkills.has(step.skill) ? step.pointer : step.inline;
+	return `${index + 1}. ${text}`;
+}
+function renderLoopSkill(skill, selectedSkills) {
+	const definition = LOOP_SKILL_DEFINITIONS[skill];
+	const steps = definition.steps.map((step, index) => renderStep(step, index, selectedSkills)).join("\n");
+	return `---
+name: ${skill}
+description: ${definition.description}
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# ${definition.title}
+
+${definition.intro}
+
+## Loop Steps
+
+${steps}
+
+## Max Iterations
+
+The loop runs at most ${MAX_ITERATIONS} iterations. When it reaches ${MAX_ITERATIONS} iterations without meeting a stop condition, it stops unconditionally and reports the unfinished state and the outstanding work; it never raises the bound to keep going.
+
+## Stop Conditions
+
+Stop the loop as soon as any of these holds:
+
+- The relevant tests and checks are green.
+- An iteration produces no diff.
+- The same failure repeats identically across two consecutive iterations.
+
+## Approval Gate
+
+- Get explicit human approval before any write, commit, or destructive step in each iteration.
+- The loop never self-approves, never continues past the iteration bound, and never runs destructive commands on its own authority.
+- Pause and surface the state whenever approval is missing.
+
+## Safety
+
+- Do not upload source code.
+- Do not read or print secrets.
+- APC does not run this loop; a human or agent follows these instructions and remains in control.
+`;
+}
+function renderLoopSkillContent(skill, selectedSkills = /* @__PURE__ */ new Set()) {
+	return LOOP_SKILL_IDS.includes(skill) ? renderLoopSkill(skill, selectedSkills) : void 0;
+}
+/**
+* Not-supported note for the automation pack on a Tabnine-including target set
+* (never silence). Loop skills are skills-capable-client artifacts only;
+* Tabnine gets an explicit informational note, consistent with the
+* unsupported-target rule.
+*/
+function automationTabnineNote(path) {
+	return {
+		code: "automation_target_not_generated",
+		path,
+		expected: "skills-capable client (Claude or Codex)",
+		actual: "Tabnine has no loop skill surface",
+		message: "capabilities.skills.packs automation loop skills are not generated for Tabnine: loop skills target skills-capable clients (Claude and Codex) only."
+	};
+}
+//#endregion
+//#region ../../packages/compiler/src/hooks.ts
+var VERIFIED_CLAUDE_HOOK_EVENTS = [
+	"SessionStart",
+	"Setup",
+	"InstructionsLoaded",
+	"UserPromptSubmit",
+	"UserPromptExpansion",
+	"MessageDisplay",
+	"PreToolUse",
+	"PermissionRequest",
+	"PostToolUse",
+	"PostToolUseFailure",
+	"PostToolBatch",
+	"PermissionDenied",
+	"Notification",
+	"SubagentStart",
+	"SubagentStop",
+	"TaskCreated",
+	"TaskCompleted",
+	"Stop",
+	"StopFailure",
+	"TeammateIdle",
+	"ConfigChange",
+	"CwdChanged",
+	"FileChanged",
+	"WorktreeCreate",
+	"WorktreeRemove",
+	"PreCompact",
+	"PostCompact",
+	"SessionEnd",
+	"Elicitation",
+	"ElicitationResult"
+];
+var VERIFIED_CODEX_HOOK_EVENTS = [
+	"SessionStart",
+	"UserPromptSubmit",
+	"PreToolUse",
+	"PermissionRequest",
+	"PostToolUse",
+	"SubagentStart",
+	"SubagentStop",
+	"Stop",
+	"PreCompact",
+	"PostCompact"
+];
+var TEMPLATES_BY_ROLE = new Map([
 	{
-		id: "tdd-change",
-		workflowFlag: "tdd"
+		role: "final-review-reminder",
+		events: ["Stop", "SubagentStop"],
+		claudeCommand: "echo \"Reminder: run the final-review skill before handing off.\"",
+		codexCommand: "echo '{\"systemMessage\":\"Reminder: run the final-review skill before handing off.\"}'",
+		codexCommandWindows: "cmd /c echo {\"systemMessage\":\"Reminder: run the final-review skill before handing off.\"}"
 	},
 	{
-		id: "final-review",
-		workflowFlag: "finalReview"
+		role: "context-injection",
+		events: ["UserPromptSubmit"],
+		claudeCommand: "git status --short --branch; exit 0",
+		codexCommand: "git status --short --branch; exit 0",
+		codexCommandWindows: "cmd /c \"git status --short --branch || exit 0\""
 	},
 	{
-		id: "subagent-driven-change",
-		workflowFlag: "subagentDrivenDevelopment"
+		role: "pre-compact-checkpoint",
+		events: ["PreCompact"],
+		claudeCommand: "echo \"Reminder: checkpoint in-progress work before compaction.\"",
+		codexCommand: "echo '{\"systemMessage\":\"Reminder: checkpoint in-progress work before compaction.\"}'",
+		codexCommandWindows: "cmd /c echo {\"systemMessage\":\"Reminder: checkpoint in-progress work before compaction.\"}"
+	}
+].map((template) => [template.role, template]));
+function getAdvisoryHookTemplate(role) {
+	const template = TEMPLATES_BY_ROLE.get(role);
+	if (!template) throw new Error(`Unknown advisory hook role ${role}.`);
+	return template;
+}
+function getAdvisoryHookTemplateId(role) {
+	return `targets/claude-hooks/${role}@1`;
+}
+function getCodexHookTemplateId(role) {
+	return `targets/codex-hooks/${role}@1`;
+}
+function renderAdvisoryHookTemplateSource(role) {
+	const template = getAdvisoryHookTemplate(role);
+	return `${JSON.stringify({
+		role: template.role,
+		events: template.events,
+		command: template.claudeCommand
+	}, null, 2)}\n`;
+}
+function renderCodexHookTemplateSource(role) {
+	const template = getAdvisoryHookTemplate(role);
+	return `${JSON.stringify({
+		role: template.role,
+		events: template.events,
+		command: template.codexCommand,
+		commandWindows: template.codexCommandWindows
+	}, null, 2)}\n`;
+}
+function buildHooksValue(roles, toHandler) {
+	const selected = new Set(roles);
+	const value = {};
+	for (const role of ADVISORY_HOOK_ROLE_IDS) {
+		if (!selected.has(role)) continue;
+		const template = getAdvisoryHookTemplate(role);
+		for (const event of template.events) {
+			const entries = value[event] ?? [];
+			entries.push({ hooks: [toHandler(template)] });
+			value[event] = entries;
+		}
 	}
-];
+	return value;
+}
+/**
+* Build the value of the `hooks` key for the generated `.claude/settings.json`.
+* Event order is canonical (template-table order), independent of the order
+* roles appear in the profile.
+*/
+function buildClaudeAdvisoryHooksValue(roles) {
+	return buildHooksValue(roles, (template) => ({
+		type: "command",
+		command: template.claudeCommand
+	}));
+}
+/**
+* Build the full generated `.codex/hooks.json` document. Codex documents
+* `commandWindows` as the Windows-only command override, so both platform
+* variants live in the one deterministic artifact.
+*/
+function renderCodexHooksJson(roles) {
+	const hooks = buildHooksValue(roles, (template) => ({
+		type: "command",
+		command: template.codexCommand,
+		commandWindows: template.codexCommandWindows
+	}));
+	return `${JSON.stringify({ hooks }, null, 2)}\n`;
+}
+/**
+* Not-supported notes for hook-incapable targets (never silence). Claude and
+* Codex advisory hooks are generated (both confirmed-official with verified
+* event lists); Tabnine hook support remains unknown in the capability
+* matrix, so Tabnine-including profiles get an explicit note.
+*/
+function getAdvisoryHookNotes(profile) {
+	if (getSelectedAdvisoryHookRoles(profile).length === 0) return [];
+	const notes = [];
+	if (profile.clients.tabnine.enabled) notes.push({
+		code: "hooks_target_not_generated",
+		path: "/capabilities/hooks",
+		expected: "confirmed-official hook support",
+		actual: "unknown Tabnine hook support",
+		message: "capabilities.hooks advisory roles are not generated for Tabnine: hook support is not confirmed-official in the capability matrix."
+	});
+	return notes;
+}
+//#endregion
+//#region ../../packages/compiler/src/compiler.ts
 var TEMPLATE_SOURCES = [
 	{
 		id: "targets/agents-md@1",
@@ -18021,6 +18727,8 @@ var TEMPLATE_SOURCES = [
 	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),
+	agentsMdTopicTemplateSource("targets/agents-md/85-memory-guidance@1", MEMORY_GUIDANCE_TOPIC),
+	agentsMdTopicTemplateSource("targets/agents-md/86-logging-guidance@1", LOGGING_GUIDANCE_TOPIC),
 	{
 		id: "targets/lockfile@1",
 		target: "lockfile",
@@ -18038,6 +18746,8 @@ var TEMPLATE_SOURCES = [
 	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/85-memory-guidance@1", renderMemoryGuidanceGuideline),
+	guidelineTemplateSource("targets/tabnine-guidelines/86-logging-guidance@1", renderLoggingGuidanceGuideline),
 	guidelineTemplateSource("targets/tabnine-guidelines/90-final-review@1", renderFinalReviewGuideline),
 	{
 		id: "targets/tabnine-mcp-config@1",
@@ -18051,18 +18761,38 @@ var TEMPLATE_SOURCES = [
 		version: "1",
 		source: renderCodexConfigToml()
 	},
+	{
+		id: "targets/codex-hooks@1",
+		target: "codex-hooks",
+		version: "1",
+		source: renderCodexHooksJson(ADVISORY_HOOK_ROLE_IDS)
+	},
+	...ADVISORY_HOOK_ROLE_IDS.map((role) => codexHookTemplateSource(role)),
 	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"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/implement-next@1", "codex-workflow-skills", "implement-next"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/review-change@1", "codex-workflow-skills", "review-change"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/security-review@1", "codex-workflow-skills", "security-review"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/readability-review@1", "codex-workflow-skills", "readability-review"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/test-review@1", "codex-workflow-skills", "test-review"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/architecture-review@1", "codex-workflow-skills", "architecture-review"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/loop-implement-test-fix@1", "codex-workflow-skills", "loop-implement-test-fix"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/loop-review-patch-retest@1", "codex-workflow-skills", "loop-review-patch-retest"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/loop-security-patch-retest@1", "codex-workflow-skills", "loop-security-patch-retest"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/loop-docs-update@1", "codex-workflow-skills", "loop-docs-update"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/loop-sdd-cycle@1", "codex-workflow-skills", "loop-sdd-cycle"),
+	workflowSkillTemplateSource("targets/codex-workflow-skills/mcp-fit-check@1", "codex-workflow-skills", "mcp-fit-check"),
 	{
 		id: "targets/claude-settings@1",
 		target: "claude-settings",
 		version: "1",
 		source: renderClaudeSettingsJson()
 	},
+	...ADVISORY_HOOK_ROLE_IDS.map((role) => advisoryHookTemplateSource(role)),
 	{
 		id: "targets/claude-mcp@1",
 		target: "claude-mcp",
@@ -18080,7 +18810,19 @@ var TEMPLATE_SOURCES = [
 	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")
+	workflowSkillTemplateSource("targets/claude-workflow-skills/subagent-driven-change@1", "claude-workflow-skills", "subagent-driven-change"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/implement-next@1", "claude-workflow-skills", "implement-next"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/review-change@1", "claude-workflow-skills", "review-change"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/security-review@1", "claude-workflow-skills", "security-review"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/readability-review@1", "claude-workflow-skills", "readability-review"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/test-review@1", "claude-workflow-skills", "test-review"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/architecture-review@1", "claude-workflow-skills", "architecture-review"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/loop-implement-test-fix@1", "claude-workflow-skills", "loop-implement-test-fix"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/loop-review-patch-retest@1", "claude-workflow-skills", "loop-review-patch-retest"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/loop-security-patch-retest@1", "claude-workflow-skills", "loop-security-patch-retest"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/loop-docs-update@1", "claude-workflow-skills", "loop-docs-update"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/loop-sdd-cycle@1", "claude-workflow-skills", "loop-sdd-cycle"),
+	workflowSkillTemplateSource("targets/claude-workflow-skills/mcp-fit-check@1", "claude-workflow-skills", "mcp-fit-check")
 ];
 function getDefaultTemplates() {
 	return TEMPLATE_SOURCES.map(({ id, target, version, source }) => ({
@@ -18100,12 +18842,45 @@ function compileProfile(request) {
 	};
 	const files = targets.flatMap((target) => renderTarget(target, request.profile));
 	const requiredTemplateIds = getRequiredTemplateIdSet(targets, request.profile);
+	const notes = [
+		...getAdvisoryHookNotes(request.profile),
+		...getAutomationPackNotes(request.profile),
+		...getImplementNextNotes(request.profile)
+	];
 	return {
 		ok: true,
 		files: files.sort(compareGeneratedFiles),
-		templates: templates.filter((template) => requiredTemplateIds.has(template.id)).sort(compareTemplates)
+		templates: templates.filter((template) => requiredTemplateIds.has(template.id)).sort(compareTemplates),
+		...notes.length > 0 ? { notes } : {}
 	};
 }
+/**
+* Not-supported notes for the automation pack on a Tabnine-including target set
+* (never silence). Loop skills emit only for Claude and Codex; a profile that
+* selects `automation` with Tabnine enabled gets an explicit informational
+* note instead of silent omission.
+*/
+function getAutomationPackNotes(profile) {
+	if (!(profile.capabilities?.skills?.packs ?? []).includes("automation") || !profile.clients.tabnine.enabled) return [];
+	return [automationTabnineNote("/capabilities/skills/packs")];
+}
+/**
+* Phase 24 (I4): `implement-next` never silences a missing-capability target.
+* When its prerequisites are met but Tabnine is enabled, emit an informational
+* note (mirroring the WS6 automation-pack pattern): Tabnine is not
+* `confirmed-official` for the subagent chain the dispatcher drives, so the
+* skill is generated for Claude and Codex only.
+*/
+function getImplementNextNotes(profile) {
+	if (!emitsImplementNext(profile.workflow) || !profile.clients.tabnine.enabled) return [];
+	return [{
+		code: "implement_next_target_not_generated",
+		path: "/workflow/subagentDrivenDevelopment",
+		expected: "skills-capable client with a confirmed-official subagent chain (Claude or Codex)",
+		actual: "Tabnine has no implement-next dispatcher surface",
+		message: "implement-next is not generated for Tabnine: the ledger dispatcher targets skills-capable clients with a confirmed-official subagent chain (Claude and Codex) only."
+	}];
+}
 function mergeTemplates(base, extra) {
 	const seen = new Set(base.map((template) => template.id));
 	const result = [...base];
@@ -18132,7 +18907,7 @@ function getSubagentTemplates(profile) {
 		version: "1",
 		sha256: sha256Hex(normalizeGeneratedText(renderCodexSubagent(agent, effective)))
 	});
-	if (profile.clients.tabnine.enabled) for (const agent of agents) {
+	if (profile.clients.tabnine.enabled) for (const agent of getTabnineSubagents(profile)) {
 		if (agent.toolScope !== "read-only") continue;
 		templates.push({
 			id: `targets/tabnine-subagents/${agent.name}@1`,
@@ -18147,9 +18922,11 @@ 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 codeReviewSection = profile.workflow.codeReview === true && !profile.clients.codex.enabled && !profile.clients.claude.enabled ? `\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)}` : "";
+	const memoryGuidanceSection = profile.workflow.memoryGuidance === true ? `\n${renderTopicAsAgentsMdSection(MEMORY_GUIDANCE_TOPIC)}` : "";
+	const loggingGuidanceSection = profile.workflow.loggingGuidance === true ? `\n${renderTopicAsAgentsMdSection(LOGGING_GUIDANCE_TOPIC)}` : "";
 	return normalizeGeneratedText(`# AGENTS.md
 
 ## Instruction Precedence
@@ -18178,7 +18955,7 @@ ${enabledClients}
 - SDD: ${renderRequired(profile.workflow.sdd)}
 - TDD: ${renderRequired(profile.workflow.tdd)}
 - Final implementation review: ${renderRequired(profile.workflow.finalReview)}
-${codeReviewSection}${refactoringSection}${documentationSection}
+${codeReviewSection}${refactoringSection}${documentationSection}${memoryGuidanceSection}${loggingGuidanceSection}
 ## Permissions
 
 | Permission         | Mode  |
@@ -18251,11 +19028,16 @@ function renderTarget(target, 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(profile))];
+		case "codex-hooks": {
+			const roles = getSelectedAdvisoryHookRoles(profile);
+			if (roles.length === 0) return [];
+			return [createGeneratedTextFile(".codex/hooks.json", "codex-hooks", "targets/codex-hooks@1", renderCodexHooksJson(roles))];
+		}
 		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-settings": return [createGeneratedTextFile(".claude/settings.json", "claude-settings", "targets/claude-settings@1", renderClaudeSettingsJson(profile))];
 		case "claude-mcp": return [createGeneratedTextFile(".mcp.json", "claude-mcp", "targets/claude-mcp@1", JSON.stringify({ mcpServers: {} }, null, 2))];
 		case "claude-md": return [createGeneratedTextFile("CLAUDE.md", "claude-md", "targets/claude-md@1", renderClaudeMd())];
 		case "claude-workflow-skills": return renderWorkflowSkillFiles(profile, "claude-workflow-skills", ".claude/skills");
@@ -18273,19 +19055,38 @@ function renderTabnineGuidelines(profile) {
 	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 (resolveSelectedSkills(profile).includes("review-change")) 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.memoryGuidance === true) files.push(createGeneratedTextFile(".tabnine/guidelines/85-memory-guidance.md", common.target, "targets/tabnine-guidelines/85-memory-guidance@1", renderMemoryGuidanceGuideline()));
+	if (profile.workflow.loggingGuidance === true) files.push(createGeneratedTextFile(".tabnine/guidelines/86-logging-guidance.md", common.target, "targets/tabnine-guidelines/86-logging-guidance@1", renderLoggingGuidanceGuideline()));
 	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, getWorkflowSkillTemplateId(target, skill.id), renderWorkflowSkill(skill.id)));
+	const selected = resolveSelectedSkills(profile);
+	const selectedSet = new Set(selected);
+	const loggingOn = profile.workflow.loggingGuidance === true;
+	return selected.map((skill) => createGeneratedTextFile(`${rootPath}/${skill}/SKILL.md`, target, getWorkflowSkillTemplateId(target, skill), applyModelInvocationPolicy(applyLoggingEnforcementToSkill(renderWorkflowSkill(skill, selectedSet), skill, loggingOn), skill, target)));
+}
+/**
+* Phase 24 (I1): inject the `disable-model-invocation: true` frontmatter line
+* for entry-point skills on targets that verifiably support it (see
+* `disablesModelInvocation`). The flag is appended as the last frontmatter key,
+* just before the closing `---`, keeping `name`/`description` first.
+*/
+function applyModelInvocationPolicy(source, skill, target) {
+	if (!disablesModelInvocation(skill, target)) return source;
+	const lines = source.split("\n");
+	const closeIndex = lines.indexOf("---", 1);
+	if (closeIndex === -1) return source;
+	lines.splice(closeIndex, 0, "disable-model-invocation: true");
+	return lines.join("\n");
 }
 function getWorkflowSkillTemplateId(target, skill) {
 	return `targets/${target}/${skill}@${skill === "tdd-change" ? "2" : "1"}`;
 }
-function renderWorkflowSkill(skill) {
+function renderWorkflowSkill(skill, selectedSkills = /* @__PURE__ */ new Set()) {
 	switch (skill) {
 		case "grill-change": return `---
 name: grill-change
@@ -18319,6 +19120,20 @@ 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>\`
 
+## Design-it-Twice
+
+For a hard-to-reverse choice, present it as a Design-it-Twice question: sketch two genuinely different paths before recommending one.
+
+Path A: \`<approach>\` - interface: \`<the shape callers see>\`; risks: \`<what could go wrong>\`.
+Path B: \`<a genuinely different approach>\` - interface: \`<the shape callers see>\`; risks: \`<what could go wrong>\`.
+Recommendation: \`<the path you would choose and why>\`.
+
+Do not offer two variations of the same path. Reserve this form for choices that are expensive to change later; a routine choice needs one recommended answer, not two paths.
+
+## ADR Candidates
+
+Capture a decision as an ADR candidate when it is hard to reverse, surprising without context, or carries real trade-offs. Record the decision, the alternatives considered, and the reason as an agreement-record note only. Do not write an ADR file during the grill; synthesis persists it after approval.
+
 ## Decision Checks
 
 Before ending the grill, confirm:
@@ -18344,6 +19159,7 @@ When the user agrees the grill is complete, return:
 - Decisions made
 - Durable terms and hard-to-reverse decisions
 - Decision rules for implementation tradeoffs
+- ADR candidates that meet the threshold
 - Open questions or risks
 - Confirmation that post-grill synthesis can run next
 
@@ -18422,6 +19238,31 @@ Include these sections:
 \`TDD Strategy\` complements \`Tests\`; it must not replace the required \`Tests\`
 section from \`docs/specs/SPEC_TEMPLATE.md\`.
 
+## Seam & Interface Design
+
+Decide the test seam and mock boundary now, under this human gate, so the TDD loop runs without new architecture decisions.
+
+Classify each slice:
+
+- computation: pure input to output; the seam is the function's return value.
+- orchestration: coordinates other units; the seam is the observable effect at the boundary it drives.
+- deterministic generator: input profile to emitted artifacts; the seam is the generated output compared as a fixture.
+
+Seam rules:
+
+- Pick the highest boundary that keeps tests fast and deterministic; prefer fewer, higher seams over many low ones.
+- Prefer an existing seam over inventing a new one.
+- Declare the allowed mock boundary as unmanaged dependencies only, such as network, clock, or filesystem you do not own; never mock the code under test.
+- Sizing rule: one slice = one seam = one observable outcome = one RED.
+
+Human-gate checklist to confirm before writing briefs:
+
+1. Is the seam at the highest fast, deterministic boundary?
+2. Is the unit under test treated as a black box?
+3. Do inputs and outputs cross an explicit interface?
+4. Are the names drawn from the glossary?
+5. Does an abstraction exist only for the test?
+
 ## Issue Brief Format
 
 Each issue brief must include:
@@ -18434,6 +19275,8 @@ Each issue brief must include:
 - Acceptance criteria
 - Expected RED proof
 - Expected GREEN proof
+- Seam under test
+- Allowed mock boundary
 - Test command guidance
 - Likely file ownership
 - Dependencies
@@ -18454,6 +19297,15 @@ Use these states:
 - \`sequenced\`
 - \`human-gate\`
 
+## Persisted Artifacts
+
+After the user approves the synthesis, persist workflow state in one write step. All writes go through the client's write-approval flow.
+
+- \`TASKS.md\`: an index-only ledger. Each row links to a brief and carries one state from the closed set \`ready | blocked | sequenced | parallel-safe | human-gate | in-progress | done\`. Keep task content in the briefs, not the ledger.
+- \`docs/specs/<spec-dir>/issues/NNN-slug.md\`: one brief per slice, using the Issue Brief Format above.
+- \`CONTEXT.md\`: a glossary only, created lazily when the first durable term appears. Each definition is at most two sentences; add an \`Avoid:\` line for terms that must not be used. No implementation details or decisions.
+- ADRs: record a decision that meets all three criteria - hard to reverse, surprising without context, real trade-offs. Write to the existing project ADR directory if present, otherwise \`docs/adr/\`.
+
 ## Output
 
 Return:
@@ -18520,12 +19372,26 @@ description: Use when changing behavior where a focused failing test or golden f
 
 ## Testing Anti-Patterns
 
+- Do not write a tautological test: expected values must come from an independent source, never recomputed the way the code under test computes them.
 - 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.
 
+## Mock Boundary
+
+- Mock only unmanaged external dependencies, such as network, clock, or filesystem you do not own.
+- Prefer a fake over a stub, and a stub over a mock or spy.
+- Use a spy only where outbound communication is itself the tested contract.
+- Never introduce an abstraction that exists only for a test.
+
+## Seam Discipline
+
+- Read \`CONTEXT.md\` when it exists; test names and interface names must match its glossary terms.
+- Test only at the seam declared in the issue brief; do not re-decide the seam inside the loop.
+- If implementation shows the declared seam is wrong, stop and report \`BLOCKED\` with the reason. Never silently move or redesign the seam.
+
 ## 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.
@@ -18607,6 +19473,76 @@ Code-quality reviewer status values: \`ACCEPTABLE\`, \`ISSUES_FOUND\`, \`NEEDS_C
 
 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.
 `;
+		case "implement-next": return `---
+name: implement-next
+description: Use after synthesis to dispatch the next ready task from the TASKS.md ledger through one subagent-driven implementation cycle, one task per invocation.
+---
+
+<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
+
+# Implement Next
+
+## Purpose
+
+Advance exactly one ready task from the \`TASKS.md\` ledger through a single implementation cycle, using its persisted issue brief as context. One invocation advances at most one task; it never iterates. Repeat the command for the next task.
+
+## Preconditions
+
+- \`TASKS.md\` exists and is an index-only ledger whose rows link to issue briefs.
+- If \`TASKS.md\` is missing or contains no \`ready\` task, stop and report the ledger state; do not invent work.
+
+## Flow
+
+1. Read \`TASKS.md\` and select the first task in state \`ready\`.
+   - Stop at a \`human-gate\` task and explain the approval it needs; do not proceed past it.
+   - Skip \`blocked\` and \`sequenced\` tasks; they are not ready.
+   - If no \`ready\` task exists, stop and report.
+2. Mark the selected task \`in-progress\` in \`TASKS.md\` through the client's write-approval flow.
+3. Load the linked issue brief and run \`subagent-driven-change\` with the brief as Fresh Context: \`implementer\`, then \`spec-reviewer\`, then \`code-quality-reviewer\`.
+4. When reviews pass and the required tests run green, mark the task \`done\` and stop. The next task requires a new invocation.
+
+## Failure Path
+
+Stop and report \`BLOCKED\` when any of these holds:
+
+- \`implementer\` returns \`BLOCKED\` or \`NEEDS_CONTEXT\`,
+- a review finding cannot be resolved within the brief's scope,
+- GREEN is unreachable within the brief's declared seam.
+
+On failure, mark the task \`blocked\` in \`TASKS.md\` with a one-line reason; if the declared seam was wrong, include why it failed. Then stop. Do not touch the next task, do not edit the brief, and do not continue to another task. A human decides whether to edit the brief, re-grill, or split the task, and flips the state back to \`ready\`.
+
+## Output
+
+Report the selected task, the state transitions applied, the subagent results, the tests run, and the final state (\`done\` or \`blocked\` with its one-line reason).
+
+## Safety
+
+- Do not upload source code.
+- Do not read or print secrets.
+- Do not iterate across tasks; one invocation advances at most one task.
+- Do not self-approve; all writes, commits, and destructive steps go through the client's write-approval flow.
+- Do not edit issue briefs or advance a task that failed.
+- Do not propose \`bypassPermissions\`, tool pre-approval, dependency auto-installation, hosted execution, or remote MCP behavior.
+`;
+		case "review-change": return renderReviewChangeSkill(selectedSkills);
+		case "security-review":
+		case "readability-review":
+		case "test-review":
+		case "architecture-review": {
+			const rendered = renderSpecialistReviewSkill(skill);
+			if (rendered === void 0) throw new Error(`Missing specialist review content for ${skill}.`);
+			return rendered;
+		}
+		case "loop-implement-test-fix":
+		case "loop-review-patch-retest":
+		case "loop-security-patch-retest":
+		case "loop-docs-update":
+		case "loop-sdd-cycle": {
+			const rendered = renderLoopSkillContent(skill, selectedSkills);
+			if (rendered === void 0) throw new Error(`Missing loop skill content for ${skill}.`);
+			return rendered;
+		}
+		case "mcp-fit-check": return renderMcpFitCheckSkill();
 	}
 }
 function renderGeneralAgentBehaviorGuideline(profile) {
@@ -18700,6 +19636,66 @@ function renderRefactoringGuideline() {
 function renderDocumentationGuideline() {
 	return renderTopicAsTabnineGuideline(DOCUMENTATION_TOPIC);
 }
+function renderMemoryGuidanceGuideline() {
+	return renderTopicAsTabnineGuideline(MEMORY_GUIDANCE_TOPIC);
+}
+function renderLoggingGuidanceGuideline() {
+	return renderTopicAsTabnineGuideline(LOGGING_GUIDANCE_TOPIC);
+}
+/**
+* Phase 25 (I2): flag-conditional logging-enforcement text. These lines
+* REFERENCE the Logging Guidance convention (emitted into AGENTS.md/CLAUDE.md
+* by I1); they never restate the verbatim redaction rule (single source of
+* truth, ADR 0008). They are injected at emission time, gated on
+* `workflow.loggingGuidance`, mirroring `applyModelInvocationPolicy`. Tabnine
+* is documentation-only (ADR 0007) and never receives these lines.
+*/
+var LOGGING_ENFORCEMENT_BY_AGENT = {
+	implementer: "Follow the project's logging convention (the Logging Guidance section in AGENTS.md). If debug or diagnostic output you added is still present when you would otherwise report DONE, report DONE_WITH_CONCERNS and name the leftover output instead.",
+	"code-quality-reviewer": "Check logging discipline in the change: stray print/console output left in production code, new error paths lacking a stable event code, and any log that violates the redaction rule in the project's Logging Guidance convention. Reference that rule; do not restate it."
+};
+var LOGGING_ENFORCEMENT_FINAL_REVIEW = "Confirm debug output added during the change was removed and any new error paths carry a stable event code, per the project's Logging Guidance convention.";
+/**
+* Append the flag-conditional logging-enforcement paragraph to the emitted
+* prompt for the agents in `LOGGING_ENFORCEMENT_BY_AGENT`. Returns the prompt
+* unchanged for any other agent or when the flag is off. The appended text is
+* plain prose with no `"""`, so the Codex renderer's triple-quote guard is
+* preserved.
+*/
+function applyLoggingEnforcementToPrompt(prompt, agentName, loggingOn) {
+	if (!loggingOn) return prompt;
+	const enforcement = LOGGING_ENFORCEMENT_BY_AGENT[agentName];
+	if (enforcement === void 0) return prompt;
+	return `${prompt.trimEnd()}\n\n${enforcement}`;
+}
+/**
+* Insert the flag-conditional logging checklist item into the `final-review`
+* skill's `## Instructions` numbered list, just before the following section.
+* Returns the source unchanged for any other skill or when the flag is off.
+*
+* Assumes the Instructions list is flat and monotonically numbered (1..N with
+* no nesting); the appended item is numbered N+1. A template change that
+* breaks this assumption shifts the emitted bytes and fails the golden
+* fixtures, so it cannot ship silently.
+*/
+function applyLoggingEnforcementToSkill(source, skill, loggingOn) {
+	if (!loggingOn || skill !== "final-review") return source;
+	const lines = source.split("\n");
+	const instructionsIndex = lines.indexOf("## Instructions");
+	if (instructionsIndex === -1) return source;
+	let lastItemIndex = -1;
+	for (let i = instructionsIndex + 1; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line !== void 0 && line.startsWith("## ")) break;
+		if (line !== void 0 && /^\d+\.\s/u.test(line)) lastItemIndex = i;
+	}
+	if (lastItemIndex === -1) return source;
+	const match = lines[lastItemIndex]?.match(/^(\d+)\.\s/u);
+	if (!match || match[1] === void 0) return source;
+	const nextNumber = Number.parseInt(match[1], 10) + 1;
+	lines.splice(lastItemIndex + 1, 0, `${nextNumber}. ${LOGGING_ENFORCEMENT_FINAL_REVIEW}`);
+	return lines.join("\n");
+}
 function renderTypeScriptSvelteGuideline() {
 	return `<!-- Generated by Agent Profile Compiler. Do not edit by hand. -->
 
@@ -18777,15 +19773,36 @@ 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)));
+	const loggingOn = profile.workflow.loggingGuidance === true;
+	return agents.map((agent) => createGeneratedTextFile(`.claude/agents/${agent.name}.md`, "claude-subagents", `targets/claude-subagents/${agent.name}@1`, renderClaudeSubagent(withLoggingEnforcement(agent, loggingOn), 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)));
+	const loggingOn = profile.workflow.loggingGuidance === true;
+	return agents.map((agent) => createGeneratedTextFile(`.codex/agents/${agent.name}.toml`, "codex-subagents", `targets/codex-subagents/${agent.name}@1`, renderCodexSubagent(withLoggingEnforcement(agent, loggingOn), effective)));
+}
+/**
+* Return `agent` with the flag-conditional logging-enforcement paragraph
+* appended to its prompt when applicable. The transform touches only the
+* emitted prompt; the canonical template prompt is left unchanged.
+*/
+function withLoggingEnforcement(agent, loggingOn) {
+	const prompt = applyLoggingEnforcementToPrompt(agent.prompt, agent.name, loggingOn);
+	if (prompt === agent.prompt) return agent;
+	return {
+		...agent,
+		prompt
+	};
 }
 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)));
+	return getTabnineSubagents(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)));
+}
+var REVIEWER_SUBAGENT_NAMES = new Set(REVIEWER_DEFINITIONS.map((definition) => definition.reviewerId));
+function getTabnineSubagents(profile) {
+	const agents = getEnabledSubagents(profile);
+	if (!(profile.capabilities?.delegation?.subagents?.packs?.includes("reviewer-subagents") === true)) return agents;
+	return agents.filter((agent) => !REVIEWER_SUBAGENT_NAMES.has(agent.name));
 }
 function titleCaseFromKebab(name) {
 	return name.split("-").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
@@ -18913,12 +19930,28 @@ function agentsMdTopicTemplateSource(id, topic) {
 		source: renderTopicAsAgentsMdSection(topic)
 	};
 }
+function advisoryHookTemplateSource(role) {
+	return {
+		id: getAdvisoryHookTemplateId(role),
+		target: "claude-settings",
+		version: "1",
+		source: renderAdvisoryHookTemplateSource(role)
+	};
+}
+function codexHookTemplateSource(role) {
+	return {
+		id: getCodexHookTemplateId(role),
+		target: "codex-hooks",
+		version: "1",
+		source: renderCodexHookTemplateSource(role)
+	};
+}
 function workflowSkillTemplateSource(id, target, skill) {
 	return {
 		id,
 		target,
 		version: "1",
-		source: renderWorkflowSkill(skill)
+		source: applyModelInvocationPolicy(renderWorkflowSkill(skill), skill, target)
 	};
 }
 function hasStack(profile, field, value) {
@@ -18927,8 +19960,8 @@ function hasStack(profile, field, value) {
 function hasAnyStack(profile, field, values) {
 	return values.some((value) => hasStack(profile, field, value));
 }
-function renderClaudeSettingsJson() {
-	return `{
+function renderClaudeSettingsJson(profile) {
+	const base = `{
   "permissions": {
     "defaultMode": "default",
     "allow": [],
@@ -18948,16 +19981,22 @@ function renderClaudeSettingsJson() {
     "autoAllowBashIfSandboxed": false
   }
 }`;
+	const roles = profile ? getSelectedAdvisoryHookRoles(profile) : [];
+	if (roles.length === 0) return base;
+	const hooksJson = JSON.stringify(buildClaudeAdvisoryHooksValue(roles), null, 2).split("\n").map((line, index) => index === 0 ? line : `  ${line}`).join("\n");
+	return base.replace(/\n\}$/u, `,\n  "hooks": ${hooksJson}\n}`);
 }
 function getEnabledTargetIds(profile) {
 	const targets = ["agents-md"];
 	const subagentsEnabled = getEnabledSubagents(profile).length > 0;
+	const tabnineSubagentsEnabled = getTabnineSubagents(profile).length > 0;
 	if (profile.clients.tabnine.enabled) {
 		targets.push("tabnine-guidelines", "tabnine-mcp-config");
-		if (subagentsEnabled) targets.push("tabnine-subagents");
+		if (tabnineSubagentsEnabled) targets.push("tabnine-subagents");
 	}
 	if (profile.clients.codex.enabled) {
 		targets.push("codex-config", "codex-workflow-skills");
+		if (getSelectedAdvisoryHookRoles(profile).length > 0) targets.push("codex-hooks");
 		if (subagentsEnabled) targets.push("codex-subagents");
 	}
 	if (profile.clients.claude.enabled) {
@@ -18983,7 +20022,7 @@ function validateTargets(profile, targets, templates) {
 		});
 	}
 	if (targets.includes("tabnine-subagents")) {
-		const writeAgents = getEnabledSubagents(profile).filter((agent) => agent.toolScope === "workspace-write");
+		const writeAgents = getTabnineSubagents(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`,
@@ -19063,16 +20102,20 @@ function getRequiredTemplateIds(target, profile) {
 		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`);
+		case "tabnine-subagents": return getTabnineSubagents(profile).filter((agent) => agent.toolScope === "read-only").map((agent) => `targets/tabnine-subagents/${agent.name}@1`);
+		case "claude-settings": return ["targets/claude-settings@1", ...getSelectedAdvisoryHookRoles(profile).map((role) => getAdvisoryHookTemplateId(role))];
+		case "codex-hooks": return ["targets/codex-hooks@1", ...getSelectedAdvisoryHookRoles(profile).map((role) => getCodexHookTemplateId(role))];
 		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.codeReview === true && !profile.clients.codex.enabled && !profile.clients.claude.enabled) 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");
+	if (profile.workflow.memoryGuidance === true) ids.push("targets/agents-md/85-memory-guidance@1");
+	if (profile.workflow.loggingGuidance === true) ids.push("targets/agents-md/86-logging-guidance@1");
 	return ids;
 }
 function getRequiredTabnineGuidelineTemplateIds(profile) {
@@ -19086,14 +20129,16 @@ function getRequiredTabnineGuidelineTemplateIds(profile) {
 	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 (resolveSelectedSkills(profile).includes("review-change")) 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.memoryGuidance === true) ids.push("targets/tabnine-guidelines/85-memory-guidance@1");
+	if (profile.workflow.loggingGuidance === true) ids.push("targets/tabnine-guidelines/86-logging-guidance@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));
+	return resolveSelectedSkills(profile).map((skill) => getWorkflowSkillTemplateId(target, skill));
 }
 function uniqueTargets(targets) {
 	return Array.from(new Set(targets));
@@ -19984,5 +21029,5 @@ function truncatePreview(text, capBytes = 256 * 1024) {
 	};
 }
 
-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
+export { readRegionAwareFile as A, redactIfSecretLike as B, PHASE_14_SCAN_DIRS as C, loadProjectContext as D, writeProfileAtomic as E, ProfileWriteError as F, computeFileEtag as G, validateProfileValue as H, renderProfileYaml as I, truncatePreview as J, PHASE_14_SUPPORTED_PATHS as P, REGION_AWARE_ROOT_PATHS as R, VERIFIED_CLAUDE_HOOK_EVENTS as V, applyWritePlan as a, buildPhase14ImportReport as b, compileProfile as c, deriveEffectivePermissions as d, containsSecretLikeLiteral as e, hasAnyRegionMarker as f, parseMixedFile as g, hasAllRegionMarkers as h, isLoopSkillId as i, hasLegacyGeneratedMarker as j, createLockfileFile as k, sha256Hex as l, getEnabledSubagents as m, normalizeSafety as n, isSubagentBuiltinNameCollision as o, parseProfileYaml as p, getSelectedAdvisoryHookRoles as q, resolveProjectRoot as r, safeOutputPath as s, toLockfileV2View as t, getAdvisoryHookTemplate as u, validateLockfileText as v, VERIFIED_CODEX_HOOK_EVENTS as w, readLockfileForRegions as x, planRootInstructionsAdoption as y, planWrites as z };
+//# sourceMappingURL=projectContext-BtPm3MFR.js.map