@agent-profile/web 0.3.5 → 0.4.0

package/build/server/chunks/{src2-BtraGDB1.js → src2-DwXcz8UE.js}

@@ -1,4 +1,4 @@
-import { p as parseProfileYaml } from './projectContext-B1D-bieW.js';
+import { p as parseProfileYaml } from './projectContext-BtPm3MFR.js';
 import 'node:fs/promises';
 import 'process';
 import 'buffer';
@@ -9,4 +9,4 @@ import 'node:crypto';
 
 
 export { parseProfileYaml };
-//# sourceMappingURL=src2-BtraGDB1.js.map
+//# sourceMappingURL=src2-DwXcz8UE.js.map

package/build/server/chunks/src2-DwXcz8UE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"src2-DwXcz8UE.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/build/server/chunks/{src3-BXch_OaJ.js → src3-DeQh3O0_.js}

@@ -1,7 +1,143 @@
-import { p as parseProfileYaml, c as compileProfile, t as toLockfileV2View, d as deriveEffectivePermissions, s as safeOutputPath, e as containsSecretLikeLiteral, v as validateLockfileText, h as hasAllRegionMarkers, f as hasAnyRegionMarker, g as parseMixedFile, i as hasLegacyGeneratedMarker, j as createLockfileFile, k as sha256Hex, n as normalizeSafety, l as getEnabledSubagents, m as isSubagentBuiltinNameCollision } from './projectContext-B1D-bieW.js';
+import { p as parseProfileYaml, c as compileProfile, t as toLockfileV2View, d as deriveEffectivePermissions, s as safeOutputPath, e as containsSecretLikeLiteral, i as isLoopSkillId, v as validateLockfileText, h as hasAllRegionMarkers, f as hasAnyRegionMarker, g as parseMixedFile, j as hasLegacyGeneratedMarker, k as createLockfileFile, l as sha256Hex, n as normalizeSafety, m as getEnabledSubagents, o as isSubagentBuiltinNameCollision, q as getSelectedAdvisoryHookRoles, u as getAdvisoryHookTemplate, V as VERIFIED_CLAUDE_HOOK_EVENTS, w as VERIFIED_CODEX_HOOK_EVENTS } from './projectContext-BtPm3MFR.js';
 import { lstat, readFile, readdir } from 'node:fs/promises';
 import path from 'node:path';
 
+//#region ../../packages/doctor/src/mcpSuggestions.ts
+var BASELINE_KNOWN_AS_OF = "2026-07-04";
+var KNOWLEDGE_BASELINES = [
+	baseline("react", "19.2.7"),
+	baseline("react-dom", "19.2.7"),
+	baseline("next", "16.2.10"),
+	baseline("vue", "3.5.39"),
+	baseline("@angular/core", "22.0.5"),
+	baseline("svelte", "5.56.4"),
+	baseline("typescript", "6.0.3"),
+	baseline("vite", "8.1.3"),
+	baseline("express", "5.2.1")
+];
+function baseline(packageName, knownVersion) {
+	return {
+		packageName,
+		ecosystem: "npm",
+		knownVersion,
+		knownAsOf: BASELINE_KNOWN_AS_OF,
+		candidateIds: ["docs-current-frameworks"],
+		riskCode: "new_framework_version"
+	};
+}
+var EXACT_STABLE_SEMVER = /^(\d+)\.(\d+)\.(\d+)$/u;
+var PRERELEASE_OR_BUILD = /^\d+\.\d+\.\d+[-+]/u;
+var PARTIAL_VERSION = /^\d+(?:\.\d+)?(?:\.(?:x|\*))?$/u;
+var URL_LIKE_PREFIX = /^(?:git\+|git:|github:|file:|link:|portal:|npm:|https?:)/u;
+function evaluateDependencyVersion(detected, knownVersion) {
+	const value = detected.trim();
+	if (value.startsWith("workspace:")) return {
+		kind: "not-comparable",
+		reason: "workspace-alias"
+	};
+	if (URL_LIKE_PREFIX.test(value) || value.includes("://")) return {
+		kind: "not-comparable",
+		reason: "git-or-url"
+	};
+	const exact = EXACT_STABLE_SEMVER.exec(value);
+	if (exact) {
+		const detectedParts = toVersionParts(exact);
+		const knownExact = EXACT_STABLE_SEMVER.exec(knownVersion);
+		if (!knownExact) return {
+			kind: "not-comparable",
+			reason: "non-semver"
+		};
+		return compareVersionParts(detectedParts, toVersionParts(knownExact)) > 0 ? {
+			kind: "newer",
+			detectedVersion: detectedParts.join(".")
+		} : { kind: "not-newer" };
+	}
+	if (PRERELEASE_OR_BUILD.test(value)) return {
+		kind: "not-comparable",
+		reason: "prerelease"
+	};
+	if (isRangeDeclaration(value)) return {
+		kind: "not-comparable",
+		reason: "range"
+	};
+	return {
+		kind: "not-comparable",
+		reason: "non-semver"
+	};
+}
+function isRangeDeclaration(value) {
+	if (value === "*" || value === "x" || value === "latest") return true;
+	if (/^[\^~><=]/u.test(value) || value.includes("||")) return true;
+	return PARTIAL_VERSION.test(value);
+}
+function toVersionParts(match) {
+	return [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	];
+}
+function compareVersionParts(left, right) {
+	for (let index = 0; index < 3; index += 1) {
+		const difference = (left[index] ?? 0) - (right[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+var DEPENDENCY_SECTIONS = ["dependencies", "devDependencies"];
+async function scanMcpSuggestions(rootDir) {
+	const manifest = await readPackageManifest(rootDir);
+	if (!manifest) return [];
+	const issues = [];
+	const baselinesByName = new Map(KNOWLEDGE_BASELINES.filter((entry) => entry.ecosystem === "npm").map((entry) => [entry.packageName, entry]));
+	for (const section of DEPENDENCY_SECTIONS) {
+		const declarations = getStringRecord(manifest[section]);
+		for (const packageName of Object.keys(declarations).sort()) {
+			const matched = baselinesByName.get(packageName);
+			if (!matched) continue;
+			const evaluation = evaluateDependencyVersion(declarations[packageName] ?? "", matched.knownVersion);
+			const issuePath = `package.json/${section}/${packageName}`;
+			if (evaluation.kind === "newer") issues.push({
+				code: "MCP-SUGGEST-NEW-FRAMEWORK",
+				severity: "info",
+				path: issuePath,
+				expected: `baseline ${matched.knownVersion} or older (as of ${matched.knownAsOf})`,
+				actual: evaluation.detectedVersion,
+				message: `${packageName} ${evaluation.detectedVersion} is newer than APC's pinned baseline ${matched.knownVersion} (as of ${matched.knownAsOf}); current docs may help.`,
+				guidance: `Consider curated MCP candidate ids: ${matched.candidateIds.join(", ")}. APC recommends only; install and configuration are deferred to the user.`
+			});
+			else if (evaluation.kind === "not-comparable") issues.push({
+				code: "MCP-SUGGEST-UNCOMPARABLE",
+				severity: "info",
+				path: issuePath,
+				expected: "exact stable semver version",
+				actual: evaluation.reason,
+				message: `${packageName} version declaration is not comparable (${evaluation.reason}); no staleness claim is made.`,
+				guidance: "Pin an exact stable version to enable baseline comparison; APC makes no staleness claim for non-comparable declarations."
+			});
+		}
+	}
+	return issues;
+}
+async function readPackageManifest(rootDir) {
+	let text;
+	try {
+		text = await readFile(path.join(rootDir, "package.json"), "utf8");
+	} catch {
+		return;
+	}
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+	} catch {}
+}
+function getStringRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") result[key] = entry;
+	return result;
+}
+//#endregion
 //#region ../../packages/doctor/src/doctor.ts
 var PROFILE_PATH = "ai-profile.yaml";
 var LOCKFILE_PATH = "ai-profile.lock";
@@ -14,6 +150,7 @@ var SEVERITY_ORDER = {
 async function runDoctor(request = {}) {
 	const rootDir = path.resolve(request.rootDir ?? ".");
 	const issues = [];
+	if (request.mcpSuggestions) issues.push(...await scanMcpSuggestions(rootDir));
 	const profileBytes = await readKnownFile(rootDir, PROFILE_PATH);
 	if (!profileBytes.ok) {
 		issues.push(issue("LINT-STRUCT-001", "error", PROFILE_PATH, "readable profile file", "missing", "ai-profile.yaml was not found.", "Create ai-profile.yaml at the repository root before running doctor."));
@@ -24,6 +161,7 @@ async function runDoctor(request = {}) {
 		for (const profileIssue of profileResult.issues) issues.push(issue("LINT-STRUCT-002", "error", profileIssue.path, profileIssue.expected, profileIssue.actual, profileIssue.message, "Fix ai-profile.yaml before running compiler or doctor checks."));
 		return toResult(issues);
 	}
+	checkUnknownLanguageFallback(profileResult.profile, issues);
 	const compileResult = compileProfile({ profile: profileResult.profile });
 	if (!compileResult.ok) {
 		for (const compileIssue of compileResult.issues) issues.push(issue("LINT-STRUCT-002", "error", compileIssue.path, compileIssue.expected, compileIssue.actual, compileIssue.message, "Fix ai-profile.yaml client and target settings before running doctor."));
@@ -32,6 +170,8 @@ async function runDoctor(request = {}) {
 	await checkGeneratedArtifactsExist(rootDir, compileResult.files, issues);
 	await checkGeneratedArtifactSecurity(rootDir, compileResult.files, issues);
 	await checkSkillFiles(rootDir, issues);
+	await checkSkillPackArtifacts(rootDir, compileResult.files, issues);
+	await checkLoopSkillStructure(rootDir, compileResult.files, issues);
 	await checkSemanticWarnings(rootDir, compileResult.files, issues);
 	await checkGitignoreSecretHygiene(rootDir, issues);
 	const lockfile = await readAndValidateLockfile(rootDir, issues);
@@ -56,8 +196,177 @@ async function runDoctor(request = {}) {
 	});
 	await checkLocalRuntimeGitignore(rootDir, issues);
 	await checkForeignSkillAndSubagentCollisions(rootDir, compileResult.files, lockfileV2, issues);
+	await checkAdvisoryHookArtifacts(rootDir, profileResult.profile, issues);
+	await checkRuntimeArtifactStructure(rootDir, issues);
 	return toResult(issues);
 }
+var LEDGER_STATES = /* @__PURE__ */ new Set([
+	"ready",
+	"blocked",
+	"sequenced",
+	"parallel-safe",
+	"human-gate",
+	"in-progress",
+	"done"
+]);
+async function checkRuntimeArtifactStructure(rootDir, issues) {
+	await checkTaskLedgerStructure(rootDir, issues);
+	await checkContextGlossaryStructure(rootDir, issues);
+}
+async function checkTaskLedgerStructure(rootDir, issues) {
+	const file = await readKnownFile(rootDir, "TASKS.md");
+	if (!file.ok) return;
+	const lines = decodeUtf8(file.bytes).split("\n");
+	let inTableBody = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("|")) {
+			inTableBody = false;
+			continue;
+		}
+		if (isTableSeparatorRow(trimmed)) {
+			inTableBody = true;
+			continue;
+		}
+		if (!inTableBody) continue;
+		const hasKnownState = tableCells(trimmed).some((cell) => LEDGER_STATES.has(firstToken(cell.replace(/`/gu, ""))));
+		const hasBriefLink = /\[[^\]]+\]\([^)]+\)/u.test(trimmed);
+		if (!hasKnownState) issues.push(issue("LINT-LEDGER-001", "info", "TASKS.md", "ledger row state in the closed set `ready | blocked | sequenced | parallel-safe | human-gate | in-progress | done`", `unrecognized state in row: ${trimmed}`, "A TASKS.md ledger row uses a state outside the closed set.", "APC does not own TASKS.md; if this is a task row, set its state to a known value."));
+		if (!hasBriefLink) issues.push(issue("LINT-LEDGER-002", "info", "TASKS.md", "each ledger row links to an issue brief", `no brief link in row: ${trimmed}`, "A TASKS.md ledger row does not link to an issue brief.", "APC does not own TASKS.md; if this is a task row, add a markdown link to its brief."));
+	}
+}
+async function checkContextGlossaryStructure(rootDir, issues) {
+	const file = await readKnownFile(rootDir, "CONTEXT.md");
+	if (!file.ok) return;
+	const marker = findNonGlossaryMarker(decodeUtf8(file.bytes));
+	if (marker === void 0) return;
+	issues.push(issue("LINT-CONTEXT-001", "info", "CONTEXT.md", "glossary-only content (term definitions and `Avoid:` lines)", marker, "CONTEXT.md appears to contain non-glossary content; it is meant to be a glossary only.", "APC does not own CONTEXT.md; move implementation details or decisions out of the glossary."));
+}
+function findNonGlossaryMarker(text) {
+	if (/^```/mu.test(text)) return "fenced code block";
+	const heading = text.split("\n").map((line) => line.trim()).find((line) => /^#{1,6}\s+(decision|implementation|architecture|rationale|adr|design)\b/iu.test(line));
+	return heading === void 0 ? void 0 : `non-glossary heading: ${heading}`;
+}
+function isTableSeparatorRow(row) {
+	return /^\|?[\s:|-]+\|?$/u.test(row) && row.includes("-");
+}
+function tableCells(row) {
+	return row.replace(/^\|/u, "").replace(/\|$/u, "").split("|").map((cell) => cell.trim());
+}
+function firstToken(value) {
+	return value.trim().split(/\s+/u)[0] ?? "";
+}
+var VERIFIED_CLAUDE_HOOK_EVENT_SET = new Set(VERIFIED_CLAUDE_HOOK_EVENTS);
+var VERIFIED_CODEX_HOOK_EVENT_SET = new Set(VERIFIED_CODEX_HOOK_EVENTS);
+async function checkAdvisoryHookArtifacts(rootDir, profile, issues) {
+	const selectedRoles = getSelectedAdvisoryHookRoles(profile);
+	if (profile.clients.claude.enabled) await checkHooksArtifact({
+		rootDir,
+		issues,
+		path: ".claude/settings.json",
+		selectedRoles,
+		verifiedEvents: VERIFIED_CLAUDE_HOOK_EVENT_SET,
+		target: "claude",
+		extractHooks: (parsed) => isJsonRecord(parsed) && isJsonRecord(parsed["hooks"]) ? parsed["hooks"] : void 0,
+		toPinnedHandler: (template) => ({
+			type: "command",
+			command: template.claudeCommand
+		})
+	});
+	if (profile.clients.codex.enabled) {
+		await checkCodexConfigHookSurface(rootDir, issues);
+		if (selectedRoles.length > 0) await checkHooksArtifact({
+			rootDir,
+			issues,
+			path: ".codex/hooks.json",
+			selectedRoles,
+			verifiedEvents: VERIFIED_CODEX_HOOK_EVENT_SET,
+			target: "codex",
+			extractHooks: (parsed) => isJsonRecord(parsed) && isJsonRecord(parsed["hooks"]) ? parsed["hooks"] : void 0,
+			toPinnedHandler: (template) => ({
+				type: "command",
+				command: template.codexCommand,
+				commandWindows: template.codexCommandWindows
+			})
+		});
+	}
+}
+async function checkHooksArtifact(input) {
+	const file = await readKnownFile(input.rootDir, input.path);
+	if (!file.ok) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(decodeUtf8(file.bytes));
+	} catch {
+		return;
+	}
+	const hooks = input.extractHooks(parsed);
+	if (!hooks) return;
+	const pinnedByEvent = /* @__PURE__ */ new Map();
+	for (const role of input.selectedRoles) {
+		const template = getAdvisoryHookTemplate(role);
+		for (const event of template.events) {
+			const handlers = pinnedByEvent.get(event) ?? [];
+			handlers.push(input.toPinnedHandler(template));
+			pinnedByEvent.set(event, handlers);
+		}
+	}
+	for (const [event, entries] of Object.entries(hooks)) {
+		if (!input.verifiedEvents.has(event)) input.issues.push(issue("LINT-HOOK-003", "error", input.path, `hook event from the verified ${input.target} event list`, event, `${input.path} declares a hook for unverified event ${event}.`, "Remove the unverified hook event; new events require re-verified official docs and an approved spec."));
+		const pinned = pinnedByEvent.get(event) ?? [];
+		for (const violation of collectNonPinnedHookHandlers(entries, pinned)) input.issues.push(issue("LINT-HOOK-008", "error", input.path, "pinned advisory hook command for a selected role", violation, `${input.path} contains a hook entry for ${event} that does not match the pinned advisory template.`, `Regenerate ${input.path} from ai-profile.yaml; slice 1 emits only pinned advisory commands for selected roles.`));
+	}
+}
+function collectNonPinnedHookHandlers(entries, pinnedHandlers) {
+	if (!Array.isArray(entries)) return ["non-array hook event value"];
+	const violations = [];
+	for (const entry of entries) {
+		if (!isJsonRecord(entry) || !Array.isArray(entry["hooks"])) {
+			violations.push("malformed hook entry");
+			continue;
+		}
+		for (const item of entry["hooks"]) if (!(isJsonRecord(item) && pinnedHandlers.some((handler) => handlerEquals(item, handler)))) violations.push(isJsonRecord(item) && typeof item["command"] === "string" ? "non-pinned hook command" : "malformed hook entry");
+	}
+	return violations;
+}
+function handlerEquals(item, pinned) {
+	const pinnedKeys = Object.keys(pinned);
+	return Object.keys(item).length === pinnedKeys.length && pinnedKeys.every((key) => item[key] === pinned[key]);
+}
+async function checkCodexConfigHookSurface(rootDir, issues) {
+	const file = await readKnownFile(rootDir, ".codex/config.toml");
+	if (!file.ok) return;
+	if (codexConfigDeclaresInlineHooks(decodeUtf8(file.bytes))) issues.push(issue("LINT-HOOK-005", "error", ".codex/config.toml", "no hook surface outside the generated .codex/hooks.json", "inline hooks section present", ".codex/config.toml contains an inline hooks surface; APC generates Codex hooks only in .codex/hooks.json.", "Remove the inline hooks table from the generated config.toml; declare hook intent through capabilities.hooks instead."));
+}
+/**
+* Detect an inline hook surface in config.toml: a `[hooks]` / `[hooks.*]` /
+* `[[hooks.*]]` table header, or a root-level `hooks` key. A `hooks` key
+* inside another table (for example the documented `[features]`
+* `hooks = false` feature flag) is not a hook definition and must not be
+* flagged.
+*/
+function codexConfigDeclaresInlineHooks(text) {
+	let inRootTable = true;
+	for (const rawLine of text.split(/\r?\n/u)) {
+		const line = rawLine.trim();
+		const header = /^\[\[?\s*([^\]\s]+)\s*\]?\]/u.exec(line);
+		if (header) {
+			const tablePath = header[1] ?? "";
+			if (tablePath === "hooks" || tablePath.startsWith("hooks.")) return true;
+			inRootTable = false;
+			continue;
+		}
+		if (inRootTable && /^hooks\s*[.=]/u.test(line)) return true;
+	}
+	return false;
+}
+function isJsonRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkUnknownLanguageFallback(profile, issues) {
+	if (!profile.stack.languages.includes("unknown")) return;
+	issues.push(issue("LINT-SEM-003", "warning", "/stack/languages", "known language slugs", "unknown", "stack.languages contains the temporary unknown fallback.", "Replace unknown with the real language slug when it is known."));
+}
 async function checkGeneratedArtifactsExist(rootDir, files, issues) {
 	for (const file of files) if (!(await readKnownFile(rootDir, file.path)).ok) issues.push(issue("LINT-STRUCT-003", "error", file.path, `generated artifact for ${file.target}`, "missing", `${file.path} is missing for enabled target ${file.target}.`, "Run the compiler after reviewing enabled targets."));
 }
@@ -94,6 +403,70 @@ async function checkSkillFiles(rootDir, issues) {
 		if (duplicatesGenericProjectFacts(text)) issues.push(issue("LINT-SKILL-003", "warning", skillPath, "task-specific skill content", "generic project facts duplicated", `${skillPath} appears to duplicate generic project facts.`, "Keep stack and project facts in generated project instructions rather than every skill."));
 	}
 }
+async function checkSkillPackArtifacts(rootDir, generatedFiles, issues) {
+	const expectedPaths = new Set(generatedFiles.filter((file) => file.target === "codex-workflow-skills" || file.target === "claude-workflow-skills").map((file) => file.path));
+	const actualPaths = await collectSkillFiles(rootDir);
+	for (const skillPath of actualPaths) {
+		const file = await readKnownFile(rootDir, skillPath);
+		if (!file.ok) continue;
+		const text = decodeUtf8(file.bytes);
+		if (text.includes(GENERATED_HEADER_MARKER) && !expectedPaths.has(skillPath)) issues.push(issue("LINT-SKILL-PACK-001", "warning", skillPath, "skill accounted for by selected packs or workflow flags", "orphan generated skill", `${skillPath} carries the generated-file header but is not selected by the current profile.`, "Remove the orphan generated skill or restore the matching pack or workflow intent."));
+		if (!expectedPaths.has(skillPath)) continue;
+		const root = SKILL_ROOTS.find((candidate) => skillPath.startsWith(`${candidate}/`));
+		if (root === void 0) continue;
+		for (const match of text.matchAll(/\brun\s+`([a-z0-9][a-z0-9-]*)`/gu)) {
+			const referencedSkill = match[1];
+			if (referencedSkill === void 0) continue;
+			const referencedPath = `${root}/${referencedSkill}/SKILL.md`;
+			if (!expectedPaths.has(referencedPath)) issues.push(issue("LINT-SKILL-REF-001", "error", skillPath, "references only to skills generated for this target", `dangling skill reference ${referencedSkill}`, `${skillPath} references a skill that is not generated for the same target.`, "Select the pack that provides the referenced skill or remove the dangling reference."));
+		}
+	}
+	for (const expectedPath of expectedPaths) if (!(await readKnownFile(rootDir, expectedPath)).ok) issues.push(issue("LINT-SKILL-PACK-002", "error", expectedPath, "skill generated by selected packs or workflow flags", "missing", `${expectedPath} is selected by the current profile but missing from disk.`, "Regenerate project artifacts after reviewing the selected skill packs."));
+}
+var REQUIRED_LOOP_SECTIONS = [
+	"Max Iterations",
+	"Stop Conditions",
+	"Approval Gate"
+];
+function loopSkillNameFromPath(skillPath) {
+	return skillPath.match(/^(?:\.agents|\.claude)\/skills\/([a-z0-9][a-z0-9-]*)\/SKILL\.md$/u)?.[1];
+}
+function extractMarkdownSection(text, heading) {
+	const lines = text.split("\n");
+	const headingLine = `## ${heading}`;
+	const start = lines.findIndex((line) => line.trim() === headingLine);
+	if (start === -1) return void 0;
+	const body = [];
+	for (let index = start + 1; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		if (/^#{1,6}\s/u.test(line)) break;
+		body.push(line);
+	}
+	return body.join("\n").trim();
+}
+async function checkLoopSkillStructure(rootDir, generatedFiles, issues) {
+	const loopPaths = generatedFiles.filter((file) => file.target === "codex-workflow-skills" || file.target === "claude-workflow-skills").map((file) => file.path).filter((skillPath) => {
+		const name = loopSkillNameFromPath(skillPath);
+		return name !== void 0 && isLoopSkillId(name);
+	});
+	for (const skillPath of loopPaths) {
+		const file = await readKnownFile(rootDir, skillPath);
+		if (!file.ok) continue;
+		const text = decodeUtf8(file.bytes);
+		for (const heading of REQUIRED_LOOP_SECTIONS) {
+			const body = extractMarkdownSection(text, heading);
+			if (body === void 0) {
+				issues.push(issue("LINT-SKILL-LOOP-001", "error", skillPath, `## ${heading} section present`, "missing", `${skillPath} is a loop skill but is missing the "## ${heading}" section.`, "Regenerate the automation loop skills; every loop skill must contain the Max Iterations, Stop Conditions, and Approval Gate sections."));
+				continue;
+			}
+			if (body === "") {
+				issues.push(issue("LINT-SKILL-LOOP-001", "error", skillPath, `non-empty "## ${heading}" section`, "empty", `${skillPath} has an empty "## ${heading}" section.`, "Regenerate the automation loop skills so each required section has content."));
+				continue;
+			}
+			if (heading === "Max Iterations" && !/\d/u.test(body)) issues.push(issue("LINT-SKILL-LOOP-001", "error", skillPath, "hard-coded integer iteration bound", "no integer bound", `${skillPath} does not state a hard-coded integer iteration bound in "## Max Iterations".`, "Regenerate the automation loop skills so the iteration bound is a hard-coded integer."));
+		}
+	}
+}
 async function checkSemanticWarnings(rootDir, files, issues) {
 	for (const file of files) {
 		const current = await readKnownFile(rootDir, file.path);
@@ -288,7 +661,7 @@ function mergeRecords(left, right) {
 	const result = { ...left };
 	for (const [key, value] of Object.entries(right)) {
 		const previous = result[key];
-		if (Array.isArray(previous) && Array.isArray(value)) result[key] = Array.from(new Set([...previous, ...value]));
+		if (Array.isArray(previous) && Array.isArray(value)) result[key] = Array.from(/* @__PURE__ */ new Set([...previous, ...value]));
 		else if (getRecord(previous) && getRecord(value)) result[key] = mergeRecords(previous, value);
 		else result[key] = value;
 	}
@@ -433,7 +806,7 @@ var SUBAGENT_ROOTS = [
 	".tabnine/agent/agents"
 ];
 var GENERATED_HEADER_MARKER = "Generated by Agent Profile Compiler";
-var TABNINE_UNSAFE_TOOL_NAMES = new Set([
+var TABNINE_UNSAFE_TOOL_NAMES = /* @__PURE__ */ new Set([
 	"run_shell_command",
 	"write_file",
 	"browser_agent",
@@ -443,7 +816,7 @@ var TABNINE_UNSAFE_TOOL_NAMES = new Set([
 	"http_request",
 	"network"
 ]);
-var CLAUDE_WRITE_TOOLS = new Set([
+var CLAUDE_WRITE_TOOLS = /* @__PURE__ */ new Set([
 	"Edit",
 	"Write",
 	"NotebookEdit"
@@ -468,7 +841,7 @@ async function checkSubagentArtifacts(input) {
 			if (isGenerated && !generatedSubagentPaths.has(relativePath) && !lockfileSubagentPaths.has(relativePath)) issues.push(issue("LINT-SUBAGENT-006", "warning", relativePath, "claimed by current compile output or lockfile", "orphan generated subagent", `${relativePath} carries the generated-file header but is not produced by the current profile and not recorded in ai-profile.lock.`, "Remove the orphan generated subagent file or restore the matching profile intent."));
 		}
 	}
-	if (profile.clients.tabnine.enabled && enabled.some((agent) => agent.toolScope === "read-only")) issues.push(issue("LINT-SUBAGENT-008", "info", ".tabnine/agent/settings.json", "experimental.enableAgents verifiable", "not verifiable", "Tabnine experimental.enableAgents cannot be verified because Agent Profile Compiler does not write .tabnine/agent/settings.json.", "Manually enable experimental.enableAgents in .tabnine/agent/settings.json to use the generated Tabnine subagent files."));
+	if (profile.clients.tabnine.enabled && Array.from(generatedSubagentPaths).some((subagentPath) => subagentPath.startsWith(".tabnine/agent/agents/"))) issues.push(issue("LINT-SUBAGENT-008", "info", ".tabnine/agent/settings.json", "experimental.enableAgents verifiable", "not verifiable", "Tabnine experimental.enableAgents cannot be verified because Agent Profile Compiler does not write .tabnine/agent/settings.json.", "Manually enable experimental.enableAgents in .tabnine/agent/settings.json to use the generated Tabnine subagent files."));
 }
 function checkCodexSubagentFile(relativePath, text, effective, issues) {
 	const sandboxMode = /^\s*sandbox_mode\s*=\s*"([^"]+)"/mu.exec(text)?.[1];
@@ -866,4 +1239,4 @@ function parseSkillOrSubagentName(text) {
 }
 
 export { runDoctor as r };
-//# sourceMappingURL=src3-BXch_OaJ.js.map
+//# sourceMappingURL=src3-DeQh3O0_.js.map