@rigour-labs/mcp 5.2.9 → 5.3.1

package/dist/utils/context-telemetry.d.ts

@@ -0,0 +1,27 @@
+export type CacheStatus = 'exact-hit' | 'semantic-hit' | 'partial-hit' | 'miss' | 'none';
+export type TelemetryMeta = {
+    candidateTokens: number;
+    returnedTokens: number;
+    cacheStatus: CacheStatus;
+    deduplicatedTokens?: number;
+    isEstimated?: boolean;
+};
+export type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: boolean;
+    _shouldContinue?: boolean;
+    _rigour_report?: unknown;
+    _meta?: unknown;
+    _telemetry?: TelemetryMeta;
+};
+export declare function buildTelemetryMeta(opts: {
+    candidateText: string;
+    returnedText: string;
+    cacheStatus: CacheStatus;
+    deduplicatedTokens?: number;
+}): TelemetryMeta;
+/** Resolve a short commit/ref fingerprint for cache keys. */
+export declare function getWorkspaceCommitSha(cwd: string): Promise<string>;

package/dist/utils/context-telemetry.js

@@ -0,0 +1,34 @@
+/**
+ * MCP tool telemetry metadata — honest token accounting from handlers.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { estimateTokenCount } from '@rigour-labs/core';
+export function buildTelemetryMeta(opts) {
+    return {
+        candidateTokens: estimateTokenCount(opts.candidateText),
+        returnedTokens: estimateTokenCount(opts.returnedText),
+        cacheStatus: opts.cacheStatus,
+        deduplicatedTokens: opts.deduplicatedTokens ?? 0,
+        isEstimated: true,
+    };
+}
+/** Resolve a short commit/ref fingerprint for cache keys. */
+export async function getWorkspaceCommitSha(cwd) {
+    try {
+        const headPath = path.join(cwd, '.git', 'HEAD');
+        if (!await fs.pathExists(headPath))
+            return 'workspace';
+        const head = (await fs.readFile(headPath, 'utf-8')).trim();
+        if (head.startsWith('ref:')) {
+            const refPath = path.join(cwd, '.git', head.slice(5).trim());
+            if (await fs.pathExists(refPath)) {
+                return (await fs.readFile(refPath, 'utf-8')).trim().slice(0, 12);
+            }
+        }
+        return head.slice(0, 12);
+    }
+    catch {
+        return 'workspace';
+    }
+}

package/package.json

@@ -1,76 +1,76 @@
 {
-  "name": "@rigour-labs/mcp",
-  "version": "5.2.9",
-  "description": "MCP server + live dashboard for AI code governance — OWASP LLM Top 10 (10/10), real-time MCP App UI, 25+ security patterns, Bayesian learning Brain, hallucinated import detection, multi-agent governance. Works with Claude, Cursor, VS Code, ChatGPT, Goose, Windsurf. Industry presets for HIPAA, SOC2, FedRAMP.",
-  "license": "MIT",
-  "homepage": "https://rigour.run",
-  "icon": "https://raw.githubusercontent.com/rigour-labs/rigour/main/docs/assets/icon.svg",
-  "keywords": [
-    "ai",
-    "llm",
-    "mcp",
-    "mcp-app",
-    "mcp-server",
-    "model-context-protocol",
-    "ai-agent",
-    "ai-code-governance",
-    "owasp-llm-top-10",
-    "bayesian-learning",
-    "real-time-hooks",
-    "security-patterns",
-    "hallucinated-imports",
-    "vibe-coding",
-    "claude",
-    "cursor",
-    "cline",
-    "windsurf",
-    "copilot",
-    "gemini",
-    "codex",
-    "chatgpt",
-    "goose",
-    "multi-agent-governance",
-    "quality-gates",
-    "fix-packets",
-    "agent-governance",
-    "drift-detection",
-    "live-dashboard",
-    "code-quality",
-    "ai-safety",
-    "deep-learning",
-    "rlaif"
-  ],
-  "type": "module",
-  "mcpName": "io.github.rigour-labs/rigour",
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "bin": {
-    "rigour-mcp": "dist/index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rigour-labs/rigour"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.2",
-    "execa": "^8.0.1",
-    "fs-extra": "^11.2.0",
-    "yaml": "^2.8.2",
-    "@rigour-labs/core": "5.2.9"
-  },
-  "devDependencies": {
-    "@types/node": "^25.0.3",
-    "vitest": "^1.0.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "test": "vitest run"
-  }
-}
+    "name": "@rigour-labs/mcp",
+    "version": "5.3.1",
+    "description": "MCP server + live dashboard for AI code governance — OWASP LLM Top 10 (10/10), real-time MCP App UI, 25+ security patterns, Bayesian learning Brain, hallucinated import detection, multi-agent governance. Works with Claude, Cursor, VS Code, ChatGPT, Goose, Windsurf. Industry presets for HIPAA, SOC2, FedRAMP.",
+    "license": "MIT",
+    "homepage": "https://rigour.run",
+    "icon": "https://raw.githubusercontent.com/rigour-labs/rigour/main/docs/assets/icon.svg",
+    "keywords": [
+        "ai",
+        "llm",
+        "mcp",
+        "mcp-app",
+        "mcp-server",
+        "model-context-protocol",
+        "ai-agent",
+        "ai-code-governance",
+        "owasp-llm-top-10",
+        "bayesian-learning",
+        "real-time-hooks",
+        "security-patterns",
+        "hallucinated-imports",
+        "vibe-coding",
+        "claude",
+        "cursor",
+        "cline",
+        "windsurf",
+        "copilot",
+        "gemini",
+        "codex",
+        "chatgpt",
+        "goose",
+        "multi-agent-governance",
+        "quality-gates",
+        "fix-packets",
+        "agent-governance",
+        "drift-detection",
+        "live-dashboard",
+        "code-quality",
+        "ai-safety",
+        "deep-learning",
+        "rlaif"
+    ],
+    "type": "module",
+    "mcpName": "io.github.rigour-labs/rigour",
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "bin": {
+        "rigour-mcp": "dist/index.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/rigour-labs/rigour"
+    },
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/index.js",
+        "test": "vitest run"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.25.2",
+        "@rigour-labs/core": "workspace:*",
+        "execa": "^8.0.1",
+        "fs-extra": "^11.2.0",
+        "yaml": "^2.8.2"
+    },
+    "devDependencies": {
+        "@types/node": "^25.0.3",
+        "vitest": "^1.0.0"
+    }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Ashutosh (https://github.com/erashu212), Rigour Labs.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.test.js

@@ -1,254 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as os from 'os';
-// Mock the MCP tool handlers for testing
-// In a real scenario, we'd refactor index.ts to export testable functions
-describe('MCP Frontier Tools', () => {
-    let testDir;
-    let rigourDir;
-    beforeEach(async () => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-test-'));
-        rigourDir = path.join(testDir, '.rigour');
-        await fs.ensureDir(rigourDir);
-    });
-    afterEach(async () => {
-        await fs.remove(testDir);
-    });
-    describe('rigour_agent_register', () => {
-        const sessionPath = () => path.join(rigourDir, 'agent-session.json');
-        async function registerAgent(agentId, taskScope) {
-            let session = { agents: [], startedAt: new Date().toISOString() };
-            if (await fs.pathExists(sessionPath())) {
-                session = JSON.parse(await fs.readFile(sessionPath(), 'utf-8'));
-            }
-            const existingIdx = session.agents.findIndex((a) => a.agentId === agentId);
-            if (existingIdx >= 0) {
-                session.agents[existingIdx] = {
-                    agentId,
-                    taskScope,
-                    registeredAt: session.agents[existingIdx].registeredAt,
-                    lastCheckpoint: new Date().toISOString(),
-                };
-            }
-            else {
-                session.agents.push({
-                    agentId,
-                    taskScope,
-                    registeredAt: new Date().toISOString(),
-                    lastCheckpoint: new Date().toISOString(),
-                });
-            }
-            // Check for scope conflicts
-            const conflicts = [];
-            for (const agent of session.agents) {
-                if (agent.agentId !== agentId) {
-                    for (const scope of taskScope) {
-                        if (agent.taskScope.includes(scope)) {
-                            conflicts.push(`${agent.agentId} also claims "${scope}"`);
-                        }
-                    }
-                }
-            }
-            await fs.writeFile(sessionPath(), JSON.stringify(session, null, 2));
-            return { session, conflicts };
-        }
-        it('should register a new agent', async () => {
-            const { session, conflicts } = await registerAgent('agent-a', ['src/api/**']);
-            expect(session.agents).toHaveLength(1);
-            expect(session.agents[0].agentId).toBe('agent-a');
-            expect(conflicts).toHaveLength(0);
-        });
-        it('should detect scope conflicts', async () => {
-            await registerAgent('agent-a', ['src/api/**', 'src/utils/**']);
-            const { conflicts } = await registerAgent('agent-b', ['src/api/**']);
-            expect(conflicts).toHaveLength(1);
-            expect(conflicts[0]).toContain('agent-a');
-        });
-        it('should update existing agent registration', async () => {
-            await registerAgent('agent-a', ['src/api/**']);
-            const { session } = await registerAgent('agent-a', ['src/api/**', 'tests/**']);
-            expect(session.agents).toHaveLength(1);
-            expect(session.agents[0].taskScope).toContain('tests/**');
-        });
-        it('should support multiple agents', async () => {
-            await registerAgent('agent-a', ['src/frontend/**']);
-            await registerAgent('agent-b', ['src/backend/**']);
-            const { session } = await registerAgent('agent-c', ['src/shared/**']);
-            expect(session.agents).toHaveLength(3);
-        });
-    });
-    describe('rigour_checkpoint', () => {
-        const checkpointPath = () => path.join(rigourDir, 'checkpoint-session.json');
-        async function recordCheckpoint(progressPct, qualityScore, summary = 'Test') {
-            let session = {
-                sessionId: `chk-session-${Date.now()}`,
-                startedAt: new Date().toISOString(),
-                checkpoints: [],
-                status: 'active'
-            };
-            if (await fs.pathExists(checkpointPath())) {
-                session = JSON.parse(await fs.readFile(checkpointPath(), 'utf-8'));
-            }
-            const warnings = [];
-            if (qualityScore < 80) {
-                warnings.push(`Quality score ${qualityScore}% is below threshold 80%`);
-            }
-            // Drift detection
-            if (session.checkpoints.length >= 2) {
-                const recentScores = session.checkpoints.slice(-3).map((cp) => cp.qualityScore);
-                const avgRecent = recentScores.reduce((a, b) => a + b, 0) / recentScores.length;
-                if (qualityScore < avgRecent - 10) {
-                    warnings.push(`Drift detected: quality dropped from avg ${avgRecent.toFixed(0)}% to ${qualityScore}%`);
-                }
-            }
-            const checkpoint = {
-                checkpointId: `cp-${Date.now()}`,
-                timestamp: new Date().toISOString(),
-                progressPct,
-                summary,
-                qualityScore,
-                warnings,
-            };
-            session.checkpoints.push(checkpoint);
-            await fs.writeFile(checkpointPath(), JSON.stringify(session, null, 2));
-            return { checkpoint, warnings, session };
-        }
-        it('should record a checkpoint', async () => {
-            const { checkpoint, session } = await recordCheckpoint(25, 85, 'Initial work');
-            expect(checkpoint.progressPct).toBe(25);
-            expect(checkpoint.qualityScore).toBe(85);
-            expect(session.checkpoints).toHaveLength(1);
-        });
-        it('should warn on low quality score', async () => {
-            const { warnings } = await recordCheckpoint(50, 65, 'Struggling');
-            expect(warnings.some(w => w.includes('below threshold'))).toBe(true);
-        });
-        it('should detect quality drift', async () => {
-            await recordCheckpoint(20, 90);
-            await recordCheckpoint(40, 88);
-            await recordCheckpoint(60, 85);
-            const { warnings } = await recordCheckpoint(80, 70);
-            expect(warnings.some(w => w.includes('Drift detected'))).toBe(true);
-        });
-        it('should track multiple checkpoints', async () => {
-            await recordCheckpoint(25, 90);
-            await recordCheckpoint(50, 88);
-            await recordCheckpoint(75, 92);
-            const { session } = await recordCheckpoint(100, 95);
-            expect(session.checkpoints).toHaveLength(4);
-        });
-    });
-    describe('rigour_handoff', () => {
-        const handoffPath = () => path.join(rigourDir, 'handoffs.jsonl');
-        async function createHandoff(fromAgentId, toAgentId, taskDescription, filesInScope = []) {
-            const handoff = {
-                handoffId: `handoff-${Date.now()}`,
-                timestamp: new Date().toISOString(),
-                fromAgentId,
-                toAgentId,
-                taskDescription,
-                filesInScope,
-                status: 'pending',
-            };
-            await fs.appendFile(handoffPath(), JSON.stringify(handoff) + '\n');
-            return handoff;
-        }
-        it('should create a handoff record', async () => {
-            const handoff = await createHandoff('agent-a', 'agent-b', 'Complete API integration');
-            expect(handoff.fromAgentId).toBe('agent-a');
-            expect(handoff.toAgentId).toBe('agent-b');
-            expect(handoff.status).toBe('pending');
-        });
-        it('should include files in scope', async () => {
-            const handoff = await createHandoff('agent-a', 'agent-b', 'Fix tests', ['tests/api.test.ts', 'tests/utils.test.ts']);
-            expect(handoff.filesInScope).toHaveLength(2);
-        });
-        it('should append multiple handoffs', async () => {
-            await createHandoff('agent-a', 'agent-b', 'Task 1');
-            await createHandoff('agent-b', 'agent-c', 'Task 2');
-            const content = await fs.readFile(handoffPath(), 'utf-8');
-            const lines = content.trim().split('\n');
-            expect(lines).toHaveLength(2);
-        });
-    });
-    describe('rigour_agent_deregister', () => {
-        const sessionPath = () => path.join(rigourDir, 'agent-session.json');
-        async function deregisterAgent(agentId) {
-            if (!await fs.pathExists(sessionPath())) {
-                return { success: false, message: 'No active session' };
-            }
-            const session = JSON.parse(await fs.readFile(sessionPath(), 'utf-8'));
-            const initialCount = session.agents.length;
-            session.agents = session.agents.filter((a) => a.agentId !== agentId);
-            await fs.writeFile(sessionPath(), JSON.stringify(session, null, 2));
-            return {
-                success: session.agents.length < initialCount,
-                remainingAgents: session.agents.length,
-            };
-        }
-        it('should remove an agent from session', async () => {
-            // First register
-            const session = { agents: [{ agentId: 'agent-a', taskScope: [] }], startedAt: new Date().toISOString() };
-            await fs.writeFile(sessionPath(), JSON.stringify(session));
-            const result = await deregisterAgent('agent-a');
-            expect(result.success).toBe(true);
-            expect(result.remainingAgents).toBe(0);
-        });
-        it('should handle non-existent agent', async () => {
-            const session = { agents: [{ agentId: 'agent-a', taskScope: [] }], startedAt: new Date().toISOString() };
-            await fs.writeFile(sessionPath(), JSON.stringify(session));
-            const result = await deregisterAgent('agent-b');
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('rigour_handoff_accept', () => {
-        const handoffPath = () => path.join(rigourDir, 'handoffs.jsonl');
-        async function acceptHandoff(handoffId, agentId) {
-            if (!await fs.pathExists(handoffPath())) {
-                return { success: false, message: 'No handoffs found' };
-            }
-            const content = await fs.readFile(handoffPath(), 'utf-8');
-            const handoffs = content.trim().split('\n').map(line => JSON.parse(line));
-            const handoff = handoffs.find(h => h.handoffId === handoffId);
-            if (!handoff) {
-                return { success: false, message: 'Handoff not found' };
-            }
-            if (handoff.toAgentId !== agentId) {
-                return { success: false, message: 'Agent not the intended recipient' };
-            }
-            handoff.status = 'accepted';
-            handoff.acceptedAt = new Date().toISOString();
-            // Rewrite the file with updated handoff
-            const updatedContent = handoffs.map(h => JSON.stringify(h)).join('\n') + '\n';
-            await fs.writeFile(handoffPath(), updatedContent);
-            return { success: true, handoff };
-        }
-        it('should accept a pending handoff', async () => {
-            const handoff = {
-                handoffId: 'handoff-123',
-                fromAgentId: 'agent-a',
-                toAgentId: 'agent-b',
-                taskDescription: 'Test task',
-                status: 'pending',
-            };
-            await fs.writeFile(handoffPath(), JSON.stringify(handoff) + '\n');
-            const result = await acceptHandoff('handoff-123', 'agent-b');
-            expect(result.success).toBe(true);
-            expect(result.handoff?.status).toBe('accepted');
-        });
-        it('should reject if agent is not recipient', async () => {
-            const handoff = {
-                handoffId: 'handoff-123',
-                fromAgentId: 'agent-a',
-                toAgentId: 'agent-b',
-                taskDescription: 'Test task',
-                status: 'pending',
-            };
-            await fs.writeFile(handoffPath(), JSON.stringify(handoff) + '\n');
-            const result = await acceptHandoff('handoff-123', 'agent-c');
-            expect(result.success).toBe(false);
-            expect(result.message).toContain('not the intended recipient');
-        });
-    });
-});

package/dist/smoke.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/smoke.test.js

@@ -1,6 +0,0 @@
-import { describe, it, expect } from 'vitest';
-describe('MCP Smoke Test', () => {
-    it('should pass', async () => {
-        expect(true).toBe(true);
-    });
-});

package/dist/supervisor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/supervisor.test.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-// Integration-style tests for rigour_run_supervised
-// These test the exported functionality indirectly since MCP server is complex to mock
-describe('rigour_run_supervised', () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = path.join(os.tmpdir(), `rigour-test-${Date.now()}`);
-        await fs.ensureDir(testDir);
-        // Create a minimal rigour.yml
-        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
-version: 1
-preset: api
-gates:
-  max_file_lines: 500
-  forbid_todos: true
-  required_files: []
-ignore: []
-`);
-        // Create .rigour directory for events
-        await fs.ensureDir(path.join(testDir, '.rigour'));
-    });
-    afterEach(async () => {
-        await fs.remove(testDir);
-    });
-    it('should have correct tool schema', () => {
-        // Verify the tool schema includes all required fields
-        const expectedProperties = ['cwd', 'command', 'maxRetries', 'dryRun'];
-        const requiredProperties = ['cwd', 'command'];
-        // This is a schema validation test - in real MCP, the server validates this
-        expect(expectedProperties).toContain('dryRun');
-        expect(requiredProperties).not.toContain('dryRun'); // dryRun should be optional
-    });
-    it('should log supervisor_started event', async () => {
-        // Simulate what the handler does
-        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
-        const event = {
-            id: 'test-id',
-            timestamp: new Date().toISOString(),
-            type: 'supervisor_started',
-            requestId: 'req-123',
-            command: 'echo "test"',
-            maxRetries: 3,
-            dryRun: true
-        };
-        await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
-        const content = await fs.readFile(eventsPath, 'utf-8');
-        const logged = JSON.parse(content.trim());
-        expect(logged.type).toBe('supervisor_started');
-        expect(logged.dryRun).toBe(true);
-        expect(logged.maxRetries).toBe(3);
-    });
-    it('should log supervisor_iteration events', async () => {
-        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
-        // Simulate iteration logging
-        const iterations = [
-            { iteration: 1, status: 'FAIL', failures: 2 },
-            { iteration: 2, status: 'FAIL', failures: 1 },
-            { iteration: 3, status: 'PASS', failures: 0 },
-        ];
-        for (const iter of iterations) {
-            const event = {
-                id: `iter-${iter.iteration}`,
-                timestamp: new Date().toISOString(),
-                type: 'supervisor_iteration',
-                requestId: 'req-123',
-                ...iter
-            };
-            await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
-        }
-        const content = await fs.readFile(eventsPath, 'utf-8');
-        const lines = content.trim().split('\n').map(l => JSON.parse(l));
-        expect(lines.length).toBe(3);
-        expect(lines[0].iteration).toBe(1);
-        expect(lines[2].status).toBe('PASS');
-    });
-    it('should log supervisor_completed event with final status', async () => {
-        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
-        const event = {
-            id: 'completed-1',
-            timestamp: new Date().toISOString(),
-            type: 'supervisor_completed',
-            requestId: 'req-123',
-            finalStatus: 'PASS',
-            totalIterations: 2
-        };
-        await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
-        const content = await fs.readFile(eventsPath, 'utf-8');
-        const logged = JSON.parse(content.trim());
-        expect(logged.type).toBe('supervisor_completed');
-        expect(logged.finalStatus).toBe('PASS');
-        expect(logged.totalIterations).toBe(2);
-    });
-    it('should track iteration history correctly', () => {
-        const iterations = [];
-        // Simulate the supervisor loop
-        iterations.push({ iteration: 1, status: 'FAIL', failures: 3 });
-        iterations.push({ iteration: 2, status: 'FAIL', failures: 1 });
-        iterations.push({ iteration: 3, status: 'PASS', failures: 0 });
-        const summary = iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join('\n');
-        expect(summary).toContain('1. FAIL (3 failures)');
-        expect(summary).toContain('3. PASS (0 failures)');
-        expect(iterations.length).toBe(3);
-    });
-    it('should generate fix packet for failures', () => {
-        const failures = [
-            { id: 'max_lines', title: 'File too long', details: 'src/index.ts has 600 lines', files: ['src/index.ts'], hint: 'Split into modules' },
-            { id: 'forbid_todos', title: 'TODO found', details: 'Found TODO comment', files: ['src/utils.ts'] },
-        ];
-        const fixPacket = failures.map((f, i) => {
-            let text = `FIX TASK ${i + 1}: [${f.id.toUpperCase()}] ${f.title}\n`;
-            text += `   - CONTEXT: ${f.details}\n`;
-            if (f.files && f.files.length > 0) {
-                text += `   - TARGET FILES: ${f.files.join(', ')}\n`;
-            }
-            if (f.hint) {
-                text += `   - REFACTORING GUIDANCE: ${f.hint}\n`;
-            }
-            return text;
-        }).join('\n---\n');
-        expect(fixPacket).toContain('[MAX_LINES]');
-        expect(fixPacket).toContain('[FORBID_TODOS]');
-        expect(fixPacket).toContain('Split into modules');
-        expect(fixPacket).toContain('src/index.ts');
-    });
-});

package/dist/tools/deep-handlers.test.d.ts

@@ -1 +0,0 @@
-export {};