@agent-profile/web 0.1.5 → 0.3.0

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

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

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

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

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

@@ -1,5 +1,5 @@
-import { p as parseProfileYaml, c as compileProfile, s as safeOutputPath, a as containsSecretLikeLiteral, v as validateLockfileText, b as createLockfileFile, d as sha256Hex, n as normalizeSafety, e as deriveEffectivePermissions } from './projectContext-Cxsfz84C.js';
-import { readFile, readdir } from 'node:fs/promises';
+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 { lstat, readFile, readdir } from 'node:fs/promises';
 import path from 'node:path';
 
 //#region ../../packages/doctor/src/doctor.ts
@@ -35,15 +35,27 @@ async function runDoctor(request = {}) {
 	await checkSemanticWarnings(rootDir, compileResult.files, issues);
 	await checkGitignoreSecretHygiene(rootDir, issues);
 	const lockfile = await readAndValidateLockfile(rootDir, issues);
-	if (lockfile) await checkLockfileDrift({
+	const lockfileV2 = lockfile ? toLockfileV2View(lockfile) : void 0;
+	await checkRegionFiles(rootDir, compileResult.files, lockfileV2, issues);
+	if (lockfileV2) await checkLockfileDrift({
 		rootDir,
 		profileBytes: profileBytes.bytes,
 		templates: compileResult.templates,
 		files: compileResult.files,
-		lockfile,
+		lockfile: lockfileV2,
 		issues
 	});
 	await checkPermissionPosture(rootDir, profileResult.profile, issues);
+	await checkSubagentArtifacts({
+		rootDir,
+		profile: profileResult.profile,
+		effective: deriveEffectivePermissions(profileResult.profile),
+		generatedFiles: compileResult.files,
+		lockfile: lockfileV2,
+		issues
+	});
+	await checkLocalRuntimeGitignore(rootDir, issues);
+	await checkForeignSkillAndSubagentCollisions(rootDir, compileResult.files, lockfileV2, issues);
 	return toResult(issues);
 }
 async function checkGeneratedArtifactsExist(rootDir, files, issues) {
@@ -108,7 +120,8 @@ async function checkLockfileDrift(input) {
 	const expectedLockfileText = createLockfileFile({
 		profileBytes: input.profileBytes,
 		templates: input.templates,
-		files: input.files
+		files: input.files,
+		mixedOutputs: collectMixedOutputDescriptorsFromLockfile(input.lockfile)
 	});
 	const expectedLockfile = JSON.parse(Buffer.from(expectedLockfileText.bytes).toString("utf8"));
 	const currentProfileHash = sha256Hex(input.profileBytes);
@@ -117,16 +130,41 @@ async function checkLockfileDrift(input) {
 	compareOutputs(input.lockfile.outputs, expectedLockfile.outputs, input.issues);
 	const lockOutputsByKey = new Map(input.lockfile.outputs.map((output) => [outputKey(output), output]));
 	for (const output of expectedLockfile.outputs) {
-		const expectedHash = lockOutputsByKey.get(outputKey(output))?.sha256 ?? output.sha256;
+		if (output.ownership === "manual-owned") continue;
+		const lockOutput = lockOutputsByKey.get(outputKey(output));
 		const current = await readKnownFile(input.rootDir, output.path);
 		if (!current.ok) {
-			input.issues.push(issue("LINT-LOCK-006", "error", output.path, "generated file present", "missing", `${output.path} is listed in ai-profile.lock but is missing.`, "Run the compiler after reviewing generated file changes."));
+			const isLocalRuntime = LOCAL_RUNTIME_IGNORE_PATHS.some((line) => line.replace(/\/$/u, "") === output.path);
+			input.issues.push(issue("LINT-LOCK-006", isLocalRuntime ? "warning" : "error", output.path, "generated file present", "missing", `${output.path} is listed in ai-profile.lock but is missing${isLocalRuntime ? " (local-runtime path; regenerated by compile --write)" : ""}.`, isLocalRuntime ? "Run agent-profile compile --write to materialize the local-runtime file; it is intentionally not committed." : "Run the compiler after reviewing generated file changes."));
+			continue;
+		}
+		if (output.ownership === "mixed") {
+			const expectedHash = (lockOutput && lockOutput.ownership === "mixed" ? lockOutput.regions[0] : output.regions[0])?.sha256 ?? output.regions[0]?.sha256 ?? "";
+			const parsed = parseMixedFile(Buffer.from(current.bytes));
+			if (!parsed.ok) continue;
+			if (parsed.generatedInnerHash !== expectedHash) input.issues.push(issue("LINT-REGION-004", "error", output.path, expectedHash, parsed.generatedInnerHash, `${output.path} generated region hash differs from ai-profile.lock.`, "Run the compiler after reviewing the generated region diff."));
 			continue;
 		}
+		const expectedHash = lockOutput && lockOutput.ownership === "generated-owned" ? lockOutput.sha256 : output.sha256;
 		const currentHash = sha256Hex(current.bytes);
 		if (currentHash !== expectedHash) input.issues.push(issue("LINT-LOCK-007", "error", output.path, expectedHash, currentHash, `${output.path} bytes differ from ai-profile.lock.`, "Regenerate the file or lockfile after reviewing the generated diff."));
 	}
 }
+function collectMixedOutputDescriptorsFromLockfile(lockfile) {
+	const result = [];
+	for (const output of lockfile.outputs) {
+		if (output.ownership !== "mixed") continue;
+		const region = output.regions[0];
+		if (!region) continue;
+		result.push({
+			path: output.path,
+			target: region.target,
+			templateId: region.templateId,
+			regionHash: region.sha256
+		});
+	}
+	return result;
+}
 function compareTemplates(actual, expected, issues) {
 	const actualMap = new Map(actual.map((template) => [templateKey(template), template]));
 	const expectedMap = new Map(expected.map((template) => [templateKey(template), template]));
@@ -149,10 +187,20 @@ function compareOutputs(actual, expected, issues) {
 			issues.push(issue("LINT-LOCK-005", "error", expectedOutput.path, "output recorded in lockfile", "missing", `${expectedOutput.path} is missing from ai-profile.lock outputs.`, "Regenerate ai-profile.lock after reviewing generated output changes."));
 			continue;
 		}
-		if (actualOutput.templateId !== expectedOutput.templateId || actualOutput.sha256 !== expectedOutput.sha256) issues.push(issue("LINT-LOCK-005", "error", expectedOutput.path, `${expectedOutput.templateId}/${expectedOutput.sha256}`, `${actualOutput.templateId}/${actualOutput.sha256}`, `${expectedOutput.path} lockfile output metadata differs from current compiler output.`, "Regenerate generated outputs and ai-profile.lock after reviewing changes."));
+		const expectedSig = describeOutputSignature(expectedOutput);
+		const actualSig = describeOutputSignature(actualOutput);
+		if (expectedSig !== actualSig) issues.push(issue("LINT-LOCK-005", "error", expectedOutput.path, expectedSig, actualSig, `${expectedOutput.path} lockfile output metadata differs from current compiler output.`, "Regenerate generated outputs and ai-profile.lock after reviewing changes."));
 	}
 	for (const [key, actualOutput] of actualMap) if (!expectedMap.has(key)) issues.push(issue("LINT-LOCK-005", "error", actualOutput.path, "current compiler output", "extra lockfile output", `${actualOutput.path} is not emitted by the current compiler request.`, "Regenerate ai-profile.lock after reviewing target changes."));
 }
+function describeOutputSignature(output) {
+	if (output.ownership === "mixed") {
+		const region = output.regions[0];
+		return `mixed/${output.templateId}/${region?.sha256 ?? ""}`;
+	}
+	if (output.ownership === "manual-owned") return "manual-owned/manual/-";
+	return `generated/${output.templateId}/${output.sha256}`;
+}
 async function checkPermissionPosture(rootDir, profile, issues) {
 	const safety = normalizeSafety(profile);
 	const effective = deriveEffectivePermissions(profile);
@@ -379,6 +427,130 @@ function reportRuntimeUnverifiable(profile, issues) {
 	if (profile.clients.codex.enabled) issues.push(permissionIssue("LINT-PERM-006", "info", "codex-runtime", "verified runtime approval and sandbox flags", "not verifiable", "Codex runtime flags or user configuration may override project config.", "Verify the active Codex approval policy and sandbox mode before trusting runtime posture."));
 	if (profile.clients.claude.enabled) issues.push(permissionIssue("LINT-PERM-006", "info", "claude-runtime", "verified CLI permission mode and merged user settings", "not verifiable", "Claude CLI flags and user settings may override project settings.", "Verify the active Claude permission mode and settings scopes before trusting runtime posture."));
 }
+var SUBAGENT_ROOTS = [
+	".claude/agents",
+	".codex/agents",
+	".tabnine/agent/agents"
+];
+var GENERATED_HEADER_MARKER = "Generated by Agent Profile Compiler";
+var TABNINE_UNSAFE_TOOL_NAMES = new Set([
+	"run_shell_command",
+	"write_file",
+	"browser_agent",
+	"browser",
+	"open_url",
+	"fetch_url",
+	"http_request",
+	"network"
+]);
+var CLAUDE_WRITE_TOOLS = new Set([
+	"Edit",
+	"Write",
+	"NotebookEdit"
+]);
+async function checkSubagentArtifacts(input) {
+	const { rootDir, profile, effective, generatedFiles, lockfile, issues } = input;
+	const enabled = getEnabledSubagents(profile);
+	const generatedSubagentPaths = new Set(generatedFiles.filter((file) => file.target === "claude-subagents" || file.target === "codex-subagents" || file.target === "tabnine-subagents").map((file) => file.path));
+	const lockfileSubagentPaths = new Set((lockfile?.outputs ?? []).filter((output) => output.target === "claude-subagents" || output.target === "codex-subagents" || output.target === "tabnine-subagents").map((output) => output.path));
+	for (const agent of enabled) if (isSubagentBuiltinNameCollision(agent.name)) issues.push(issue("LINT-SUBAGENT-005", "warning", `/capabilities/delegation/subagents/agents/${agent.name}`, "name distinct from built-ins", "collides with built-in after normalization", `Subagent ${agent.name} collides with a documented built-in after hyphen/underscore normalization.`, "Rename the subagent to avoid shadowing client built-ins."));
+	for (const root of SUBAGENT_ROOTS) {
+		const files = await collectSubagentFilesUnder(rootDir, root);
+		for (const relativePath of files) {
+			const file = await readKnownFile(rootDir, relativePath);
+			if (!file.ok) continue;
+			const text = decodeUtf8(file.bytes);
+			const isGenerated = text.includes(GENERATED_HEADER_MARKER);
+			if (containsSecretLikeLiteral(text)) issues.push(issue("LINT-SUBAGENT-002", "error", relativePath, "no literal secret-like values", "secret-like value present", `${relativePath} contains a literal secret-like value.`, "Remove literal secrets from the subagent file; use environment variable references only."));
+			if (root === ".codex/agents") checkCodexSubagentFile(relativePath, text, effective, issues);
+			else if (root === ".claude/agents") checkClaudeSubagentFile(relativePath, text, effective, issues);
+			else if (root === ".tabnine/agent/agents") checkTabnineSubagentFile(relativePath, text, effective, issues);
+			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."));
+}
+function checkCodexSubagentFile(relativePath, text, effective, issues) {
+	const sandboxMode = /^\s*sandbox_mode\s*=\s*"([^"]+)"/mu.exec(text)?.[1];
+	if (sandboxMode === "danger-full-access") issues.push(issue("LINT-SUBAGENT-003", "error", relativePath, "sandboxed Codex subagent", "danger-full-access", `${relativePath} declares danger-full-access, which is never allowed.`, "Remove danger-full-access from the Codex subagent and use read-only or workspace-write instead."));
+	if (sandboxMode === "workspace-write" && effective.filesystem.write === "deny") issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "narrower than effectivePermissions.filesystem.write=deny", "workspace-write", `${relativePath} grants workspace-write while effectivePermissions deny filesystem writes.`, "Set sandbox_mode = \"read-only\" or tighten the subagent intent."));
+	if (/^\s*approval_policy\s*=\s*"never"/mu.test(text)) issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "interactive approval policy", "never", `${relativePath} declares approval_policy = "never", which is never allowed for generated Codex subagents.`, "Remove approval_policy = \"never\" from the Codex subagent."));
+}
+function checkClaudeSubagentFile(relativePath, text, effective, issues) {
+	const frontmatter = parseMarkdownFrontmatter(text);
+	if (frontmatter.permissionMode === "bypassPermissions") issues.push(issue("LINT-SUBAGENT-004", "error", relativePath, "non-bypass Claude permission mode", "bypassPermissions", `${relativePath} declares permissionMode: bypassPermissions, which is never allowed.`, "Remove bypassPermissions from the Claude subagent and use plan or default mode."));
+	const tools = parseClaudeToolList(frontmatter.tools);
+	if (tools.includes("Bash") && effective.shell.run === "deny") issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "tools narrower than effectivePermissions.shell.run=deny", "Bash tool granted", `${relativePath} grants the Bash tool while effectivePermissions.shell.run is deny.`, "Remove Bash from the Claude subagent tools list or relax shell.run from deny."));
+	if (tools.some((tool) => CLAUDE_WRITE_TOOLS.has(tool)) && effective.filesystem.write === "deny") issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "tools narrower than effectivePermissions.filesystem.write=deny", "Edit/Write tool granted", `${relativePath} grants write tools while effectivePermissions.filesystem.write is deny.`, "Remove Edit/Write from the Claude subagent tools list or relax filesystem.write from deny."));
+	if (tools.includes("WebFetch") && effective.network.external === "deny") issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "tools narrower than effectivePermissions.network.external=deny", "WebFetch tool granted", `${relativePath} grants the WebFetch tool while effectivePermissions.network.external is deny.`, "Remove WebFetch from the Claude subagent tools list or relax network.external from deny."));
+}
+function checkTabnineSubagentFile(relativePath, text, effective, issues) {
+	const tools = parseTabnineToolList(text, parseMarkdownFrontmatter(text).tools);
+	const unsafe = tools.filter((tool) => TABNINE_UNSAFE_TOOL_NAMES.has(tool));
+	if (unsafe.length > 0) issues.push(issue("LINT-SUBAGENT-007", "warning", relativePath, "read-only Tabnine subagent tools", `declares ${unsafe.join(", ")}`, `${relativePath} declares write/shell/browser/network-capable tool ${unsafe[0]} while Tabnine subagents are experimental/no-confirmation.`, "Restrict generated Tabnine subagents to read-only tools until safer Tabnine semantics are documented."));
+	if (tools.includes("write_file") && effective.filesystem.write !== "allow") issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "tools narrower than effectivePermissions.filesystem.write", "write_file tool granted", `${relativePath} grants write_file while effectivePermissions.filesystem.write is ${effective.filesystem.write}.`, "Remove write_file from the Tabnine subagent tools list or tighten effectivePermissions."));
+	if (tools.includes("run_shell_command") && effective.shell.run !== "allow") issues.push(issue("LINT-SUBAGENT-001", "error", relativePath, "tools narrower than effectivePermissions.shell.run", "run_shell_command tool granted", `${relativePath} grants run_shell_command while effectivePermissions.shell.run is ${effective.shell.run}.`, "Remove run_shell_command from the Tabnine subagent tools list or tighten effectivePermissions."));
+}
+function parseMarkdownFrontmatter(text) {
+	if (!text.startsWith("---\n")) return {};
+	const end = text.indexOf("\n---", 4);
+	if (end === -1) return {};
+	const block = text.slice(4, end);
+	const result = {};
+	for (const line of block.split("\n")) {
+		const match = /^([A-Za-z][A-Za-z0-9_]*)\s*:\s*(.*)$/u.exec(line);
+		if (!match) continue;
+		const [, key, rawValue] = match;
+		if (key === void 0) continue;
+		result[key] = (rawValue ?? "").trim();
+	}
+	return result;
+}
+function parseClaudeToolList(value) {
+	if (!value) return [];
+	return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function parseTabnineToolList(text, inlineValue) {
+	if (inlineValue && inlineValue.length > 0 && inlineValue !== "") {
+		if (inlineValue.startsWith("[") && inlineValue.endsWith("]")) return inlineValue.slice(1, -1).split(",").map((item) => item.trim().replace(/^["']|["']$/gu, "")).filter((item) => item.length > 0);
+	}
+	if (!text.startsWith("---\n")) return [];
+	const end = text.indexOf("\n---", 4);
+	if (end === -1) return [];
+	const block = text.slice(4, end).split("\n");
+	const tools = [];
+	let inToolsBlock = false;
+	for (const line of block) {
+		if (/^tools\s*:\s*$/u.test(line)) {
+			inToolsBlock = true;
+			continue;
+		}
+		if (inToolsBlock) {
+			const itemMatch = /^\s+-\s+(.+?)\s*$/u.exec(line);
+			if (itemMatch && itemMatch[1] !== void 0) {
+				tools.push(itemMatch[1].replace(/^["']|["']$/gu, ""));
+				continue;
+			}
+			if (/^\S/u.test(line)) inToolsBlock = false;
+		}
+	}
+	return tools;
+}
+async function collectSubagentFilesUnder(rootDir, relativeRoot) {
+	let entries;
+	try {
+		entries = await readdir(path.join(rootDir, relativeRoot), { withFileTypes: true });
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return [];
+		throw error;
+	}
+	const results = [];
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		results.push(`${relativeRoot}/${entry.name}`);
+	}
+	return results.sort();
+}
 async function collectSkillFiles(rootDir) {
 	const files = [];
 	for (const skillRoot of SKILL_ROOTS) await collectSkillFilesUnder(rootDir, skillRoot, files);
@@ -401,10 +573,17 @@ async function collectSkillFilesUnder(rootDir, relativeRoot, files) {
 async function readKnownFile(rootDir, relativePath) {
 	const safePath = safeOutputPath(relativePath);
 	if (safePath === ".env" || safePath.startsWith(".env.")) return { ok: false };
+	const absolutePath = path.join(rootDir, safePath);
+	try {
+		if ((await lstat(absolutePath)).isSymbolicLink()) return { ok: false };
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return { ok: false };
+		throw error;
+	}
 	try {
 		return {
 			ok: true,
-			bytes: await readFile(path.join(rootDir, safePath))
+			bytes: await readFile(absolutePath)
 		};
 	} catch (error) {
 		if (isNodeError(error) && error.code === "ENOENT") return { ok: false };
@@ -527,6 +706,164 @@ function decodeUtf8(bytes) {
 function isNodeError(error) {
 	return error instanceof Error && "code" in error;
 }
+var REGION_FILE_PATHS = ["AGENTS.md", "CLAUDE.md"];
+var LOCAL_RUNTIME_IGNORE_PATHS = [
+	".cce/",
+	".mcp.json",
+	".claude/settings.local.json",
+	".claude/worktrees/",
+	".codex/config.toml",
+	".codex/hooks.json"
+];
+async function checkRegionFiles(rootDir, generatedFiles, lockfile, issues) {
+	const ownershipByPath = new Map((lockfile?.outputs ?? []).map((output) => [output.path, output.ownership]));
+	for (const relativePath of REGION_FILE_PATHS) {
+		const current = await readKnownFile(rootDir, relativePath);
+		if (!current.ok) continue;
+		const bytes = Buffer.from(current.bytes);
+		const ownership = ownershipByPath.get(relativePath);
+		const allMarkers = hasAllRegionMarkers(bytes);
+		const anyMarkers = hasAnyRegionMarker(bytes);
+		const generatedFile = generatedFiles.find((file) => file.path === relativePath);
+		if (ownership === "mixed") {
+			const parsed = parseMixedFile(bytes);
+			if (!parsed.ok) {
+				const code = parsed.issues.some((item) => item.code === "duplicate-markers") ? "LINT-REGION-002" : "LINT-REGION-001";
+				issues.push(issue(code, "error", relativePath, "valid generated/manual region markers", "invalid region markers", `${relativePath} region markers are not valid for a mixed-ownership file.`, "Move or remove the file and re-run init --import --strategy regions --write."));
+				continue;
+			}
+			if (!parsed.generatedInner.toString("utf8").includes("If generated and manual instructions conflict, follow the manual project instructions unless they would weaken safety, privacy, or permission limits. Safety, privacy, and explicit deny rules always win.")) issues.push(issue("LINT-REGION-003", "warning", relativePath, "required instruction precedence text in generated region", "missing precedence text", `${relativePath} generated region is missing the required precedence sentence.`, "Re-run compile --write to refresh the generated region."));
+			continue;
+		}
+		if (anyMarkers && !allMarkers) {
+			issues.push(issue("LINT-REGION-001", "error", relativePath, "valid generated/manual region markers", "partial region markers", `${relativePath} contains partial region markers.`, "Move or remove the file and re-run init --import --strategy regions --write; the compiler will not auto-repair markers."));
+			continue;
+		}
+		if (allMarkers) {
+			const parsed = parseMixedFile(bytes);
+			if (!parsed.ok) {
+				const code = parsed.issues.some((item) => item.code === "duplicate-markers") ? "LINT-REGION-002" : "LINT-REGION-001";
+				issues.push(issue(code, "error", relativePath, "valid generated/manual region markers", "invalid region markers", `${relativePath} region markers are not valid.`, "Move or remove the file and re-run init --import --strategy regions --write."));
+			}
+			continue;
+		}
+		if (generatedFile && ownership !== "generated-owned" && !allMarkers && hasLegacyGeneratedMarker(bytes)) {
+			issues.push(issue("LINT-OWN-002", "warning", relativePath, "lockfile-owned generated file", "generated-looking file without lockfile ownership", `${relativePath} contains the legacy generated marker but is not lockfile-owned.`, "Run init --import --strategy regions --write to adopt the file into mixed ownership, or remove and re-run compile --write."));
+			continue;
+		}
+		if (generatedFile && ownership !== "generated-owned" && !allMarkers) issues.push(issue("LINT-OWN-001", "error", relativePath, "lockfile-owned or mixed ownership", "unknown ownership conflicts with generated output", `${relativePath} exists but ownership cannot be proven; the compiler will refuse to write it.`, "Run init --import --strategy regions --write to adopt the file into mixed ownership."));
+	}
+}
+async function checkLocalRuntimeGitignore(rootDir, issues) {
+	const gitignore = await readKnownFile(rootDir, ".gitignore");
+	const lines = gitignore.ok ? decodeUtf8(gitignore.bytes).split(/\r?\n/u).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")) : [];
+	for (const recommended of LOCAL_RUNTIME_IGNORE_PATHS) {
+		if (!await pathExists(rootDir, recommended.replace(/\/$/u, ""))) continue;
+		if (!isIgnoreLinePresent(lines, recommended)) issues.push(issue("LINT-GITIGNORE-002", "warning", ".gitignore", `ignore line for ${recommended}`, "missing", `${recommended} exists locally but is not listed in .gitignore.`, "Run agent-profile init --update-gitignore --write to add recommended ignore lines."));
+	}
+}
+async function pathExists(rootDir, relativePath) {
+	try {
+		safeOutputPath(relativePath);
+	} catch {
+		return false;
+	}
+	try {
+		const { lstat } = await import('node:fs/promises');
+		await lstat(path.join(rootDir, relativePath));
+		return true;
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function isIgnoreLinePresent(lines, target) {
+	const trimmed = target.replace(/\/$/u, "");
+	return lines.some((line) => {
+		return line.replace(/^\//u, "").replace(/\/$/u, "") === trimmed;
+	});
+}
+async function checkForeignSkillAndSubagentCollisions(rootDir, generatedFiles, lockfile, issues) {
+	const ownedPaths = new Set((lockfile?.outputs ?? []).map((output) => output.path));
+	const generatedSkillByName = /* @__PURE__ */ new Map();
+	const generatedSubagentByName = /* @__PURE__ */ new Map();
+	const pushByName = (map, name, entry) => {
+		const list = map.get(name) ?? [];
+		list.push(entry);
+		map.set(name, list);
+	};
+	for (const file of generatedFiles) {
+		const name = parseSkillOrSubagentName(decodeUtf8(file.bytes));
+		if (!name) continue;
+		if (file.target === "codex-workflow-skills" || file.target === "claude-workflow-skills") pushByName(generatedSkillByName, name, {
+			path: file.path,
+			runtime: pathRuntime(file.path)
+		});
+		if (file.target === "claude-subagents" || file.target === "codex-subagents" || file.target === "tabnine-subagents") pushByName(generatedSubagentByName, name, {
+			path: file.path,
+			runtime: pathRuntime(file.path)
+		});
+	}
+	const skillFiles = await collectSkillFiles(rootDir);
+	for (const skillPath of skillFiles) {
+		if (ownedPaths.has(skillPath)) continue;
+		const generatedPath = generatedFiles.find((file) => file.path === skillPath);
+		const file = await readKnownFile(rootDir, skillPath);
+		if (!file.ok) continue;
+		const name = parseSkillOrSubagentName(decodeUtf8(file.bytes));
+		if (generatedPath) {
+			issues.push(issue("LINT-OWN-001", "error", skillPath, "lockfile-owned generated skill", "foreign skill at generated path", `${skillPath} exists at a generated output path but is not lockfile-owned.`, "Move or rename the existing skill, or run compile --write --force only after reviewing the diff."));
+			continue;
+		}
+		if (name && generatedSkillByName.has(name)) {
+			const others = generatedSkillByName.get(name).filter((entry) => entry.path !== skillPath);
+			if (others.length > 0) {
+				const foreignRuntime = pathRuntime(skillPath);
+				const matching = others.find((entry) => entry.runtime !== void 0 && entry.runtime === foreignRuntime);
+				const referencePath = (matching ?? others[0]).path;
+				const severity = matching ? "error" : "warning";
+				issues.push(issue("LINT-SKILL-009", severity, skillPath, "skill name distinct from generated skills", `name collides with generated ${referencePath}`, `${skillPath} declares skill name ${name}, which collides with generated ${referencePath}${matching ? ` for the ${matching.runtime} runtime` : ""}.`, matching ? `Rename the foreign skill; both files target the ${matching.runtime} runtime and would load the same name.` : "Rename the foreign skill or move it to a different name to avoid runtime collision."));
+			}
+		}
+	}
+	const subagentFiles = [];
+	for (const root of SUBAGENT_ROOTS) {
+		const files = await collectSubagentFilesUnder(rootDir, root);
+		for (const file of files) subagentFiles.push(file);
+	}
+	for (const subagentPath of subagentFiles) {
+		if (ownedPaths.has(subagentPath)) continue;
+		const generatedPath = generatedFiles.find((file) => file.path === subagentPath);
+		const file = await readKnownFile(rootDir, subagentPath);
+		if (!file.ok) continue;
+		const name = parseSkillOrSubagentName(decodeUtf8(file.bytes));
+		if (generatedPath) {
+			issues.push(issue("LINT-OWN-001", "error", subagentPath, "lockfile-owned generated subagent", "foreign subagent at generated path", `${subagentPath} exists at a generated output path but is not lockfile-owned.`, "Move or rename the existing subagent, or run compile --write --force only after reviewing the diff."));
+			continue;
+		}
+		if (name && generatedSubagentByName.has(name)) {
+			const others = generatedSubagentByName.get(name).filter((entry) => entry.path !== subagentPath);
+			if (others.length > 0) {
+				const foreignRuntime = pathRuntime(subagentPath);
+				const matching = others.find((entry) => entry.runtime !== void 0 && entry.runtime === foreignRuntime);
+				const referencePath = (matching ?? others[0]).path;
+				const severity = matching ? "error" : "warning";
+				issues.push(issue("LINT-SUBAGENT-009", severity, subagentPath, "subagent name distinct from generated subagents", `name collides with generated ${referencePath}`, `${subagentPath} declares subagent name ${name}, which collides with generated ${referencePath}${matching ? ` for the ${matching.runtime} runtime` : ""}.`, matching ? `Rename the foreign subagent; both files target the ${matching.runtime} runtime and would load the same name.` : "Rename the foreign subagent to avoid runtime collision."));
+			}
+		}
+	}
+}
+function pathRuntime(filePath) {
+	if (filePath.startsWith(".agents/skills/") || filePath.startsWith(".codex/agents/")) return "codex";
+	if (filePath.startsWith(".claude/skills/") || filePath.startsWith(".claude/agents/")) return "claude";
+	if (filePath.startsWith(".tabnine/agent/agents/")) return "tabnine";
+}
+function parseSkillOrSubagentName(text) {
+	const fm = parseMarkdownFrontmatter(text);
+	if (typeof fm.name === "string" && fm.name.length > 0) return fm.name;
+	const tomlMatch = /^\s*name\s*=\s*"([^"]+)"/mu.exec(text);
+	if (tomlMatch && tomlMatch[1]) return tomlMatch[1];
+}
 
 export { runDoctor as r };
-//# sourceMappingURL=src3-jm480tTA.js.map
+//# sourceMappingURL=src3-BXch_OaJ.js.map