@lousy-agents/cli 2.4.0 → 2.5.1

package/dist/mcp-server.js

@@ -5610,6 +5610,7 @@ exports["default"] = def;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const code_1 = __webpack_require__(5765);
+const util_1 = __webpack_require__(4227);
 const codegen_1 = __webpack_require__(9029);
 const error = {
     message: ({ schemaCode }) => (0, codegen_1.str) `must match pattern "${schemaCode}"`,
@@ -5622,11 +5623,19 @@ const def = {
     $data: true,
     error,
     code(cxt) {
-        const { data, $data, schema, schemaCode, it } = cxt;
-        // TODO regexp should be wrapped in try/catchs
+        const { gen, data, $data, schema, schemaCode, it } = cxt;
         const u = it.opts.unicodeRegExp ? "u" : "";
-        const regExp = $data ? (0, codegen_1._) `(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-        cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);
+        if ($data) {
+            const { regExp } = it.opts.code;
+            const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._) `new RegExp` : (0, util_1.useFunc)(gen, regExp);
+            const valid = gen.let("valid");
+            gen.try(() => gen.assign(valid, (0, codegen_1._) `${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+            cxt.fail$data((0, codegen_1._) `!${valid}`);
+        }
+        else {
+            const regExp = (0, code_1.usePattern)(cxt, schema);
+            cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);
+        }
     },
 };
 exports["default"] = def;
@@ -45199,6 +45208,283 @@ async function watchConfig(options) {
     return new FileSystemEnvironmentGateway();
 }
 
+;// CONCATENATED MODULE: ./src/gateways/instruction-analysis-gateway.ts
+/**
+ * Gateway for analyzing repository instructions for feedback loop coverage
+ */ 
+
+
+/**
+ * File system implementation of instruction analysis gateway
+ */ class FileSystemInstructionAnalysisGateway {
+    async analyzeCoverage(targetDir, scripts, tools) {
+        // Find all instruction files
+        const instructionFiles = await this.findInstructionFiles(targetDir);
+        // Read and search instruction content
+        const references = [];
+        const documentedTargets = new Set();
+        for (const file of instructionFiles){
+            const content = await (0,promises_.readFile)(file, "utf-8");
+            const lines = content.split("\n");
+            // Check for script references (e.g., "npm test", "npm run build")
+            for (const script of scripts){
+                const scriptRefs = this.findReferencesInContent(script.name, content, lines, file, targetDir);
+                if (scriptRefs.length > 0) {
+                    references.push(...scriptRefs);
+                    documentedTargets.add(script.name);
+                }
+            }
+            // Check for tool references (e.g., "mise run test", "biome check")
+            for (const tool of tools){
+                const toolRefs = this.findReferencesInContent(tool.name, content, lines, file, targetDir);
+                if (toolRefs.length > 0) {
+                    references.push(...toolRefs);
+                    documentedTargets.add(tool.name);
+                }
+            }
+        }
+        // Filter mandatory scripts/tools
+        const mandatoryScripts = scripts.filter((s)=>s.isMandatory);
+        const mandatoryTools = tools.filter((t)=>t.isMandatory);
+        const allMandatory = [
+            ...mandatoryScripts,
+            ...mandatoryTools
+        ];
+        // Categorize as missing or documented
+        const missingInInstructions = allMandatory.filter((item)=>!documentedTargets.has(item.name));
+        const documentedInInstructions = allMandatory.filter((item)=>documentedTargets.has(item.name));
+        const totalMandatory = allMandatory.length;
+        const totalDocumented = documentedInInstructions.length;
+        const coveragePercentage = totalMandatory === 0 ? 100 : totalDocumented / totalMandatory * 100;
+        return {
+            missingInInstructions,
+            documentedInInstructions,
+            references,
+            summary: {
+                totalMandatory,
+                totalDocumented,
+                coveragePercentage: Math.round(coveragePercentage * 100) / 100
+            }
+        };
+    }
+    async findInstructionFiles(targetDir) {
+        const files = [];
+        // Check for .github/copilot-instructions.md
+        const copilotInstructions = (0,external_node_path_.join)(targetDir, ".github", "copilot-instructions.md");
+        if (await file_system_utils_fileExists(copilotInstructions)) {
+            files.push(copilotInstructions);
+        }
+        // Check for .github/instructions/*.md
+        const instructionsDir = (0,external_node_path_.join)(targetDir, ".github", "instructions");
+        if (await file_system_utils_fileExists(instructionsDir)) {
+            try {
+                const instructionFiles = await (0,promises_.readdir)(instructionsDir);
+                for (const file of instructionFiles){
+                    if (file.endsWith(".md")) {
+                        files.push((0,external_node_path_.join)(instructionsDir, file));
+                    }
+                }
+            } catch  {
+            // Skip directory if we can't read it (e.g., permissions issues)
+            // Similar to how workflow parsing errors are handled
+            }
+        }
+        return files;
+    }
+    findReferencesInContent(target, content, lines, file, targetDir) {
+        const references = [];
+        // Build a case-insensitive, word-boundary-aware pattern for the target.
+        // This reduces false positives from simple substring matches like
+        // "test" in "testing" or "latest", while still matching common
+        // separators such as spaces, punctuation, etc.
+        const escapedTarget = target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const targetPattern = new RegExp(`(?:^|[^\\w])(${escapedTarget})(?=$|[^\\w])`, "i");
+        // Fast path: skip line-by-line processing if the target pattern
+        // never appears in the full content.
+        if (!targetPattern.test(content)) {
+            return references;
+        }
+        // Find line numbers where target appears
+        for(let i = 0; i < lines.length; i++){
+            const line = lines[i];
+            if (targetPattern.test(line)) {
+                // Get context (line before and after if available)
+                const contextLines = [];
+                if (i > 0) contextLines.push(lines[i - 1]);
+                contextLines.push(line);
+                if (i < lines.length - 1) contextLines.push(lines[i + 1]);
+                const relativePath = (0,external_node_path_.relative)(targetDir, file);
+                references.push({
+                    target,
+                    file: relativePath,
+                    line: i + 1,
+                    context: contextLines.join("\n")
+                });
+            }
+        }
+        return references;
+    }
+}
+/**
+ * Creates and returns the default instruction analysis gateway
+ */ function createInstructionAnalysisGateway() {
+    return new FileSystemInstructionAnalysisGateway();
+}
+
+;// CONCATENATED MODULE: ./src/entities/feedback-loop.ts
+/**
+ * Core domain entities for SDLC feedback loop discovery and validation.
+ * These types represent scripts, tools, and their mapping to SDLC phases.
+ */ /**
+ * SDLC feedback loop phases that scripts and tools support
+ */ /**
+ * Maps common script names to SDLC phases
+ */ const SCRIPT_PHASE_MAPPING = {
+    test: "test",
+    "test:unit": "test",
+    "test:integration": "test",
+    "test:e2e": "test",
+    "test:watch": "test",
+    build: "build",
+    compile: "build",
+    bundle: "build",
+    lint: "lint",
+    "lint:fix": "lint",
+    "lint:check": "lint",
+    "lint:workflows": "lint",
+    "lint:yaml": "lint",
+    format: "format",
+    "format:check": "format",
+    "format:fix": "format",
+    prettier: "format",
+    "prettier:check": "format",
+    "prettier:fix": "format",
+    audit: "security",
+    "audit:fix": "security",
+    security: "security",
+    deploy: "deploy",
+    publish: "deploy",
+    release: "deploy",
+    install: "install",
+    ci: "install",
+    dev: "dev",
+    start: "dev",
+    serve: "dev"
+};
+/**
+ * Scripts that are considered mandatory for agent feedback loops
+ */ const MANDATORY_SCRIPT_NAMES = (/* unused pure expression or super */ null && ([
+    "test",
+    "build",
+    "lint",
+    "format"
+]));
+/**
+ * Determines the SDLC phase for a script based on its name and command
+ */ function determineScriptPhase(scriptName, command) {
+    // Check exact name match first
+    const exactMatch = SCRIPT_PHASE_MAPPING[scriptName];
+    if (exactMatch) {
+        return exactMatch;
+    }
+    // Check if name starts with a known phase
+    for (const [pattern, phase] of Object.entries(SCRIPT_PHASE_MAPPING)){
+        // Skip patterns we've already handled as exact matches
+        if (pattern === scriptName) {
+            continue;
+        }
+        if (!scriptName.startsWith(pattern)) {
+            continue;
+        }
+        // If the pattern itself includes a separator (e.g. "test:unit"),
+        // allow simple prefix matching (handles "test:unit:watch", etc.)
+        const lastCharOfPattern = pattern.charAt(pattern.length - 1);
+        if (lastCharOfPattern === ":") {
+            return phase;
+        }
+        // For generic patterns like "test" or "build", require that the next
+        // character after the pattern is a colon to avoid matching names
+        // like "test-utils" or "build-tools".
+        const nextChar = scriptName.charAt(pattern.length);
+        if (nextChar === ":") {
+            return phase;
+        }
+    }
+    // Analyze command content for hints (not script name, since we already checked patterns)
+    const lowerCommand = command.toLowerCase();
+    if (lowerCommand.includes("test") || lowerCommand.includes("vitest") || lowerCommand.includes("jest") || lowerCommand.includes("mocha") || lowerCommand.includes("ava")) {
+        return "test";
+    }
+    if (lowerCommand.includes("build") || lowerCommand.includes("compile") || lowerCommand.includes("webpack") || lowerCommand.includes("rspack") || lowerCommand.includes("rollup") || lowerCommand.includes("vite build")) {
+        return "build";
+    }
+    if (lowerCommand.includes("lint") || lowerCommand.includes("eslint") || lowerCommand.includes("biome") || lowerCommand.includes("tslint") || lowerCommand.includes("actionlint") || lowerCommand.includes("yamllint")) {
+        return "lint";
+    }
+    if (lowerCommand.includes("prettier") || lowerCommand.includes("format")) {
+        return "format";
+    }
+    if (lowerCommand.includes("audit") || lowerCommand.includes("snyk") || lowerCommand.includes("npm-audit")) {
+        return "security";
+    }
+    return "unknown";
+}
+/**
+ * Determines if a script is mandatory based on its phase
+ */ function isScriptMandatory(phase) {
+    return [
+        "test",
+        "build",
+        "lint",
+        "format"
+    ].includes(phase);
+}
+
+;// CONCATENATED MODULE: ./src/gateways/script-discovery-gateway.ts
+/**
+ * Gateway for discovering scripts from package.json manifests
+ */ 
+
+
+
+/**
+ * File system implementation of script discovery gateway
+ */ class FileSystemScriptDiscoveryGateway {
+    async discoverScripts(targetDir) {
+        const packageJsonPath = (0,external_node_path_.join)(targetDir, "package.json");
+        if (!await file_system_utils_fileExists(packageJsonPath)) {
+            return [];
+        }
+        try {
+            const content = await (0,promises_.readFile)(packageJsonPath, "utf-8");
+            const packageJson = JSON.parse(content);
+            if (!packageJson.scripts) {
+                return [];
+            }
+            const scripts = [];
+            for (const [name, command] of Object.entries(packageJson.scripts)){
+                const phase = determineScriptPhase(name, command);
+                const isMandatory = isScriptMandatory(phase);
+                scripts.push({
+                    name,
+                    command,
+                    phase,
+                    isMandatory
+                });
+            }
+            return scripts;
+        } catch  {
+            // If package.json is malformed or cannot be parsed, return empty array
+            return [];
+        }
+    }
+}
+/**
+ * Creates and returns the default script discovery gateway
+ */ function createScriptDiscoveryGateway() {
+    return new FileSystemScriptDiscoveryGateway();
+}
+
 ;// CONCATENATED MODULE: ./src/gateways/skill-file-gateway.ts
 /**
  * Gateway for skill file system operations.
@@ -45238,6 +45524,160 @@ async function watchConfig(options) {
     return new FileSystemSkillFileGateway();
 }
 
+;// CONCATENATED MODULE: ./src/gateways/tool-discovery-gateway.ts
+/**
+ * Gateway for discovering CLI tools and commands from GitHub Actions workflows
+ */ 
+
+
+
+
+/**
+ * File system implementation of tool discovery gateway
+ */ class FileSystemToolDiscoveryGateway {
+    async discoverTools(targetDir) {
+        const workflowsDir = (0,external_node_path_.join)(targetDir, ".github", "workflows");
+        if (!await file_system_utils_fileExists(workflowsDir)) {
+            return [];
+        }
+        const files = await (0,promises_.readdir)(workflowsDir);
+        const yamlFiles = files.filter((f)=>f.endsWith(".yml") || f.endsWith(".yaml"));
+        const allTools = [];
+        for (const file of yamlFiles){
+            const filePath = (0,external_node_path_.join)(workflowsDir, file);
+            try {
+                const content = await (0,promises_.readFile)(filePath, "utf-8");
+                const workflow = (0,yaml_dist.parse)(content);
+                const tools = this.extractToolsFromWorkflow(workflow, file);
+                allTools.push(...tools);
+            } catch  {
+            // Skip files that can't be parsed as valid YAML
+            }
+        }
+        return this.deduplicateTools(allTools);
+    }
+    extractToolsFromWorkflow(workflow, sourceFile) {
+        const tools = [];
+        if (!workflow || typeof workflow !== "object") {
+            return tools;
+        }
+        const jobs = workflow.jobs;
+        if (!jobs || typeof jobs !== "object") {
+            return tools;
+        }
+        for (const job of Object.values(jobs)){
+            if (!job || typeof job !== "object") {
+                continue;
+            }
+            const steps = job.steps;
+            if (!Array.isArray(steps)) {
+                continue;
+            }
+            for (const step of steps){
+                if (!step || typeof step !== "object") {
+                    continue;
+                }
+                const stepObj = step;
+                const run = stepObj.run;
+                if (typeof run === "string") {
+                    // Extract tools from run commands
+                    const extractedTools = this.extractToolsFromRunCommand(run, sourceFile);
+                    tools.push(...extractedTools);
+                }
+            }
+        }
+        return tools;
+    }
+    extractToolsFromRunCommand(runCommand, sourceFile) {
+        const tools = [];
+        // Split by newlines and pipe tokens with surrounding whitespace to handle
+        // multi-line and piped commands without breaking on constructs like "cmd || true"
+        const commands = runCommand.split(/\n|\s\|\s/).map((c)=>c.trim()).filter((c)=>c.length > 0 && !c.startsWith("#"));
+        for (const command of commands){
+            // Extract the base command (first word)
+            const parts = command.split(/\s+/);
+            const baseCommand = parts[0];
+            // Skip shell built-ins and common utilities
+            if (this.isShellBuiltin(baseCommand)) {
+                continue;
+            }
+            // Determine tool name and full command
+            let toolName;
+            const fullCommand = command;
+            // Handle special cases like "npm run", "mise run", etc.
+            if (parts.length >= 2 && (baseCommand === "npm" || baseCommand === "mise") && parts[1] === "run") {
+                if (parts.length >= 3 && parts[2]) {
+                    // "npm run test" -> name: "npm run test"
+                    toolName = parts.slice(0, 3).join(" ");
+                } else {
+                    // Handle commands like "npm run" without a script name
+                    toolName = parts.slice(0, 2).join(" ");
+                }
+            } else if (parts.length >= 2) {
+                // For most tools, include the subcommand for better specificity
+                // e.g., "npm test", "npx biome", "pnpm lint"
+                toolName = parts.slice(0, 2).join(" ");
+            } else {
+                // Fallback to the base command if no subcommand is present
+                toolName = baseCommand;
+            }
+            const phase = this.determineToolPhase(toolName, fullCommand);
+            const isMandatory = isScriptMandatory(phase);
+            tools.push({
+                name: toolName,
+                fullCommand,
+                phase,
+                isMandatory,
+                sourceWorkflow: sourceFile
+            });
+        }
+        return tools;
+    }
+    isShellBuiltin(command) {
+        const builtins = [
+            "cd",
+            "echo",
+            "mkdir",
+            "rm",
+            "cp",
+            "mv",
+            "test",
+            "[",
+            "if",
+            "then",
+            "else",
+            "fi",
+            "for",
+            "while",
+            "do",
+            "done",
+            "case",
+            "esac"
+        ];
+        return builtins.includes(command);
+    }
+    determineToolPhase(toolName, fullCommand) {
+        // Use the same logic as script phase determination
+        return determineScriptPhase(toolName, fullCommand);
+    }
+    deduplicateTools(tools) {
+        const seen = new Map();
+        for (const tool of tools){
+            // Use full command as key for deduplication
+            const key = tool.fullCommand;
+            if (!seen.has(key)) {
+                seen.set(key, tool);
+            }
+        }
+        return Array.from(seen.values());
+    }
+}
+/**
+ * Creates and returns the default tool discovery gateway
+ */ function createToolDiscoveryGateway() {
+    return new FileSystemToolDiscoveryGateway();
+}
+
 ;// CONCATENATED MODULE: ./src/use-cases/setup-step-discovery.ts
 /**
  * Use case for discovering setup steps in workflows.
@@ -45536,6 +45976,9 @@ async function watchConfig(options) {
 
 
 
+
+
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/types.ts
 /**
  * Shared types and utilities for MCP tool handlers.
@@ -46611,6 +47054,140 @@ function getGlobalWacContext() {
     });
 };
 
+;// CONCATENATED MODULE: ./src/use-cases/discover-feedback-loops.ts
+/**
+ * Use case for discovering and analyzing SDLC feedback loops
+ */ /**
+ * Use case for discovering scripts and tools that form SDLC feedback loops
+ */ class DiscoverFeedbackLoopsUseCase {
+    scriptGateway;
+    toolGateway;
+    packageManagerGateway;
+    constructor(scriptGateway, toolGateway, packageManagerGateway){
+        this.scriptGateway = scriptGateway;
+        this.toolGateway = toolGateway;
+        this.packageManagerGateway = packageManagerGateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
+        }
+        // Discover scripts from package.json
+        const scripts = await this.scriptGateway.discoverScripts(input.targetDir);
+        // Discover tools from GitHub Actions workflows
+        const tools = await this.toolGateway.discoverTools(input.targetDir);
+        // Detect package manager
+        const packageManagers = await this.packageManagerGateway.detectPackageManagers(input.targetDir);
+        const primaryPackageManager = packageManagers.length > 0 ? packageManagers[0].type : undefined;
+        const feedbackLoops = {
+            scripts: this.sortByPhase(scripts),
+            tools: this.sortByPhase(tools),
+            packageManager: primaryPackageManager
+        };
+        return {
+            feedbackLoops
+        };
+    }
+    /**
+     * Sorts scripts or tools by phase priority
+     * Order: test, lint, format, build, security, install, dev, deploy, unknown
+     */ sortByPhase(items) {
+        const phasePriority = {
+            test: 1,
+            lint: 2,
+            format: 3,
+            build: 4,
+            security: 5,
+            install: 6,
+            dev: 7,
+            deploy: 8,
+            unknown: 9
+        };
+        return [
+            ...items
+        ].sort((a, b)=>{
+            const priorityA = phasePriority[a.phase] ?? 10;
+            const priorityB = phasePriority[b.phase] ?? 10;
+            return priorityA - priorityB;
+        });
+    }
+}
+
+;// CONCATENATED MODULE: ./src/mcp/tools/discover-feedback-loops.ts
+/**
+ * MCP tool handler for discovering scripts and CLI tools.
+ */ 
+
+
+
+
+/**
+ * Discovers npm scripts from package.json and CLI tools from GitHub Actions workflows,
+ * mapping them to SDLC feedback loop phases (test, build, lint, format, etc.).
+ */ const discoverFeedbackLoopsHandler = async (args)=>{
+    const dir = args.targetDir || process.cwd();
+    try {
+        // Create gateways
+        const scriptGateway = createScriptDiscoveryGateway();
+        const toolGateway = createToolDiscoveryGateway();
+        const environmentGateway = createEnvironmentGateway();
+        // Adapter for package manager gateway
+        const packageManagerGateway = {
+            async detectPackageManagers (targetDir) {
+                const env = await environmentGateway.detectEnvironment(targetDir);
+                return env.packageManagers;
+            }
+        };
+        // Create use case
+        const useCase = new DiscoverFeedbackLoopsUseCase(scriptGateway, toolGateway, packageManagerGateway);
+        // Execute discovery
+        const result = await useCase.execute({
+            targetDir: dir
+        });
+        const { scripts, tools, packageManager } = result.feedbackLoops;
+        // Group by phase for better readability
+        const scriptsByPhase = scripts.reduce((acc, script)=>{
+            if (!acc[script.phase]) {
+                acc[script.phase] = [];
+            }
+            acc[script.phase].push({
+                name: script.name,
+                command: script.command,
+                mandatory: script.isMandatory
+            });
+            return acc;
+        }, {});
+        const toolsByPhase = tools.reduce((acc, tool)=>{
+            if (!acc[tool.phase]) {
+                acc[tool.phase] = [];
+            }
+            acc[tool.phase].push({
+                name: tool.name,
+                command: tool.fullCommand,
+                mandatory: tool.isMandatory,
+                source: tool.sourceWorkflow
+            });
+            return acc;
+        }, {});
+        const mandatoryScripts = scripts.filter((s)=>s.isMandatory);
+        const mandatoryTools = tools.filter((t)=>t.isMandatory);
+        return successResponse({
+            summary: {
+                totalScripts: scripts.length,
+                totalTools: tools.length,
+                mandatoryScripts: mandatoryScripts.length,
+                mandatoryTools: mandatoryTools.length,
+                packageManager: packageManager || "none detected"
+            },
+            scriptsByPhase,
+            toolsByPhase,
+            message: `Discovered ${scripts.length} package.json script(s) and ${tools.length} CLI tool(s) from workflows`
+        });
+    } catch (error) {
+        return types_errorResponse(`Failed to discover feedback loops: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+};
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/discover-workflow-setup-actions.ts
 /**
  * MCP tool handler for discovering setup actions in existing workflows.
@@ -46730,6 +47307,162 @@ function getGlobalWacContext() {
     });
 };
 
+;// CONCATENATED MODULE: ./src/use-cases/validate-instruction-coverage.ts
+/**
+ * Use case for validating instruction coverage of feedback loops
+ */ /**
+ * Use case for validating that repository instructions cover mandatory feedback loops
+ */ class ValidateInstructionCoverageUseCase {
+    discoverFeedbackLoops;
+    instructionGateway;
+    constructor(discoverFeedbackLoops, instructionGateway){
+        this.discoverFeedbackLoops = discoverFeedbackLoops;
+        this.instructionGateway = instructionGateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
+        }
+        // First, discover all feedback loops
+        const discoveryResult = await this.discoverFeedbackLoops.execute({
+            targetDir: input.targetDir
+        });
+        const { scripts, tools, packageManager } = discoveryResult.feedbackLoops;
+        // Analyze instruction coverage
+        const coverage = await this.instructionGateway.analyzeCoverage(input.targetDir, scripts, tools);
+        // Generate suggestions for missing documentation
+        const suggestions = this.generateSuggestions(coverage, packageManager || "npm");
+        return {
+            coverage,
+            hasFullCoverage: coverage.summary.coveragePercentage === 100,
+            suggestions
+        };
+    }
+    generateSuggestions(coverage, packageManager) {
+        const suggestions = [];
+        if (coverage.missingInInstructions.length === 0) {
+            suggestions.push("✅ All mandatory feedback loops are documented in instructions");
+            return suggestions;
+        }
+        suggestions.push(`⚠️  ${coverage.missingInInstructions.length} mandatory feedback loop(s) are not documented:`);
+        suggestions.push("");
+        // Group by phase
+        const byPhase = new Map();
+        for (const item of coverage.missingInInstructions){
+            const existing = byPhase.get(item.phase) || [];
+            existing.push(item);
+            byPhase.set(item.phase, existing);
+        }
+        // Generate suggestions per phase
+        for (const [phase, items] of byPhase.entries()){
+            suggestions.push(`${phase.toUpperCase()} phase:`);
+            for (const item of items){
+                if ("command" in item) {
+                    // It's a script
+                    suggestions.push(`  - Document "${packageManager} run ${item.name}" (runs: ${item.command})`);
+                } else {
+                    // It's a tool
+                    suggestions.push(`  - Document "${item.fullCommand}"`);
+                }
+            }
+            suggestions.push("");
+        }
+        suggestions.push("Consider adding these to .github/copilot-instructions.md");
+        suggestions.push("or creating dedicated instruction files in .github/instructions/");
+        return suggestions;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/mcp/tools/validate-instruction-coverage.ts
+/**
+ * MCP tool handler for validating instruction coverage of feedback loops.
+ */ 
+
+
+
+
+
+
+/**
+ * Validates that repository instructions (.github/copilot-instructions.md and .github/instructions/*.md)
+ * document all mandatory feedback loop scripts and tools.
+ * Returns coverage percentage and suggestions for missing documentation.
+ */ const validateInstructionCoverageHandler = async (args)=>{
+    const dir = args.targetDir || process.cwd();
+    try {
+        // Create gateways
+        const scriptGateway = createScriptDiscoveryGateway();
+        const toolGateway = createToolDiscoveryGateway();
+        const environmentGateway = createEnvironmentGateway();
+        const instructionGateway = createInstructionAnalysisGateway();
+        // Adapter for package manager gateway
+        const packageManagerGateway = {
+            async detectPackageManagers (targetDir) {
+                const env = await environmentGateway.detectEnvironment(targetDir);
+                return env.packageManagers;
+            }
+        };
+        // Create use cases
+        const discoverUseCase = new DiscoverFeedbackLoopsUseCase(scriptGateway, toolGateway, packageManagerGateway);
+        const validateUseCase = new ValidateInstructionCoverageUseCase(discoverUseCase, instructionGateway);
+        // Execute validation
+        const result = await validateUseCase.execute({
+            targetDir: dir
+        });
+        const { coverage, hasFullCoverage, suggestions } = result;
+        // Format missing items for better readability
+        const missing = coverage.missingInInstructions.map((item)=>{
+            if ("command" in item) {
+                // Script
+                return {
+                    type: "script",
+                    name: item.name,
+                    phase: item.phase,
+                    command: item.command
+                };
+            }
+            // Tool
+            return {
+                type: "tool",
+                name: item.name,
+                phase: item.phase,
+                command: item.fullCommand
+            };
+        });
+        // Format documented items
+        const documented = coverage.documentedInInstructions.map((item)=>{
+            if ("command" in item) {
+                // Script
+                return {
+                    type: "script",
+                    name: item.name,
+                    phase: item.phase
+                };
+            }
+            // Tool
+            return {
+                type: "tool",
+                name: item.name,
+                phase: item.phase
+            };
+        });
+        return successResponse({
+            hasFullCoverage,
+            summary: {
+                totalMandatory: coverage.summary.totalMandatory,
+                totalDocumented: coverage.summary.totalDocumented,
+                coveragePercentage: coverage.summary.coveragePercentage
+            },
+            missing,
+            documented,
+            suggestions,
+            message: hasFullCoverage ? "✅ All mandatory feedback loops are documented" : `⚠️  ${coverage.summary.coveragePercentage.toFixed(1)}% coverage - ${missing.length} mandatory items not documented`
+        });
+    } catch (error) {
+        return types_errorResponse(`Failed to validate instruction coverage: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+};
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/index.ts
 /**
  * MCP tool handlers module exports.
@@ -46741,6 +47474,8 @@ function getGlobalWacContext() {
 
 
 
+
+
 ;// CONCATENATED MODULE: ./src/mcp/server.ts
 /**
  * MCP Server for Copilot Setup Steps workflow management.
@@ -46792,6 +47527,18 @@ function getGlobalWacContext() {
         handler: discoverWorkflowSetupActionsHandler,
         inputSchema: targetDirInputSchema
     },
+    {
+        name: "discover_feedback_loops",
+        description: "Discover npm scripts from package.json and CLI tools from GitHub Actions workflows, mapping them to SDLC feedback loop phases (test, build, lint, format, security, etc.)",
+        handler: discoverFeedbackLoopsHandler,
+        inputSchema: targetDirInputSchema
+    },
+    {
+        name: "validate_instruction_coverage",
+        description: "Validate that repository instructions (.github/copilot-instructions.md and .github/instructions/*.md) document all mandatory feedback loop scripts and tools. Returns coverage percentage and suggestions for missing documentation.",
+        handler: validateInstructionCoverageHandler,
+        inputSchema: targetDirInputSchema
+    },
     {
         name: "read_copilot_setup_workflow",
         description: "Read the existing Copilot Setup Steps workflow (copilot-setup-steps.yml or .yaml) from a target directory",