@lousy-agents/cli 5.18.2 → 5.19.0

package/dist/index.js

@@ -3032,7 +3032,7 @@ exports.basename = (path, { windows } = {}) => {
 
 
 },
-7015(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+4140(__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);
@@ -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);
@@ -52594,6 +52696,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,6 +52825,26 @@ 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",
@@ -52650,9 +52886,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 +52933,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 +52949,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.
@@ -53110,6 +53352,172 @@ const INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in hook configuration file";
     }
 }
 
+;// 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");
+        }
+        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
+        };
+    }
+}
+
 ;// CONCATENATED MODULE: ../core/src/use-cases/lint-skill-frontmatter.ts
 
 const AgentSkillFrontmatterSchema = schemas_object({
@@ -53265,6 +53673,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 +53945,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 +54011,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 +54057,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 +54073,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 +54111,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 +54175,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 +54409,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 +54424,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 +54439,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 +63711,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__(4140);