@lousy-agents/cli 5.18.2 → 5.19.1

package/dist/index.js

@@ -3032,7 +3032,7 @@ exports.basename = (path, { windows } = {}) => {
 
 
 },
-7015(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+6567(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -11689,11 +11689,11 @@ const $ZodXor = /*@__PURE__*/ (/* unused pure expression or super */ null && (co
 })));
 const $ZodDiscriminatedUnion = 
 /*@__PURE__*/
-(/* unused pure expression or super */ null && (core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
+$constructor("$ZodDiscriminatedUnion", (inst, def) => {
     def.inclusive = false;
     $ZodUnion.init(inst, def);
     const _super = inst._zod.parse;
-    util.defineLazy(inst._zod, "propValues", () => {
+    defineLazy(inst._zod, "propValues", () => {
         const propValues = {};
         for (const option of def.options) {
             const pv = option._zod.propValues;
@@ -11709,7 +11709,7 @@ const $ZodDiscriminatedUnion =
         }
         return propValues;
     });
-    const disc = util.cached(() => {
+    const disc = util_cached(() => {
         const opts = def.options;
         const map = new Map();
         for (const o of opts) {
@@ -11727,7 +11727,7 @@ const $ZodDiscriminatedUnion =
     });
     inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
-        if (!util.isObject(input)) {
+        if (!util_isObject(input)) {
             payload.issues.push({
                 code: "invalid_type",
                 expected: "object",
@@ -11760,7 +11760,7 @@ const $ZodDiscriminatedUnion =
         });
         return payload;
     };
-})));
+});
 const $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -15937,17 +15937,17 @@ function xor(options, params) {
         ...util.normalizeParams(params),
     });
 }
-const ZodDiscriminatedUnion = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
+const ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
     ZodUnion.init(inst, def);
-    core.$ZodDiscriminatedUnion.init(inst, def);
-})));
+    $ZodDiscriminatedUnion.init(inst, def);
+});
 function discriminatedUnion(discriminator, options, params) {
     // const [options, params] = args;
     return new ZodDiscriminatedUnion({
         type: "union",
         options,
         discriminator,
-        ...util.normalizeParams(params),
+        ...normalizeParams(params),
     });
 }
 const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
@@ -27697,13 +27697,13 @@ const PackageJsonSchema = schemas_object({
             "shared"
         ]
     },
-    // Doctor-only skill locations
+    // Additional skill roots (SKILL.md convention, no alternate layout documented)
     {
         id: "skill-pi",
         path: ".pi/skills",
         matchKind: "directory-prefix",
         primaryConstruct: "skill",
-        lintTarget: "none",
+        lintTarget: "skills",
         harnessHints: [
             "pi"
         ]
@@ -27713,7 +27713,7 @@ const PackageJsonSchema = schemas_object({
         path: ".pi/prompts",
         matchKind: "directory-prefix",
         primaryConstruct: "skill",
-        lintTarget: "none",
+        lintTarget: "skills",
         harnessHints: [
             "pi"
         ]
@@ -27833,13 +27833,13 @@ const PackageJsonSchema = schemas_object({
         ],
         instructionFormat: "claude-md"
     },
-    // Doctor-only construct locations
+    // Subagent lint root
     {
         id: "subagent-claude",
         path: ".claude/agents",
         matchKind: "directory-prefix",
         primaryConstruct: "subagent",
-        lintTarget: "none",
+        lintTarget: "subagents",
         harnessHints: [
             "claude"
         ]
@@ -27875,11 +27875,14 @@ const PackageJsonSchema = schemas_object({
  * Normalizes a repo-relative path for catalog matching.
  * Collapses `.` / `..` segments. Returns "" when the path is absolute or
  * escapes the repository root — callers treat "" as non-matching.
- */ function normalizeRepoRelativePath(path) {
-    const normalized = path.replaceAll("\\", "/");
+ */ function isAbsoluteRepoPath(normalized) {
     // POSIX absolute, UNC-style leading slash after backslash conversion,
     // and Windows drive-letter absolute (C:/..., d:\...).
-    if (normalized.startsWith("/") || /^[A-Za-z]:(\/|$)/.test(normalized)) {
+    return normalized.startsWith("/") || /^[A-Za-z]:(\/|$)/.test(normalized);
+}
+function normalizeRepoRelativePath(path) {
+    const normalized = path.replaceAll("\\", "/");
+    if (isAbsoluteRepoPath(normalized)) {
         return "";
     }
     const resolved = [];
@@ -27887,10 +27890,10 @@ const PackageJsonSchema = schemas_object({
         if (segment === "" || segment === ".") {
             continue;
         }
+        if (segment === ".." && resolved.length === 0) {
+            return "";
+        }
         if (segment === "..") {
-            if (resolved.length === 0) {
-                return "";
-            }
             resolved.pop();
             continue;
         }
@@ -27938,14 +27941,15 @@ function constructTypesForPath(path, catalog = AGENTIC_LOCATION_CATALOG) {
     if (!best) {
         return [];
     }
-    if (best.secondaryConstructs && best.secondaryConstructs.length > 0) {
+    const secondary = best.secondaryConstructs ?? [];
+    if (secondary.length === 0) {
         return [
-            best.primaryConstruct,
-            ...best.secondaryConstructs
+            best.primaryConstruct
         ];
     }
     return [
-        best.primaryConstruct
+        best.primaryConstruct,
+        ...secondary
     ];
 }
 function lintTargetEntries(target, catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
@@ -27957,8 +27961,14 @@ function skillDirectoryRoots(catalog = agentic_location_catalog_AGENTIC_LOCATION
 function agentDirectoryRoots(catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
     return lintTargetEntries("agents", catalog).filter((entry)=>entry.matchKind === "directory-prefix").map((entry)=>entry.path);
 }
+function subagentDirectoryRoots(catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
+    return lintTargetEntries("subagents", catalog).filter((entry)=>entry.matchKind === "directory-prefix").map((entry)=>entry.path);
+}
+function isHookConfigEntry(entry) {
+    return entry.matchKind === "exact" && entry.hookPlatform != null;
+}
 function hookConfigPaths(catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
-    return lintTargetEntries("hooks", catalog).filter((entry)=>entry.matchKind === "exact" && entry.hookPlatform != null).map((entry)=>({
+    return lintTargetEntries("hooks", catalog).filter(isHookConfigEntry).map((entry)=>({
             relativePath: entry.path,
             platform: entry.hookPlatform
         }));
@@ -30372,26 +30382,74 @@ function parseRawEdges(content) {
     return edges;
 }
 
-;// CONCATENATED MODULE: ../doctor/src/gateways/mcp-config.ts
-
-
-const MAX_MCP_CONFIG_BYTES = 1_048_576;
-const MCP_CONFIG_SOURCES = [
+;// CONCATENATED MODULE: ../core/src/entities/mcp-config-source.ts
+/**
+ * Canonical list of MCP server configuration file locations.
+ * Shared by doctor (inventory enumeration) and lint (mcp-servers target) so
+ * the two consumers cannot drift on where MCP servers are declared.
+ *
+ * Deliberately kept separate from AGENTIC_LOCATION_CATALOG: one MCP config
+ * file can declare many servers, so the one-path-to-one-construct model the
+ * catalog/matchers use for skills, agents, hooks, and instructions does not
+ * fit. This list is the single source of truth for MCP config paths instead.
+ */ const MCP_CONFIG_SOURCES = [
     {
         relPath: ".mcp.json",
-        harness: "shared"
+        harnessHint: "shared"
     },
     {
         relPath: ".vscode/mcp.json",
-        harness: "copilot"
+        harnessHint: "copilot"
     }
 ];
+
+;// CONCATENATED MODULE: ../doctor/src/gateways/mcp-config.ts
+
+
+
+const MAX_MCP_CONFIG_BYTES = 1_048_576;
 const McpServerEntrySchema = schemas_object({
     type: schemas_string().optional(),
     transport: schemas_string().optional()
 }).passthrough();
+/**
+ * Property names that must never be used as MCP server names: assigning
+ * them via a plain object key (as zod's `record()` does when reconstructing
+ * parsed output) triggers JavaScript's `__proto__` magic setter instead of
+ * creating an own property, silently dropping the entry. Rejected explicitly
+ * so a config declaring one of these names is treated as invalid instead of
+ * silently under-inventoried.
+ */ const RESERVED_SERVER_NAMES = [
+    "__proto__",
+    "constructor",
+    "prototype"
+];
+const SERVER_MAP_FIELDS = [
+    "mcpServers",
+    "servers"
+];
+function hasReservedServerName(parsed) {
+    if (typeof parsed !== "object" || parsed === null) {
+        return false;
+    }
+    for (const field of SERVER_MAP_FIELDS){
+        const servers = parsed[field];
+        if (typeof servers !== "object" || servers === null) {
+            continue;
+        }
+        if (RESERVED_SERVER_NAMES.some((name)=>Object.hasOwn(servers, name))) {
+            return true;
+        }
+    }
+    return false;
+}
+// Accepts both Claude Code's `.mcp.json` convention (`mcpServers`) and VS
+// Code's `.vscode/mcp.json` convention (`servers`) regardless of which
+// source file is being read, since either config file could in practice
+// use either key.
 const McpConfigSchema = schemas_object({
-    mcpServers: schemas_record(schemas_string(), McpServerEntrySchema).optional()
+    mcpServers: schemas_record(schemas_string(), McpServerEntrySchema).optional(),
+    servers: schemas_record(schemas_string(), McpServerEntrySchema).optional()
 }).passthrough();
 async function readMcpServersFromSource(repoRoot, source) {
     let content;
@@ -30406,13 +30464,20 @@ async function readMcpServersFromSource(repoRoot, source) {
     } catch  {
         return [];
     }
+    if (hasReservedServerName(raw)) {
+        return [];
+    }
     const result = McpConfigSchema.safeParse(raw);
-    if (!result.success || result.data.mcpServers === undefined) {
+    if (!result.success) {
         return [];
     }
-    return Object.entries(result.data.mcpServers).map(([serverName, entry])=>({
+    const servers = {
+        ...result.data.mcpServers ?? {},
+        ...result.data.servers ?? {}
+    };
+    return Object.entries(servers).map(([serverName, entry])=>({
             serverName,
-            harness: source.harness,
+            harness: source.harnessHint,
             path: source.relPath,
             ...entry.transport !== undefined ? {
                 transport: entry.transport
@@ -32855,6 +32920,82 @@ function createInitHooksCommand(useCase) {
     }
 }
 
+;// CONCATENATED MODULE: ../core/src/gateways/markdown-file-discovery.ts
+/**
+ * Shared recursive markdown-file discovery for lint gateways that scan a
+ * catalog root directory for `.md` files (agents, subagents). Guards
+ * against path traversal and symlink escapes, and caps recursion depth to
+ * avoid stack exhaustion on pathologically deep directory trees.
+ */ 
+
+/** Maximum subdirectory nesting the walk will descend into. */ const MAX_WALK_DEPTH = 32;
+function isUnsafeEntryName(name) {
+    return name.includes("..") || name.includes("/") || name.includes("\\");
+}
+function isWithinResolvedRoot(resolvedRootDir, absoluteEntryPath) {
+    const resolvedPath = (0,external_node_path_.resolve)(absoluteEntryPath);
+    const rel = (0,external_node_path_.relative)(resolvedRootDir, resolvedPath);
+    return !rel.startsWith("..") && !rel.startsWith(external_node_path_.sep);
+}
+async function rootExists(targetDir, rootDir) {
+    try {
+        return await file_system_utils_pathExistsWithinRoot(targetDir, rootDir);
+    } catch  {
+        return false;
+    }
+}
+function isDiscoverableMarkdownFile(entry, name) {
+    return entry.isFile() && name.endsWith(".md");
+}
+async function collectEntryFiles(targetDir, resolvedRootDir, dir, depth, entry, deriveName) {
+    const name = entry.name;
+    if (isUnsafeEntryName(name)) {
+        return [];
+    }
+    const entryPath = (0,external_node_path_.join)(dir, name);
+    const absoluteEntryPath = (0,external_node_path_.join)(targetDir, entryPath);
+    if (!isWithinResolvedRoot(resolvedRootDir, absoluteEntryPath)) {
+        return [];
+    }
+    if (entry.isSymbolicLink()) {
+        return [];
+    }
+    if (entry.isDirectory()) {
+        return walkMarkdownFiles(targetDir, resolvedRootDir, entryPath, depth + 1, deriveName);
+    }
+    if (!isDiscoverableMarkdownFile(entry, name)) {
+        return [];
+    }
+    return [
+        {
+            filePath: absoluteEntryPath,
+            name: deriveName(name)
+        }
+    ];
+}
+async function walkMarkdownFiles(targetDir, resolvedRootDir, dir, depth, deriveName) {
+    if (depth > MAX_WALK_DEPTH) {
+        return [];
+    }
+    const entries = await file_system_utils_listDirectoryWithinRoot(targetDir, dir);
+    const discovered = [];
+    for (const entry of entries){
+        const files = await collectEntryFiles(targetDir, resolvedRootDir, dir, depth, entry, deriveName);
+        discovered.push(...files);
+    }
+    return discovered;
+}
+/**
+ * Recursively discovers `.md` files under `rootDir` (relative to
+ * `targetDir`). `deriveName` maps a filename to the construct name callers
+ * use to identify the file (e.g. stripping `.md` or `.agent.md`).
+ */ async function discoverMarkdownFiles(targetDir, rootDir, deriveName) {
+    if (!await rootExists(targetDir, rootDir)) {
+        return [];
+    }
+    return walkMarkdownFiles(targetDir, (0,external_node_path_.resolve)(targetDir, rootDir), rootDir, 0, deriveName);
+}
+
 ;// CONCATENATED MODULE: ../core/src/gateways/agent-lint-gateway.ts
 /**
  * Gateway for agent lint file system operations.
@@ -32863,6 +33004,7 @@ function createInitHooksCommand(useCase) {
 
 
 
+
 /** Maximum agent file size: 1 MB */ const MAX_AGENT_FILE_BYTES = 1_048_576;
 /** Catalog agent roots converted to OS-native relative paths. */ const AGENT_DIRECTORIES = agentDirectoryRoots().map((root)=>(0,external_node_path_.join)(...root.split("/")));
 /**
@@ -32877,51 +33019,11 @@ function createInitHooksCommand(useCase) {
         return agents;
     }
     async discoverAgentsInDir(targetDir, agentsDir) {
-        try {
-            if (!await file_system_utils_pathExistsWithinRoot(targetDir, agentsDir)) {
-                return [];
-            }
-        } catch  {
-            return [];
-        }
-        const resolvedAgentsDir = (0,external_node_path_.resolve)(targetDir, agentsDir);
-        const agents = [];
-        const walk = async (dir)=>{
-            const entries = await file_system_utils_listDirectoryWithinRoot(targetDir, dir);
-            for (const entry of entries){
-                const name = entry.name;
-                if (name.includes("..") || name.includes("/") || name.includes("\\")) {
-                    continue;
-                }
-                const entryPath = (0,external_node_path_.join)(dir, name);
-                const absoluteEntryPath = (0,external_node_path_.join)(targetDir, entryPath);
-                const resolvedPath = (0,external_node_path_.resolve)(absoluteEntryPath);
-                const rel = (0,external_node_path_.relative)(resolvedAgentsDir, resolvedPath);
-                if (rel.startsWith("..") || rel.startsWith(external_node_path_.sep)) {
-                    continue;
-                }
-                if (entry.isSymbolicLink()) {
-                    continue;
-                }
-                if (entry.isDirectory()) {
-                    await walk(entryPath);
-                    continue;
-                }
-                if (!entry.isFile()) {
-                    continue;
-                }
-                if (!name.endsWith(".md")) {
-                    continue;
-                }
-                const agentName = name.endsWith(".agent.md") ? (0,external_node_path_.basename)(name, ".agent.md") : (0,external_node_path_.basename)(name, ".md");
-                agents.push({
-                    filePath: absoluteEntryPath,
-                    agentName
-                });
-            }
-        };
-        await walk(agentsDir);
-        return agents;
+        const files = await discoverMarkdownFiles(targetDir, agentsDir, (name)=>name.endsWith(".agent.md") ? (0,external_node_path_.basename)(name, ".agent.md") : (0,external_node_path_.basename)(name, ".md"));
+        return files.map((file)=>({
+                filePath: file.filePath,
+                agentName: file.name
+            }));
     }
     async readAgentFileContent(filePath) {
         return readFileNoFollow(filePath, MAX_AGENT_FILE_BYTES);
@@ -32945,11 +33047,28 @@ function createInitHooksCommand(useCase) {
 
 /** Maximum hook config file size: 1 MB */ const MAX_CONFIG_FILE_BYTES = 1_048_576;
 /** Matches the Copilot hook key `"preToolUse":` to detect hook section presence */ const COPILOT_HOOK_PATTERN = /"preToolUse"\s*:/;
-/** Matches the Claude hook key `"PreToolUse":` to detect hook section presence */ const CLAUDE_HOOK_PATTERN = /"PreToolUse"\s*:/;
+/** Matches the Claude hook key `"hooks":` to detect hook section presence */ const CLAUDE_HOOK_PATTERN = /"hooks"\s*:/;
 /** Catalog hook config paths converted to OS-native relative paths. */ const HOOK_CONFIG_PATHS = hookConfigPaths().map((entry)=>({
         relativePath: (0,external_node_path_.join)(...entry.relativePath.split("/")),
         platform: entry.platform
     }));
+/**
+ * Structural check for a `hooks` object on a parsed settings file.
+ *
+ * Uses `Object.hasOwn` so a `hooks` key inherited from the prototype chain
+ * cannot make an unrelated file look like a hook config. Arrays are rejected
+ * even though `typeof [] === "object"`, because a hooks section is keyed by
+ * event name.
+ */ function hasHooksSection(parsed) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return false;
+    }
+    if (!Object.hasOwn(parsed, "hooks")) {
+        return false;
+    }
+    const hooks = parsed.hooks;
+    return hooks !== null && typeof hooks === "object" && !Array.isArray(hooks);
+}
 /**
  * File system implementation of the hook config lint gateway.
  */ class FileSystemHookConfigGateway {
@@ -32996,14 +33115,24 @@ function createInitHooksCommand(useCase) {
         return readFileNoFollow(filePath, MAX_CONFIG_FILE_BYTES);
     }
     /**
-     * Lightweight heuristic to check if a file may contain a pre-tool-use hooks section.
-     * Uses substring search rather than JSON.parse so that files with invalid JSON are
-     * still discovered and surfaced as `hook/invalid-json` diagnostics by the use case.
+     * Checks whether a file may contain a hooks section.
+     *
+     * Claude Code settings files carry much more than hooks, and the `hooks`
+     * key is generic enough to appear inside unrelated string values, so a
+     * parsed structural check is used when the JSON is well-formed. Malformed
+     * JSON falls back to a substring search so the file is still discovered
+     * and surfaced as a `hook/invalid-json` diagnostic by the use case.
      */ mayContainHookSection(content, platform) {
         if (platform === "copilot") {
             return COPILOT_HOOK_PATTERN.test(content);
         }
-        return CLAUDE_HOOK_PATTERN.test(content);
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        } catch  {
+            return CLAUDE_HOOK_PATTERN.test(content);
+        }
+        return hasHooksSection(parsed);
     }
 }
 /**
@@ -52594,6 +52723,120 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
     return new RemarkMarkdownAstGateway();
 }
 
+;// CONCATENATED MODULE: ../core/src/gateways/mcp-lint-gateway.ts
+/**
+ * Gateway for MCP server config file system operations.
+ * Discovers MCP server config files at the shared MCP_CONFIG_SOURCES paths.
+ */ 
+
+
+/** Maximum MCP config file size: 1 MB */ const MAX_MCP_CONFIG_FILE_BYTES = 1_048_576;
+/** Catalog MCP config paths converted to OS-native relative paths. */ const MCP_CONFIG_RELATIVE_PATHS = MCP_CONFIG_SOURCES.map((source)=>(0,external_node_path_.join)(...source.relPath.split("/")));
+const SKIPPABLE_PATH_ERROR_PREFIXES = [
+    "Resolved path is outside target directory:",
+    "Path contains symbolic link:"
+];
+function isSkippablePathError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return SKIPPABLE_PATH_ERROR_PREFIXES.some((prefix)=>error.message.startsWith(prefix));
+}
+async function pathExistsSafely(targetDir, relativePath) {
+    try {
+        return await file_system_utils_pathExistsWithinRoot(targetDir, relativePath);
+    } catch  {
+        return false;
+    }
+}
+async function resolveConfigPathOrNull(targetDir, relativePath) {
+    try {
+        return await file_system_utils_resolveSafePath(targetDir, relativePath);
+    } catch (error) {
+        if (isSkippablePathError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Resolves a config path within the target directory, returning null when the
+ * path is missing or escapes the root via traversal/symlink.
+ */ async function tryResolveConfigPath(targetDir, relativePath) {
+    if (!await pathExistsSafely(targetDir, relativePath)) {
+        return null;
+    }
+    return resolveConfigPathOrNull(targetDir, relativePath);
+}
+/**
+ * File system implementation of the MCP server lint gateway.
+ */ class FileSystemMcpServersLintGateway {
+    async discoverMcpConfigFiles(targetDir) {
+        const discovered = [];
+        for (const relativePath of MCP_CONFIG_RELATIVE_PATHS){
+            const safePath = await tryResolveConfigPath(targetDir, relativePath);
+            if (safePath === null) {
+                continue;
+            }
+            discovered.push({
+                filePath: safePath,
+                relativePath
+            });
+        }
+        return discovered;
+    }
+    async readFileContent(filePath) {
+        return readFileNoFollow(filePath, MAX_MCP_CONFIG_FILE_BYTES);
+    }
+}
+/**
+ * Creates and returns the default MCP server lint gateway.
+ */ function createMcpServersLintGateway() {
+    return new FileSystemMcpServersLintGateway();
+}
+
+;// CONCATENATED MODULE: ../core/src/gateways/subagent-lint-gateway.ts
+/**
+ * Gateway for subagent lint file system operations.
+ * Discovers Claude Code subagent files and parses YAML frontmatter.
+ */ 
+
+
+
+
+/** Maximum subagent file size: 1 MB */ const MAX_SUBAGENT_FILE_BYTES = 1_048_576;
+/** Catalog subagent roots converted to OS-native relative paths. */ const SUBAGENT_DIRECTORIES = subagentDirectoryRoots().map((root)=>(0,external_node_path_.join)(...root.split("/")));
+/**
+ * File system implementation of the subagent lint gateway.
+ */ class FileSystemSubagentLintGateway {
+    async discoverSubagents(targetDir) {
+        const subagents = [];
+        for (const subagentsDir of SUBAGENT_DIRECTORIES){
+            const discovered = await this.discoverSubagentsInDir(targetDir, subagentsDir);
+            subagents.push(...discovered);
+        }
+        return subagents;
+    }
+    async discoverSubagentsInDir(targetDir, subagentsDir) {
+        const files = await discoverMarkdownFiles(targetDir, subagentsDir, (name)=>(0,external_node_path_.basename)(name, ".md"));
+        return files.map((file)=>({
+                filePath: file.filePath,
+                subagentName: file.name
+            }));
+    }
+    async readSubagentFileContent(filePath) {
+        return readFileNoFollow(filePath, MAX_SUBAGENT_FILE_BYTES);
+    }
+    parseFrontmatter(content) {
+        return parseFrontmatter(content);
+    }
+}
+/**
+ * Creates and returns the default subagent lint gateway.
+ */ function createSubagentLintGateway() {
+    return new FileSystemSubagentLintGateway();
+}
+
 ;// CONCATENATED MODULE: ../core/src/entities/lint-rules.ts
 /**
  * Lint rule registry entity.
@@ -52609,10 +52852,31 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
         "agent/invalid-description": "error",
         "agent/invalid-field": "warn"
     },
+    subagents: {
+        "subagent/missing-frontmatter": "error",
+        "subagent/invalid-frontmatter": "error",
+        "subagent/missing-name": "error",
+        // Claude Code's documented subagent contract requires only `name`
+        // and `description`; it neither specifies a name format beyond
+        // "unique identifier" nor ties `name` to the filename the way
+        // VS Code derives a Copilot custom agent's name from
+        // `<name>.agent.md`. Defaulting these to "warn" avoids failing
+        // lint for subagents that are valid per Claude Code's own docs.
+        "subagent/invalid-name-format": "warn",
+        "subagent/name-mismatch": "warn",
+        "subagent/missing-description": "error",
+        "subagent/invalid-description": "error",
+        "subagent/invalid-field": "warn"
+    },
+    mcpServers: {
+        "mcpserver/invalid-json": "error",
+        "mcpserver/invalid-config": "error"
+    },
     hooks: {
         "hook/invalid-json": "error",
         "hook/invalid-config": "error",
         "hook/missing-command": "error",
+        "hook/unknown-event": "error",
         "hook/missing-matcher": "warn",
         "hook/missing-timeout": "warn"
     },
@@ -52650,9 +52914,11 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
 ]));
 /** Zod schema for the lint.rules section of the config */ const LintRulesConfigSchema = schemas_object({
     agents: RuleConfigMapSchema.optional(),
+    subagents: RuleConfigMapSchema.optional(),
     hooks: RuleConfigMapSchema.optional(),
     instructions: RuleConfigMapSchema.optional(),
-    skills: RuleConfigMapSchema.optional()
+    skills: RuleConfigMapSchema.optional(),
+    mcpServers: RuleConfigMapSchema.optional()
 });
 /** Zod schema for the lint section of the config */ const LintConfigSchema = schemas_object({
     lint: schemas_object({
@@ -52695,9 +52961,11 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
     }
     return {
         agents: mergeTargetRules(DEFAULT_LINT_RULES.agents, rules.agents),
+        subagents: mergeTargetRules(DEFAULT_LINT_RULES.subagents, rules.subagents),
         hooks: mergeTargetRules(DEFAULT_LINT_RULES.hooks, rules.hooks),
         instructions: mergeTargetRules(DEFAULT_LINT_RULES.instructions, rules.instructions),
-        skills: mergeTargetRules(DEFAULT_LINT_RULES.skills, rules.skills)
+        skills: mergeTargetRules(DEFAULT_LINT_RULES.skills, rules.skills),
+        mcpServers: mergeTargetRules(DEFAULT_LINT_RULES.mcpServers, rules.mcpServers)
     };
 }
 
@@ -52709,8 +52977,10 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
  */ /** Maps a lint target to its config key */ const TARGET_TO_CONFIG_KEY = {
     skill: "skills",
     agent: "agents",
+    subagent: "subagents",
     hook: "hooks",
-    instruction: "instructions"
+    instruction: "instructions",
+    "mcp-server": "mcpServers"
 };
 /**
  * Maps config severity to diagnostic severity.
@@ -52911,6 +53181,167 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
     return lines[0]?.trim() === "---";
 }
 
+;// CONCATENATED MODULE: ../core/src/entities/claude-hook-schema.ts
+// biome-ignore-all lint/style/useNamingConvention: Claude Code API uses PascalCase hook event names (PreToolUse) and snake_case handler types (mcp_tool)
+/**
+ * Zod schemas for the Claude Code hooks configuration format.
+ *
+ * Lives in entities (Layer 1) so that use cases can import it without
+ * violating the dependency rule, mirroring `copilot-hook-schema.ts`.
+ *
+ * Modelled on https://code.claude.com/docs/en/hooks. Claude Code settings
+ * files carry far more than hooks, so the top level is permissive
+ * (`.passthrough()`); the `hooks` section itself is strict so that a
+ * misspelled event name — which silently never fires — is reported.
+ */ 
+const MAX_HOOKS_PER_ENTRY = 100;
+/**
+ * Events that accept a `matcher`. The remainder fire unconditionally, so a
+ * missing `matcher` is only worth reporting for the events listed here.
+ */ const MATCHER_SUPPORTING_EVENTS = new Set([
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionRequest",
+    "PermissionDenied",
+    "SessionStart",
+    "Setup",
+    "SessionEnd",
+    "Notification",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact",
+    "ConfigChange",
+    "DirectoryAdded",
+    "FileChanged",
+    "StopFailure",
+    "InstructionsLoaded",
+    "UserPromptExpansion",
+    "Elicitation",
+    "ElicitationResult"
+]);
+/** Fields every handler type accepts regardless of `type`. */ const sharedHandlerFields = {
+    if: schemas_string().optional(),
+    timeout: schemas_number().positive().optional(),
+    statusMessage: schemas_string().optional(),
+    once: schemas_boolean().optional()
+};
+/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
+const ClaudeCommandHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("command"),
+    command: schemas_string().min(1, "Hook command must not be empty"),
+    args: schemas_array(schemas_string()).optional(),
+    shell: schemas_enum([
+        "bash",
+        "powershell"
+    ]).optional(),
+    async: schemas_boolean().optional(),
+    asyncRewake: schemas_boolean().optional()
+}).strict();
+const ClaudeHttpHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("http"),
+    url: schemas_string().min(1, "Hook url must not be empty"),
+    headers: schemas_record(schemas_string(), schemas_string()).optional(),
+    allowedEnvVars: schemas_array(schemas_string().regex(ENV_KEY_PATTERN, "Hook allowedEnvVars entry must be a valid identifier (no prototype-polluting keys)")).optional()
+}).strict();
+const ClaudeMcpToolHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("mcp_tool"),
+    server: schemas_string().min(1, "Hook server must not be empty"),
+    tool: schemas_string().min(1, "Hook tool must not be empty"),
+    input: schemas_record(schemas_string(), unknown()).optional()
+}).strict();
+const ClaudePromptHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("prompt"),
+    prompt: schemas_string().min(1, "Hook prompt must not be empty"),
+    model: schemas_string().optional()
+}).strict();
+const ClaudeAgentHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("agent"),
+    prompt: schemas_string().min(1, "Hook prompt must not be empty"),
+    model: schemas_string().optional()
+}).strict();
+/**
+ * A single hook handler. Discriminated on `type` so that each handler is
+ * validated against its own required fields — an `http` handler is not
+ * expected to carry a `command`, and vice versa.
+ */ const ClaudeHookHandlerSchema = discriminatedUnion("type", [
+    ClaudeCommandHandlerSchema,
+    ClaudeHttpHandlerSchema,
+    ClaudeMcpToolHandlerSchema,
+    ClaudePromptHandlerSchema,
+    ClaudeAgentHandlerSchema
+]);
+/**
+ * A single entry within a hook event array.
+ *
+ * `matcher` is optional for every event: Claude Code treats an omitted
+ * matcher as "match all", and many events accept no matcher at all.
+ */ const ClaudeHookEntrySchema = schemas_object({
+    matcher: schemas_string().optional(),
+    hooks: schemas_array(ClaudeHookHandlerSchema).min(1, "Hook entry must include at least one handler").max(MAX_HOOKS_PER_ENTRY)
+}).strict();
+const hookEventArray = schemas_array(ClaudeHookEntrySchema);
+/**
+ * Every hook event Claude Code dispatches, each optional so that configs may
+ * use any combination.
+ *
+ * Spelled out rather than generated from a list so the schema keeps precise
+ * inferred types without a type assertion.
+ */ const claudeHookEventShape = {
+    SessionStart: hookEventArray.optional(),
+    Setup: hookEventArray.optional(),
+    UserPromptSubmit: hookEventArray.optional(),
+    UserPromptExpansion: hookEventArray.optional(),
+    PreToolUse: hookEventArray.optional(),
+    PermissionRequest: hookEventArray.optional(),
+    PermissionDenied: hookEventArray.optional(),
+    PostToolUse: hookEventArray.optional(),
+    PostToolUseFailure: hookEventArray.optional(),
+    PostToolBatch: hookEventArray.optional(),
+    Notification: hookEventArray.optional(),
+    MessageDisplay: hookEventArray.optional(),
+    SubagentStart: hookEventArray.optional(),
+    SubagentStop: hookEventArray.optional(),
+    TaskCreated: hookEventArray.optional(),
+    TaskCompleted: hookEventArray.optional(),
+    Stop: hookEventArray.optional(),
+    StopFailure: hookEventArray.optional(),
+    TeammateIdle: hookEventArray.optional(),
+    InstructionsLoaded: hookEventArray.optional(),
+    ConfigChange: hookEventArray.optional(),
+    CwdChanged: hookEventArray.optional(),
+    DirectoryAdded: hookEventArray.optional(),
+    FileChanged: hookEventArray.optional(),
+    WorktreeCreate: hookEventArray.optional(),
+    WorktreeRemove: hookEventArray.optional(),
+    PreCompact: hookEventArray.optional(),
+    PostCompact: hookEventArray.optional(),
+    Elicitation: hookEventArray.optional(),
+    ElicitationResult: hookEventArray.optional(),
+    SessionEnd: hookEventArray.optional()
+};
+/**
+ * Every known hook event name.
+ *
+ * Derived from the schema shape so the two can never drift apart, and used to
+ * report the valid set when an unknown event name is encountered.
+ */ const CLAUDE_HOOK_EVENTS = Object.keys(claudeHookEventShape);
+/**
+ * Zod schema for the hooks section of a Claude Code settings file.
+ *
+ * Every event is optional — configs may use any combination — but unknown
+ * event names are rejected so that typos surface instead of silently
+ * never firing.
+ */ const ClaudeHooksConfigSchema = schemas_object({
+    hooks: schemas_object(claudeHookEventShape).strict()
+}).passthrough();
+
 ;// CONCATENATED MODULE: ../core/src/entities/copilot-hook-schema.ts
 /**
  * Zod schemas for the GitHub Copilot hooks configuration format.
@@ -52922,7 +53353,7 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
  * depend on @lousy-agents/core.
  */ 
 const MAX_HOOKS_PER_EVENT = 100;
-/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
+/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const copilot_hook_schema_ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
 /**
  * Zod schema for a single GitHub Copilot hook command entry.
  */ const CopilotHookCommandSchema = schemas_object({
@@ -52931,7 +53362,7 @@ const MAX_HOOKS_PER_EVENT = 100;
     powershell: schemas_string().min(1, "Hook PowerShell command must not be empty").optional(),
     cwd: schemas_string().optional(),
     timeoutSec: schemas_number().positive().optional(),
-    env: schemas_record(schemas_string().regex(ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
+    env: schemas_record(schemas_string().regex(copilot_hook_schema_ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
 }).strict().refine((data)=>Boolean(data.bash) || Boolean(data.powershell), {
     message: "At least one of 'bash' or 'powershell' must be provided and non-empty"
 });
@@ -52951,33 +53382,78 @@ const hookArray = schemas_array(CopilotHookCommandSchema).max(MAX_HOOKS_PER_EVEN
 }).strict();
 
 ;// CONCATENATED MODULE: ../core/src/use-cases/lint-hook-config.ts
-// biome-ignore-all lint/style/useNamingConvention: Claude Code API uses PascalCase hook event names (PreToolUse)
 /**
- * Use case for linting pre-tool-use hook configurations.
+ * Use case for linting hook configurations.
  * Validates GitHub Copilot and Claude Code hook config files.
  */ 
 
 
 const INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in hook configuration file";
+/** Joins a Zod issue path into the dotted `field` shown on a diagnostic. */ function toFieldPath(path) {
+    return path.length > 0 ? path.join(".") : undefined;
+}
 /**
- * Zod schema for a single Claude Code hook command entry.
- */ const ClaudeHookCommandSchema = schemas_object({
-    type: schemas_literal("command"),
-    command: schemas_string().min(1, "Hook command must not be empty")
-}).strict();
-/**
- * Zod schema for a single Claude Code PreToolUse hook entry.
- */ const ClaudePreToolUseEntrySchema = schemas_object({
-    matcher: schemas_string().optional(),
-    hooks: schemas_array(ClaudeHookCommandSchema).min(1)
-}).strict();
+ * Expands a single Zod issue into diagnostics.
+ *
+ * `unrecognized_keys` issues carry every offending key on one issue whose path
+ * points at the *containing* object, so they are expanded into one diagnostic
+ * per key. A stray key directly under `hooks` is a misspelled event name —
+ * the most valuable defect this linter can catch, since Claude Code silently
+ * never fires such a hook.
+ */ function toClaudeDiagnostics(issue) {
+    if (issue.code === "unrecognized_keys") {
+        const isEventName = issue.path.length === 1 && issue.path[0] === "hooks";
+        return issue.keys.map((key)=>({
+                line: 1,
+                severity: "error",
+                message: isEventName ? `Unknown hook event '${key}'. A misspelled event never fires. Valid events: ${CLAUDE_HOOK_EVENTS.join(", ")}` : `Unrecognized key: "${key}"`,
+                field: [
+                    ...issue.path,
+                    key
+                ].join("."),
+                ruleId: isEventName ? "hook/unknown-event" : "hook/invalid-config"
+            }));
+    }
+    const lastPathSegment = issue.path.at(-1);
+    const isMissingCommand = lastPathSegment === "command" && (issue.code === "too_small" || issue.code === "invalid_type");
+    return [
+        {
+            line: 1,
+            severity: "error",
+            message: issue.message,
+            field: toFieldPath([
+                ...issue.path
+            ]),
+            ruleId: isMissingCommand ? "hook/missing-command" : "hook/invalid-config"
+        }
+    ];
+}
 /**
- * Zod schema for the Claude Code hooks section within settings.
- */ const ClaudeHooksConfigSchema = schemas_object({
-    hooks: schemas_object({
-        PreToolUse: schemas_array(ClaudePreToolUseEntrySchema).min(1)
-    }).passthrough()
-}).passthrough();
+ * Warns when an entry omits `matcher` for an event that supports one.
+ *
+ * Events that accept no matcher (`Stop`, `UserPromptSubmit`, …) are skipped:
+ * an omitted matcher there is the only valid spelling, not an oversight.
+ */ function collectMissingMatcherWarnings(hooks) {
+    const diagnostics = [];
+    for (const event of CLAUDE_HOOK_EVENTS){
+        if (!MATCHER_SUPPORTING_EVENTS.has(event)) {
+            continue;
+        }
+        const entries = hooks[event] ?? [];
+        entries.forEach((entry, index)=>{
+            if (entry.matcher === undefined) {
+                diagnostics.push({
+                    line: 1,
+                    severity: "warning",
+                    message: `Recommended field 'matcher' is missing from ${event} hook entry. Without a matcher, the hook runs for every occurrence.`,
+                    field: `hooks.${event}[${index}].matcher`,
+                    ruleId: "hook/missing-matcher"
+                });
+            }
+        });
+    }
+    return diagnostics;
+}
 /**
  * Use case for linting hook configuration files across a repository.
  */ class LintHookConfigUseCase {
@@ -53079,34 +53555,177 @@ const INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in hook configuration file";
         return diagnostics;
     }
     validateClaudeConfig(parsed) {
-        const diagnostics = [];
         const result = ClaudeHooksConfigSchema.safeParse(parsed);
         if (!result.success) {
-            for (const issue of result.error.issues){
-                const lastPathSegment = issue.path.length > 0 ? issue.path[issue.path.length - 1] : undefined;
-                const isMissingCommand = lastPathSegment === "command" && (issue.code === "too_small" || issue.code === "invalid_type");
-                diagnostics.push({
-                    line: 1,
-                    severity: "error",
-                    message: issue.message,
-                    field: issue.path.length > 0 ? issue.path.join(".") : undefined,
-                    ruleId: isMissingCommand ? "hook/missing-command" : "hook/invalid-config"
-                });
-            }
-            return diagnostics;
+            return result.error.issues.flatMap((issue)=>toClaudeDiagnostics(issue));
         }
-        for (const [index, entry] of result.data.hooks.PreToolUse.entries()){
-            if (entry.matcher === undefined) {
-                diagnostics.push({
-                    line: 1,
-                    severity: "warning",
-                    message: "Recommended field 'matcher' is missing from PreToolUse hook entry. Without a matcher, the hook runs for all tools.",
-                    field: `hooks.PreToolUse[${index}].matcher`,
-                    ruleId: "hook/missing-matcher"
-                });
+        return collectMissingMatcherWarnings(result.data.hooks);
+    }
+}
+
+;// CONCATENATED MODULE: ../core/src/use-cases/lint-mcp-servers.ts
+/**
+ * Use case for linting MCP server configuration files.
+ * Validates baseline shape: the config parses as JSON and, when present,
+ * `mcpServers` (Claude Code's `.mcp.json` convention) or `servers` (VS
+ * Code's `.vscode/mcp.json` convention) is a map of server name to a
+ * server declaration.
+ */ 
+const lint_mcp_servers_INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in MCP server configuration file";
+/**
+ * Property names that must never be used as MCP server names: assigning
+ * them via a plain object key (as zod's `record()` does when reconstructing
+ * parsed output) triggers JavaScript's `__proto__` magic setter instead of
+ * creating an own property, silently dropping the entry from validation and
+ * counts. Rejected explicitly so a config declaring one of these names
+ * fails lint instead of appearing to declare fewer servers than it does.
+ */ const lint_mcp_servers_RESERVED_SERVER_NAMES = [
+    "__proto__",
+    "constructor",
+    "prototype"
+];
+const lint_mcp_servers_SERVER_MAP_FIELDS = [
+    "mcpServers",
+    "servers"
+];
+/**
+ * Zod schema for a single MCP server declaration.
+ * Baseline shape only: an object whose optional `type`/`transport` fields,
+ * when present, must be non-empty strings. Unknown fields are preserved.
+ */ const lint_mcp_servers_McpServerEntrySchema = schemas_object({
+    type: schemas_string().min(1, "type must not be empty").optional(),
+    transport: schemas_string().min(1, "transport must not be empty").optional()
+}).passthrough();
+/**
+ * Zod schema for the MCP config file shape.
+ */ const lint_mcp_servers_McpConfigSchema = schemas_object({
+    mcpServers: schemas_record(schemas_string(), lint_mcp_servers_McpServerEntrySchema).optional(),
+    servers: schemas_record(schemas_string(), lint_mcp_servers_McpServerEntrySchema).optional()
+}).passthrough();
+function lint_mcp_servers_isPlainObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function reservedNameDiagnostic(field, reservedName) {
+    return {
+        line: 1,
+        severity: "error",
+        message: `Server name '${reservedName}' is a reserved JavaScript property name and is not allowed.`,
+        field: `${field}.${reservedName}`,
+        ruleId: "mcpserver/invalid-config"
+    };
+}
+function reservedNamesInServerMap(servers, field) {
+    const diagnostics = [];
+    for (const reservedName of lint_mcp_servers_RESERVED_SERVER_NAMES){
+        if (Object.hasOwn(servers, reservedName)) {
+            diagnostics.push(reservedNameDiagnostic(field, reservedName));
+        }
+    }
+    return diagnostics;
+}
+/**
+ * Scans the raw (pre-zod) parsed config for reserved server names. Must run
+ * against the raw `JSON.parse` output, which preserves `__proto__` as an
+ * ordinary own property, rather than against zod's reconstructed output.
+ */ function findReservedServerNameDiagnostics(parsed) {
+    if (!lint_mcp_servers_isPlainObject(parsed)) {
+        return [];
+    }
+    const diagnostics = [];
+    for (const field of lint_mcp_servers_SERVER_MAP_FIELDS){
+        const servers = parsed[field];
+        if (!lint_mcp_servers_isPlainObject(servers)) {
+            continue;
+        }
+        diagnostics.push(...reservedNamesInServerMap(servers, field));
+    }
+    return diagnostics;
+}
+function invalidJsonResult(filePath, error) {
+    const detail = error instanceof Error && error.message ? `: ${error.message}` : ".";
+    return {
+        filePath,
+        serverCount: 0,
+        diagnostics: [
+            {
+                line: 1,
+                severity: "error",
+                message: `${lint_mcp_servers_INVALID_JSON_MESSAGE_PREFIX}${detail}`,
+                ruleId: "mcpserver/invalid-json"
             }
+        ],
+        valid: false
+    };
+}
+function invalidConfigResult(filePath, diagnostics) {
+    return {
+        filePath,
+        serverCount: 0,
+        diagnostics,
+        valid: false
+    };
+}
+function zodIssuesToDiagnostics(issues) {
+    return issues.map((issue)=>({
+            line: 1,
+            severity: "error",
+            message: issue.message,
+            field: issue.path.length > 0 ? issue.path.join(".") : undefined,
+            ruleId: "mcpserver/invalid-config"
+        }));
+}
+function countBySeverity(results, severity) {
+    return results.reduce((sum, r)=>sum + r.diagnostics.filter((d)=>d.severity === severity).length, 0);
+}
+/**
+ * Use case for linting MCP server configuration files across a repository.
+ */ class LintMcpServersUseCase {
+    gateway;
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
         }
-        return diagnostics;
+        const files = await this.gateway.discoverMcpConfigFiles(input.targetDir);
+        const results = [];
+        for (const file of files){
+            const content = await this.gateway.readFileContent(file.filePath);
+            results.push(this.lintFile(file, content));
+        }
+        return {
+            results,
+            totalFiles: files.length,
+            totalErrors: countBySeverity(results, "error"),
+            totalWarnings: countBySeverity(results, "warning")
+        };
+    }
+    lintFile(file, content) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        } catch (error) {
+            return invalidJsonResult(file.filePath, error);
+        }
+        const reservedNameDiagnostics = findReservedServerNameDiagnostics(parsed);
+        if (reservedNameDiagnostics.length > 0) {
+            return invalidConfigResult(file.filePath, reservedNameDiagnostics);
+        }
+        const result = lint_mcp_servers_McpConfigSchema.safeParse(parsed);
+        if (!result.success) {
+            return invalidConfigResult(file.filePath, zodIssuesToDiagnostics(result.error.issues));
+        }
+        const servers = {
+            ...result.data.mcpServers ?? {},
+            ...result.data.servers ?? {}
+        };
+        return {
+            filePath: file.filePath,
+            serverCount: Object.keys(servers).length,
+            diagnostics: [],
+            valid: true
+        };
     }
 }
 
@@ -53265,6 +53884,138 @@ function hasFrontmatterDelimiters(content) {
     return false;
 }
 
+;// CONCATENATED MODULE: ../core/src/use-cases/lint-subagent-frontmatter.ts
+/**
+ * Use case for linting Claude Code subagent frontmatter.
+ * Validates required fields, name format, and filename matching.
+ */ 
+/**
+ * Zod schema for validating subagent frontmatter.
+ * Claude Code subagents require `name` and `description`, mirroring the
+ * Copilot custom agent contract (see AgentFrontmatterSchema).
+ */ const SubagentFrontmatterSchema = schemas_object({
+    name: schemas_string().min(1, "Name is required").max(64, "Name must be 64 characters or fewer").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Name must contain only lowercase letters, numbers, and hyphens"),
+    description: schemas_string().min(1, "Description is required").max(1024, "Description must be 1024 characters or fewer").refine((s)=>s.trim().length > 0, {
+        message: "Description cannot be empty or whitespace-only"
+    })
+});
+/**
+ * Use case for linting subagent frontmatter across a repository.
+ */ class LintSubagentFrontmatterUseCase {
+    gateway;
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
+        }
+        const subagents = await this.gateway.discoverSubagents(input.targetDir);
+        const results = [];
+        for (const subagent of subagents){
+            const content = await this.gateway.readSubagentFileContent(subagent.filePath);
+            const result = this.lintSubagent(subagent, content);
+            results.push(result);
+        }
+        const totalErrors = results.reduce((sum, r)=>sum + r.diagnostics.filter((d)=>d.severity === "error").length, 0);
+        const totalWarnings = results.reduce((sum, r)=>sum + r.diagnostics.filter((d)=>d.severity === "warning").length, 0);
+        return {
+            results,
+            totalSubagents: subagents.length,
+            totalErrors,
+            totalWarnings
+        };
+    }
+    lintSubagent(subagent, content) {
+        let parsed = null;
+        let diagnostics = [];
+        try {
+            parsed = this.gateway.parseFrontmatter(content);
+        } catch (error) {
+            const messagePrefix = "Invalid YAML frontmatter";
+            const errorMessage = error instanceof Error && error.message ? `${messagePrefix}: ${error.message}` : `${messagePrefix}.`;
+            diagnostics.push({
+                line: 1,
+                severity: "error",
+                message: errorMessage,
+                ruleId: "subagent/invalid-frontmatter"
+            });
+        }
+        if (!parsed) {
+            if (diagnostics.length === 0) {
+                const message = lint_subagent_frontmatter_hasOpeningDelimiter(content) ? "Invalid YAML frontmatter. The content between --- delimiters could not be parsed as valid YAML." : "Missing YAML frontmatter. Subagent files must begin with --- delimited YAML frontmatter.";
+                const ruleId = lint_subagent_frontmatter_hasOpeningDelimiter(content) ? "subagent/invalid-frontmatter" : "subagent/missing-frontmatter";
+                diagnostics.push({
+                    line: 1,
+                    severity: "error",
+                    message,
+                    ruleId
+                });
+            }
+            return {
+                filePath: subagent.filePath,
+                subagentName: subagent.subagentName,
+                diagnostics,
+                valid: false
+            };
+        }
+        const frontmatterDiagnostics = this.validateFrontmatter(parsed, subagent.subagentName);
+        diagnostics = diagnostics.concat(frontmatterDiagnostics);
+        return {
+            filePath: subagent.filePath,
+            subagentName: subagent.subagentName,
+            diagnostics,
+            valid: diagnostics.every((d)=>d.severity !== "error")
+        };
+    }
+    validateFrontmatter(parsed, filenameStem) {
+        const diagnostics = [];
+        const result = SubagentFrontmatterSchema.safeParse(parsed.data);
+        if (!result.success) {
+            for (const issue of result.error.issues){
+                const fieldName = issue.path[0]?.toString();
+                const line = fieldName ? parsed.fieldLines.get(fieldName) ?? parsed.frontmatterStartLine : parsed.frontmatterStartLine;
+                const isMissing = fieldName !== undefined && parsed.data[fieldName] === undefined;
+                const ruleId = this.getRuleIdForField(fieldName, isMissing);
+                diagnostics.push({
+                    line,
+                    severity: "error",
+                    message: issue.message,
+                    field: fieldName,
+                    ruleId
+                });
+            }
+        }
+        // Check name matches filename stem
+        if (result.success && result.data.name !== filenameStem) {
+            const nameLine = parsed.fieldLines.get("name") ?? parsed.frontmatterStartLine;
+            diagnostics.push({
+                line: nameLine,
+                severity: "error",
+                message: `Frontmatter name '${result.data.name}' does not match filename '${filenameStem}'. Claude Code identifies subagents by the name field, not the filename, but matching them is a helpful convention.`,
+                field: "name",
+                ruleId: "subagent/name-mismatch"
+            });
+        }
+        return diagnostics;
+    }
+    getRuleIdForField(fieldName, isMissing) {
+        if (fieldName === "name") {
+            return isMissing ? "subagent/missing-name" : "subagent/invalid-name-format";
+        }
+        if (fieldName === "description") {
+            return isMissing ? "subagent/missing-description" : "subagent/invalid-description";
+        }
+        return "subagent/invalid-field";
+    }
+}
+/**
+ * Checks whether content has an opening --- frontmatter delimiter.
+ */ function lint_subagent_frontmatter_hasOpeningDelimiter(content) {
+    const lines = content.split("\n");
+    return lines[0]?.trim() === "---";
+}
+
 ;// CONCATENATED MODULE: ../lint/src/lint-errors.ts
 /**
  * Public lint API error types.
@@ -53405,11 +54156,17 @@ function sanitizeForErrorMessage(value) {
 
 
 
+
+
+
+
 const LintTargetsSchema = schemas_object({
     skills: schemas_boolean().optional(),
     agents: schemas_boolean().optional(),
+    subagents: schemas_boolean().optional(),
     hooks: schemas_boolean().optional(),
-    instructions: schemas_boolean().optional()
+    instructions: schemas_boolean().optional(),
+    mcpServers: schemas_boolean().optional()
 }).strict().optional();
 const LintOptionsSchema = schemas_object({
     directory: schemas_string().min(1, "directory must not be empty"),
@@ -53465,6 +54222,22 @@ async function lintAgents(targetDir) {
     });
     return toLintOutput(output, "agent", output.totalAgents);
 }
+async function lintSubagents(targetDir) {
+    const gateway = createSubagentLintGateway();
+    const useCase = new LintSubagentFrontmatterUseCase(gateway);
+    const output = await useCase.execute({
+        targetDir
+    });
+    return toLintOutput(output, "subagent", output.totalSubagents);
+}
+async function lintMcpServers(targetDir) {
+    const gateway = createMcpServersLintGateway();
+    const useCase = new LintMcpServersUseCase(gateway);
+    const output = await useCase.execute({
+        targetDir
+    });
+    return toLintOutput(output, "mcp-server", output.totalFiles);
+}
 async function lintHooks(targetDir) {
     const gateway = createHookConfigGateway();
     const useCase = new LintHookConfigUseCase(gateway);
@@ -53495,10 +54268,15 @@ async function lintInstructions(targetDir, logger) {
         }
     };
 }
-function isTargetEnabled(key, targets) {
-    if (!targets) return true;
+function isTargetEnabled(target, targets) {
+    if (!targets) {
+        return target.defaultEnabled;
+    }
     const hasAnyEnabled = Object.values(targets).some(Boolean);
-    return !hasAnyEnabled || targets[key] === true;
+    if (!hasAnyEnabled) {
+        return target.defaultEnabled;
+    }
+    return targets[target.key] === true;
 }
 /**
  * Run lint checks on a project directory.
@@ -53506,7 +54284,10 @@ function isTargetEnabled(key, targets) {
  * Orchestrates all lint targets (skills, agents, hooks, instructions),
  * applies lint rule configuration, and returns structured results.
  *
- * When no targets are specified (or all are false), all targets are run.
+ * When no targets are specified (or all are false), the default-enabled
+ * targets are run (skills, agents, hooks, instructions). `subagents` and
+ * `mcpServers` are flag-only (not yet GA): they only run when explicitly
+ * set to `true`, even when no other target flags are set.
  *
  * @example
  * ```typescript
@@ -53541,22 +54322,36 @@ function isTargetEnabled(key, targets) {
     const lintTargets = [
         {
             key: "skills",
+            defaultEnabled: true,
             execute: lintSkills
         },
         {
             key: "agents",
+            defaultEnabled: true,
             execute: lintAgents
         },
+        {
+            key: "subagents",
+            defaultEnabled: false,
+            execute: lintSubagents
+        },
         {
             key: "hooks",
+            defaultEnabled: true,
             execute: lintHooks
         },
         {
             key: "instructions",
+            defaultEnabled: true,
             execute: (dir)=>lintInstructions(dir, parsed.logger)
+        },
+        {
+            key: "mcpServers",
+            defaultEnabled: false,
+            execute: lintMcpServers
         }
     ];
-    const enabledTargets = lintTargets.filter((t)=>isTargetEnabled(t.key, parsed.targets));
+    const enabledTargets = lintTargets.filter((t)=>isTargetEnabled(t, parsed.targets));
     const outputs = [];
     for (const target of enabledTargets){
         const rawOutput = await target.execute(targetDir);
@@ -53591,61 +54386,225 @@ function isTargetEnabled(key, targets) {
 
 
 
-;// CONCATENATED MODULE: ./src/commands/lint.ts
+;// CONCATENATED MODULE: ./src/commands/lint-instruction-display.ts
 /**
- * CLI command for linting agent skills, custom agents, and instruction files.
- * Delegates to the lint package facade and handles CLI display concerns.
+ * Instruction-quality display for the lint CLI command.
  */ 
+function warnSuggestions(suggestions) {
+    for (const suggestion of suggestions){
+        consola.warn(suggestion.message);
+    }
+}
+/**
+ * Displays instruction quality analysis results using consola.
+ */ function displayInstructionQuality(output) {
+    const result = output.qualityResult;
+    if (!result) {
+        return;
+    }
+    if (result.discoveredFiles.length === 0) {
+        consola.info("No instruction files found");
+        warnSuggestions(result.suggestions);
+        return;
+    }
+    consola.info(`Discovered ${result.discoveredFiles.length} instruction file(s)`);
+    for (const file of result.discoveredFiles){
+        consola.info(`  ${file.filePath} (${file.format})`);
+    }
+    consola.info(`Overall instruction quality score: ${result.overallQualityScore}%`);
+    warnSuggestions(result.suggestions);
+}
 
+;// CONCATENATED MODULE: ./src/commands/lint-target-labels.ts
+/**
+ * Shared human-readable labels for lint target categories, used by both
+ * per-file diagnostic display and the pass/fail summary line.
+ */ const TARGET_LABELS = {
+    skill: "skill(s)",
+    agent: "agent(s)",
+    subagent: "subagent(s)",
+    hook: "hook config(s)",
+    instruction: "instruction file(s)",
+    "mcp-server": "MCP server config(s)"
+};
+function targetLabel(target) {
+    return TARGET_LABELS[target] ?? target;
+}
 
+;// CONCATENATED MODULE: ./src/commands/lint-display.ts
 /**
- * Formats and displays a LintOutput using consola.
- */ function displayLintOutput(output, label) {
+ * Human-readable display helpers for the lint CLI command.
+ */ 
+
+
+
+const SEVERITY_LOGGERS = {
+    error: (msg)=>consola.error(msg),
+    warning: (msg)=>consola.warn(msg),
+    info: (msg)=>consola.info(msg)
+};
+function logDiagnostic(d) {
+    const fieldInfo = d.field ? ` [${d.field}]` : "";
+    const message = `${d.filePath}:${d.line}${fieldInfo}: ${d.message}`;
+    const log = SEVERITY_LOGGERS[d.severity] ?? SEVERITY_LOGGERS.info;
+    log(message);
+}
+function displayOkFiles(output) {
+    const filesWithDiagnostics = new Set(output.diagnostics.map((d)=>d.filePath));
+    for (const file of output.filesAnalyzed){
+        if (filesWithDiagnostics.has(file)) {
+            continue;
+        }
+        consola.success(`${file}: OK`);
+    }
+}
+function displayLintOutput(output, label) {
     if (output.summary.totalFiles === 0) {
         consola.info(`No ${label} found`);
         return;
     }
     consola.info(`Discovered ${output.summary.totalFiles} ${label}`);
-    const filesWithDiagnostics = new Set();
+    displayOkFiles(output);
     for (const d of output.diagnostics){
-        filesWithDiagnostics.add(d.filePath);
+        logDiagnostic(d);
     }
-    for (const file of output.filesAnalyzed){
-        if (!filesWithDiagnostics.has(file)) {
-            consola.success(`${file}: OK`);
+}
+function displayHumanOutputs(outputs) {
+    for (const output of outputs){
+        if (output.target === "instruction") {
+            displayInstructionQuality(output);
+            continue;
         }
+        displayLintOutput(output, targetLabel(output.target));
     }
-    for (const d of output.diagnostics){
-        const prefix = `${d.filePath}:${d.line}`;
-        const fieldInfo = d.field ? ` [${d.field}]` : "";
-        if (d.severity === "error") {
-            consola.error(`${prefix}${fieldInfo}: ${d.message}`);
-        } else if (d.severity === "warning") {
-            consola.warn(`${prefix}${fieldInfo}: ${d.message}`);
-        } else {
-            consola.info(`${prefix}${fieldInfo}: ${d.message}`);
-        }
+}
+function displayFormattedOutputs(outputs, format) {
+    if (format === "human") {
+        displayHumanOutputs(outputs);
+        return;
     }
+    const formatted = createFormatter(format).format(outputs);
+    if (!formatted) {
+        return;
+    }
+    process.stdout.write(`${formatted}\n`);
+}
+function sumWarnings(outputs) {
+    return outputs.reduce((sum, output)=>sum + output.summary.totalWarnings, 0);
 }
+
+;// CONCATENATED MODULE: ./src/commands/lint-report.ts
 /**
- * Displays instruction quality analysis results using consola.
- */ function displayInstructionQuality(output) {
-    const result = output.qualityResult;
-    if (!result) {
+ * Pass/fail summary reporting for the lint CLI command.
+ */ 
+
+function reportFailure(outputs, totalWarnings, format) {
+    process.exitCode = 1;
+    if (format !== "human") {
         return;
     }
-    if (result.discoveredFiles.length === 0) {
-        consola.info("No instruction files found");
-    } else {
-        consola.info(`Discovered ${result.discoveredFiles.length} instruction file(s)`);
-        for (const file of result.discoveredFiles){
-            consola.info(`  ${file.filePath} (${file.format})`);
+    const totalErrors = outputs.reduce((sum, o)=>sum + o.summary.totalErrors, 0);
+    consola.error(`lint failed: ${totalErrors} error(s), ${totalWarnings} warning(s)`);
+}
+function reportSuccess(outputs, totalWarnings, format) {
+    if (format !== "human") {
+        return;
+    }
+    if (totalWarnings > 0) {
+        consola.warn(`Lint passed with ${totalWarnings} warning(s)`);
+        return;
+    }
+    const targets = outputs.map((o)=>targetLabel(o.target)).join(", ");
+    consola.success(`All ${targets} passed lint checks`);
+}
+
+;// CONCATENATED MODULE: ./src/commands/lint.ts
+/**
+ * CLI command for linting agent skills, custom agents, and instruction files.
+ * Delegates to the lint package facade and handles CLI display concerns.
+ */ 
+
+
+
+
+const VALID_FORMATS = new Set([
+    "human",
+    "json",
+    "rdjsonl"
+]);
+function resolveTargetDir(context) {
+    if (typeof context.data?.targetDir === "string") {
+        return context.data.targetDir;
+    }
+    return process.cwd();
+}
+function isLessonsSubcommand(rawArgs) {
+    return rawArgs.some((token, idx)=>token === "lessons" && rawArgs[idx - 1] !== "--format");
+}
+function resolveBooleanFlag(context, key) {
+    return context.args?.[key] === true || context.data?.[key] === true;
+}
+function isLintFormatType(value) {
+    return VALID_FORMATS.has(value);
+}
+function readRawFormat(context) {
+    if (typeof context.args?.format === "string") {
+        return context.args.format;
+    }
+    if (typeof context.data?.format === "string") {
+        return context.data.format;
+    }
+    return "human";
+}
+function resolveFormat(context) {
+    const rawFormat = readRawFormat(context);
+    if (isLintFormatType(rawFormat)) {
+        return rawFormat;
+    }
+    return "human";
+}
+function resolveLintTargets(context) {
+    return {
+        skills: resolveBooleanFlag(context, "skills"),
+        agents: resolveBooleanFlag(context, "agents"),
+        subagents: resolveBooleanFlag(context, "subagents"),
+        hooks: resolveBooleanFlag(context, "hooks"),
+        instructions: resolveBooleanFlag(context, "instructions"),
+        mcpServers: resolveBooleanFlag(context, "mcpServers")
+    };
+}
+async function executeLint(context) {
+    try {
+        return await runLint({
+            directory: resolveTargetDir(context),
+            targets: resolveLintTargets(context)
+        });
+    } catch (error) {
+        if (error instanceof LintValidationError) {
+            consola.error(`Lint failed: ${error.message}`);
+            process.exitCode = 1;
+            return null;
         }
-        consola.info(`Overall instruction quality score: ${result.overallQualityScore}%`);
+        throw error;
     }
-    for (const suggestion of result.suggestions){
-        consola.warn(suggestion.message);
+}
+async function runLintCommand(context) {
+    if (isLessonsSubcommand(context.rawArgs ?? [])) {
+        return;
+    }
+    const format = resolveFormat(context);
+    const result = await executeLint(context);
+    if (result === null) {
+        return;
     }
+    const { outputs, hasErrors } = result;
+    const totalWarnings = sumWarnings(outputs);
+    displayFormattedOutputs(outputs, format);
+    if (hasErrors) {
+        reportFailure(outputs, totalWarnings, format);
+        return;
+    }
+    reportSuccess(outputs, totalWarnings, format);
 }
 /**
  * The `lint` command for validating agent skills, custom agents, and instruction files.
@@ -53661,6 +54620,11 @@ function isTargetEnabled(key, targets) {
         description: "Lint custom agent frontmatter in .github/agents/",
         default: false
     },
+    subagents: {
+        type: "boolean",
+        description: "[flag-only, not default-on] Lint Claude Code subagent frontmatter in .claude/agents/",
+        default: false
+    },
     hooks: {
         type: "boolean",
         description: "Lint pre-tool-use hook configurations in .github/hooks/agent-shell/hooks.json, .claude/settings.json, and .claude/settings.local.json",
@@ -53671,6 +54635,11 @@ function isTargetEnabled(key, targets) {
         description: "Analyze instruction quality across all instruction file formats",
         default: false
     },
+    mcpServers: {
+        type: "boolean",
+        description: "[flag-only, not default-on] Lint MCP server config files (.mcp.json, .vscode/mcp.json)",
+        default: false
+    },
     format: {
         type: "string",
         description: "Output format: human (default), json, or rdjsonl",
@@ -53681,96 +54650,13 @@ function createLintCommand(lintLessonsCmd) {
     return defineCommand({
         meta: {
             name: "lint",
-            description: "Lint agent skills, custom agents, instruction files, and hook configurations. Validates frontmatter, instruction quality, and hook config schemas. Run `lint lessons` to validate lesson files."
+            description: "Lint agent skills, custom agents, instruction files, and hook configurations. Validates frontmatter, instruction quality, and hook config schemas. Also supports flag-only (not default-on) subagent and MCP server config linting. Run `lint lessons` to validate lesson files."
         },
         subCommands: {
             lessons: lintLessonsCmd
         },
         args: lintArgs,
-        run: async (context)=>{
-            const rawTargetDir = typeof context.data?.targetDir === "string" ? context.data.targetDir : process.cwd();
-            const rawArgs_ = context.rawArgs ?? [];
-            const lessonsIsSubcommand = rawArgs_.some((token, idx)=>token === "lessons" && rawArgs_[idx - 1] !== "--format");
-            if (lessonsIsSubcommand) {
-                return;
-            }
-            const lintSkillsFlag = context.args?.skills === true || context.data?.skills === true;
-            const lintAgentsFlag = context.args?.agents === true || context.data?.agents === true;
-            const lintHooksFlag = context.args?.hooks === true || context.data?.hooks === true;
-            const lintInstructionsFlag = context.args?.instructions === true || context.data?.instructions === true;
-            const rawFormat = typeof context.args?.format === "string" ? context.args.format : typeof context.data?.format === "string" ? context.data.format : "human";
-            const validFormats = new Set([
-                "human",
-                "json",
-                "rdjsonl"
-            ]);
-            function isLintFormatType(value) {
-                return validFormats.has(value);
-            }
-            const format = isLintFormatType(rawFormat) ? rawFormat : "human";
-            let result;
-            try {
-                result = await runLint({
-                    directory: rawTargetDir,
-                    targets: {
-                        skills: lintSkillsFlag,
-                        agents: lintAgentsFlag,
-                        hooks: lintHooksFlag,
-                        instructions: lintInstructionsFlag
-                    }
-                });
-            } catch (error) {
-                if (error instanceof LintValidationError) {
-                    consola.error(`Lint failed: ${error.message}`);
-                    process.exitCode = 1;
-                    return;
-                }
-                throw error;
-            }
-            const { outputs, hasErrors } = result;
-            let totalWarnings = 0;
-            for (const output of outputs){
-                totalWarnings += output.summary.totalWarnings;
-            }
-            const targetLabels = {
-                skill: "skill(s)",
-                agent: "agent(s)",
-                hook: "hook config(s)",
-                instruction: "instruction file(s)"
-            };
-            if (format !== "human") {
-                const formatter = createFormatter(format);
-                const formatted = formatter.format(outputs);
-                if (formatted) {
-                    process.stdout.write(`${formatted}\n`);
-                }
-            } else {
-                for (const output of outputs){
-                    const label = targetLabels[output.target] ?? output.target;
-                    if (output.target === "instruction") {
-                        displayInstructionQuality(output);
-                    } else {
-                        displayLintOutput(output, label);
-                    }
-                }
-            }
-            if (hasErrors) {
-                process.exitCode = 1;
-                if (format === "human") {
-                    const totalErrors = outputs.reduce((sum, o)=>sum + o.summary.totalErrors, 0);
-                    consola.error(`lint failed: ${totalErrors} error(s), ${totalWarnings} warning(s)`);
-                }
-                return;
-            }
-            if (format === "human") {
-                if (totalWarnings > 0) {
-                    consola.warn(`Lint passed with ${totalWarnings} warning(s)`);
-                } else {
-                    const targets = outputs.map((o)=>targetLabels[o.target] ?? o.target).join(", ");
-                    consola.success(`All ${targets} passed lint checks`);
-                }
-            }
-        }
+        run: runLintCommand
     });
 }
 
@@ -63036,4 +63922,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(7015);
+var __webpack_exports__ = __webpack_require__(6567);