@syrin/cli 1.3.2 → 1.4.1

package/dist/runtime/analysis/rules/errors/e008-circular-dependency.d.ts

@@ -1,22 +0,0 @@
-/**
- * E008: Circular Tool Dependency
- *
- * Condition:
- * - Tool dependency graph contains a cycle
- *
- * Why:
- * - LLMs cannot reason about cycles
- * - Execution becomes undefined
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E008CircularDependencyRule extends BaseRule {
-    readonly id: "E008";
-    readonly severity: "error";
-    readonly ruleName = "Circular Tool Dependency";
-    readonly description = "Circular dependency detected between tools. Execution becomes undefined.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E008CircularDependency: E008CircularDependencyRule;
-export {};
-//# sourceMappingURL=e008-circular-dependency.d.ts.map

package/dist/runtime/analysis/rules/errors/e008-circular-dependency.js

@@ -1,84 +0,0 @@
-/**
- * E008: Circular Tool Dependency
- *
- * Condition:
- * - Tool dependency graph contains a cycle
- *
- * Why:
- * - LLMs cannot reason about cycles
- * - Execution becomes undefined
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Detect cycles in the dependency graph using DFS.
- */
-function detectCycles(dependencies) {
-    // Build adjacency list
-    const graph = new Map();
-    for (const dep of dependencies) {
-        if (!graph.has(dep.fromTool)) {
-            graph.set(dep.fromTool, []);
-        }
-        graph.get(dep.fromTool).push(dep.toTool);
-    }
-    const cycles = [];
-    const visited = new Set();
-    const recStack = new Set();
-    function dfs(tool, path) {
-        visited.add(tool);
-        recStack.add(tool);
-        path.push(tool);
-        const neighbors = graph.get(tool) || [];
-        for (const neighbor of neighbors) {
-            if (!visited.has(neighbor)) {
-                dfs(neighbor, [...path]);
-            }
-            else if (recStack.has(neighbor)) {
-                // Found a cycle
-                const cycleStart = path.indexOf(neighbor);
-                if (cycleStart !== -1) {
-                    cycles.push([...path.slice(cycleStart), neighbor]);
-                }
-            }
-        }
-        recStack.delete(tool);
-    }
-    // Check all tools
-    for (const dep of dependencies) {
-        if (!visited.has(dep.fromTool)) {
-            dfs(dep.fromTool, []);
-        }
-    }
-    return cycles;
-}
-class E008CircularDependencyRule extends BaseRule {
-    id = ERROR_CODES.E008;
-    severity = 'error';
-    ruleName = 'Circular Tool Dependency';
-    description = 'Circular dependency detected between tools. Execution becomes undefined.';
-    check(ctx) {
-        const diagnostics = [];
-        // Only check high-confidence dependencies (>= 0.8) for cycles
-        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
-        if (highConfidenceDeps.length === 0) {
-            return diagnostics;
-        }
-        const cycles = detectCycles(highConfidenceDeps);
-        // Report each cycle
-        const reportedCycles = new Set();
-        for (const cycle of cycles) {
-            // Create a canonical representation of the cycle (sort a copy to avoid mutating original)
-            const cycleKey = [...cycle].sort().join(' → ');
-            if (reportedCycles.has(cycleKey)) {
-                continue;
-            }
-            reportedCycles.add(cycleKey);
-            const cycleStr = cycle.join(' → ');
-            diagnostics.push(this.createDiagnostic(`Circular dependency detected between tools: ${cycleStr}.`, undefined, undefined, `Break the cycle by removing or restructuring dependencies between: ${cycle.join(', ')}.`));
-        }
-        return diagnostics;
-    }
-}
-export const E008CircularDependency = new E008CircularDependencyRule();
-//# sourceMappingURL=e008-circular-dependency.js.map

package/dist/runtime/analysis/rules/errors/e009-implicit-user-input.d.ts

@@ -1,23 +0,0 @@
-/**
- * E009: Tool Depends on User Input Indirectly
- *
- * Condition:
- * - Tool expects data
- * - Only source is implicit user memory / conversation
- * - No explicit tool provides it
- *
- * Why:
- * - Relies on hallucinated context
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E009ImplicitUserInputRule extends BaseRule {
-    readonly id: "E009";
-    readonly severity: "error";
-    readonly ruleName = "Tool Depends on User Input Indirectly";
-    readonly description = "Tool depends on implicit user context with no explicit source.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E009ImplicitUserInput: E009ImplicitUserInputRule;
-export {};
-//# sourceMappingURL=e009-implicit-user-input.d.ts.map

package/dist/runtime/analysis/rules/errors/e009-implicit-user-input.js

@@ -1,89 +0,0 @@
-/**
- * E009: Tool Depends on User Input Indirectly
- *
- * Condition:
- * - Tool expects data
- * - Only source is implicit user memory / conversation
- * - No explicit tool provides it
- *
- * Why:
- * - Relies on hallucinated context
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E009ImplicitUserInputRule extends BaseRule {
-    id = ERROR_CODES.E009;
-    severity = 'error';
-    ruleName = 'Tool Depends on User Input Indirectly';
-    description = 'Tool depends on implicit user context with no explicit source.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const input of tool.inputs) {
-                if (!input.required) {
-                    continue;
-                }
-                // Check if there's any tool that provides this input
-                // Look for output fields with similar names
-                const fieldName = input.name.toLowerCase();
-                let hasExplicitSource = false;
-                for (const otherTool of ctx.tools) {
-                    if (otherTool.name === tool.name) {
-                        continue;
-                    }
-                    for (const output of otherTool.outputs) {
-                        const outputName = output.name.toLowerCase();
-                        // Check for exact match or token-based match
-                        if (outputName === fieldName) {
-                            hasExplicitSource = true;
-                            break;
-                        }
-                        // Token-based matching: split on non-alphanumeric and camelCase boundaries
-                        const fieldTokens = new Set(fieldName
-                            .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-                            .filter(t => t.length > 0));
-                        const outputTokens = new Set(outputName
-                            .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-                            .filter(t => t.length > 0));
-                        // Check for token intersection
-                        const hasTokenMatch = Array.from(fieldTokens).some(token => outputTokens.has(token) && token.length >= 3) ||
-                            Array.from(outputTokens).some(token => fieldTokens.has(token) && token.length >= 3);
-                        if (hasTokenMatch) {
-                            hasExplicitSource = true;
-                            break;
-                        }
-                    }
-                    if (hasExplicitSource) {
-                        break;
-                    }
-                }
-                // Also check dependencies
-                if (!hasExplicitSource) {
-                    const hasDependency = ctx.dependencies.some(d => d.toTool === tool.name &&
-                        d.toField === input.name &&
-                        d.confidence >= 0.6);
-                    if (hasDependency) {
-                        hasExplicitSource = true;
-                    }
-                }
-                // If no explicit source found and input name suggests user data
-                const userDataIndicators = [
-                    'user',
-                    'person',
-                    'name',
-                    'email',
-                    'location',
-                    'address',
-                    'preference',
-                ];
-                const looksLikeUserData = userDataIndicators.some(indicator => fieldName.includes(indicator));
-                if (!hasExplicitSource && looksLikeUserData) {
-                    diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" depends on implicit user context (parameter: "${input.name}") with no explicit source.`, tool.name, input.name, `Create an explicit tool to provide "${input.name}", or ensure it's clearly documented as user input.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E009ImplicitUserInput = new E009ImplicitUserInputRule();
-//# sourceMappingURL=e009-implicit-user-input.js.map

package/dist/runtime/analysis/rules/errors/e010-non-serializable.d.ts

@@ -1,25 +0,0 @@
-/**
- * E010: Non-Serializable Output
- *
- * Condition:
- * - Output schema contains:
- *   - functions
- *   - class instances
- *   - unsupported types
- *
- * Why:
- * - Breaks MCP contract
- * - Breaks recording & replay later
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E010NonSerializableRule extends BaseRule {
-    readonly id: "E010";
-    readonly severity: "error";
-    readonly ruleName = "Non-Serializable Output";
-    readonly description = "Output of tool is not serializable. Breaks MCP contract.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E010NonSerializable: E010NonSerializableRule;
-export {};
-//# sourceMappingURL=e010-non-serializable.d.ts.map

package/dist/runtime/analysis/rules/errors/e010-non-serializable.js

@@ -1,46 +0,0 @@
-/**
- * E010: Non-Serializable Output
- *
- * Condition:
- * - Output schema contains:
- *   - functions
- *   - class instances
- *   - unsupported types
- *
- * Why:
- * - Breaks MCP contract
- * - Breaks recording & replay later
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Check if a type is non-serializable.
- */
-function isNonSerializableType(type) {
-    const nonSerializableTypes = new Set([
-        'function',
-        'undefined',
-        'symbol',
-        'bigint',
-    ]);
-    return nonSerializableTypes.has(type.toLowerCase());
-}
-class E010NonSerializableRule extends BaseRule {
-    id = ERROR_CODES.E010;
-    severity = 'error';
-    ruleName = 'Non-Serializable Output';
-    description = 'Output of tool is not serializable. Breaks MCP contract.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const output of tool.outputs) {
-                if (isNonSerializableType(output.type)) {
-                    diagnostics.push(this.createDiagnostic(`Output of "${tool.name}" (field: "${output.name}") has non-serializable type "${output.type}".`, tool.name, output.name, `Change the output type to a serializable type (string, number, boolean, object, array).`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E010NonSerializable = new E010NonSerializableRule();
-//# sourceMappingURL=e010-non-serializable.js.map

package/dist/runtime/analysis/rules/errors/e011-missing-tool-description.d.ts

@@ -1,24 +0,0 @@
-/**
- * E011: Missing Tool Description
- *
- * Condition:
- * - Tool has no description OR
- * - Tool description is empty or only whitespace
- *
- * Why:
- * - LLM cannot understand what the tool does
- * - Tool selection becomes ambiguous
- * - Critical for tool discovery and usage
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E011MissingToolDescriptionRule extends BaseRule {
-    readonly id: "E011";
-    readonly severity: "error";
-    readonly ruleName = "Missing Tool Description";
-    readonly description = "Tool is missing a description. LLM cannot understand what the tool does.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E011MissingToolDescription: E011MissingToolDescriptionRule;
-export {};
-//# sourceMappingURL=e011-missing-tool-description.d.ts.map

package/dist/runtime/analysis/rules/errors/e011-missing-tool-description.js

@@ -1,33 +0,0 @@
-/**
- * E011: Missing Tool Description
- *
- * Condition:
- * - Tool has no description OR
- * - Tool description is empty or only whitespace
- *
- * Why:
- * - LLM cannot understand what the tool does
- * - Tool selection becomes ambiguous
- * - Critical for tool discovery and usage
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E011MissingToolDescriptionRule extends BaseRule {
-    id = ERROR_CODES.E011;
-    severity = 'error';
-    ruleName = 'Missing Tool Description';
-    description = 'Tool is missing a description. LLM cannot understand what the tool does.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            // Check if description is missing or empty/whitespace only
-            const hasDescription = Boolean(tool.description && tool.description.trim().length > 0);
-            if (!hasDescription) {
-                diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" is missing a description.`, tool.name, undefined, `Add a clear description to "${tool.name}" explaining what it does, what inputs it expects, and what it returns.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E011MissingToolDescription = new E011MissingToolDescriptionRule();
-//# sourceMappingURL=e011-missing-tool-description.js.map

package/dist/runtime/analysis/rules/errors/e012-side-effect-detected.d.ts

@@ -1,39 +0,0 @@
-/**
- * E012: Side Effect Detected
- *
- * Condition: Tool attempts filesystem writes to project files (not temp directory)
- *
- * Why this is fatal:
- * - Tools should not mutate project state
- * - Breaks isolation and testability
- * - Makes behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for behavioral validation results.
- * This extends the static analysis context with runtime observation data.
- */
-export interface BehavioralContext {
-    /** Tool name */
-    toolName: string;
-    /** Side effects detected */
-    sideEffects: Array<{
-        operation: string;
-        path: string;
-    }>;
-}
-declare class E012SideEffectDetectedRule extends BaseRule {
-    readonly id: "E012";
-    readonly severity: "error";
-    readonly ruleName = "Side Effect Detected";
-    readonly description = "Tool attempted filesystem write to project files. Tools should not mutate project state.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: BehavioralContext): Diagnostic[];
-}
-export declare const E012SideEffectDetected: E012SideEffectDetectedRule;
-export {};
-//# sourceMappingURL=e012-side-effect-detected.d.ts.map

package/dist/runtime/analysis/rules/errors/e012-side-effect-detected.js

@@ -1,40 +0,0 @@
-/**
- * E012: Side Effect Detected
- *
- * Condition: Tool attempts filesystem writes to project files (not temp directory)
- *
- * Why this is fatal:
- * - Tools should not mutate project state
- * - Breaks isolation and testability
- * - Makes behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E012SideEffectDetectedRule extends BaseRule {
-    id = ERROR_CODES.E012;
-    severity = 'error';
-    ruleName = 'Side Effect Detected';
-    description = 'Tool attempted filesystem write to project files. Tools should not mutate project state.';
-    check(_ctx) {
-        const diagnostics = [];
-        // This rule requires behavioral context (from runtime testing)
-        // It will be called with behavioral data from the test orchestrator
-        // For now, return empty - actual checking happens in test orchestrator
-        return diagnostics;
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.sideEffects.length > 0) {
-            const sideEffectList = behavioralCtx.sideEffects
-                .map(se => `  - ${se.operation}: ${se.path}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" attempted filesystem operations on project files:\n${sideEffectList}`, behavioralCtx.toolName, undefined, 'Remove filesystem writes or write only to temp directory. Tools should not mutate project state.'));
-        }
-        return diagnostics;
-    }
-}
-export const E012SideEffectDetected = new E012SideEffectDetectedRule();
-//# sourceMappingURL=e012-side-effect-detected.js.map

package/dist/runtime/analysis/rules/errors/e013-non-deterministic-output.d.ts

@@ -1,37 +0,0 @@
-/**
- * E013: Non-Deterministic Output
- *
- * Condition: Tool produces different outputs for the same input across multiple runs
- *
- * Why this is fatal:
- * - Breaks agent reliability
- * - Makes testing impossible
- * - LLM cannot reason about tool behavior
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for non-determinism detection.
- */
-export interface NonDeterminismContext {
-    /** Tool name */
-    toolName: string;
-    /** Number of runs that produced different outputs */
-    differentRuns: number;
-    /** Total number of runs */
-    totalRuns: number;
-}
-declare class E013NonDeterministicOutputRule extends BaseRule {
-    readonly id: any;
-    readonly severity: "error";
-    readonly ruleName = "Non-Deterministic Output";
-    readonly description = "Tool produces different outputs for the same input across multiple runs. This breaks agent reliability.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: NonDeterminismContext): Diagnostic[];
-}
-export declare const E013NonDeterministicOutput: E013NonDeterministicOutputRule;
-export {};
-//# sourceMappingURL=e013-non-deterministic-output.d.ts.map

package/dist/runtime/analysis/rules/errors/e013-non-deterministic-output.js

@@ -1,34 +0,0 @@
-/**
- * E013: Non-Deterministic Output
- *
- * Condition: Tool produces different outputs for the same input across multiple runs
- *
- * Why this is fatal:
- * - Breaks agent reliability
- * - Makes testing impossible
- * - LLM cannot reason about tool behavior
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E013NonDeterministicOutputRule extends BaseRule {
-    id = ERROR_CODES.E013;
-    severity = 'error';
-    ruleName = 'Non-Deterministic Output';
-    description = 'Tool produces different outputs for the same input across multiple runs. This breaks agent reliability.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.differentRuns > 0) {
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" produced different outputs across ${behavioralCtx.totalRuns} runs. ${behavioralCtx.differentRuns} run(s) produced different results.`, behavioralCtx.toolName, undefined, 'Ensure tool produces consistent outputs for the same input. Remove sources of non-determinism (random values, timestamps, etc.).'));
-        }
-        return diagnostics;
-    }
-}
-export const E013NonDeterministicOutput = new E013NonDeterministicOutputRule();
-//# sourceMappingURL=e013-non-deterministic-output.js.map

package/dist/runtime/analysis/rules/errors/e013-output-explosion.d.ts

@@ -1,39 +0,0 @@
-/**
- * E013: Output Explosion
- *
- * Condition: Tool output exceeds declared size limit
- *
- * Why this is fatal:
- * - Large outputs overwhelm LLM context
- * - Breaks agent reasoning
- * - Indicates design issue (pagination, filtering needed)
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for output size validation.
- */
-export interface OutputSizeContext {
-    /** Tool name */
-    toolName: string;
-    /** Actual output size in bytes */
-    actualSize: number;
-    /** Maximum allowed size in bytes */
-    maxSize: number;
-    /** Size limit string from contract (e.g., "50kb") */
-    limitString: string;
-}
-declare class E013OutputExplosionRule extends BaseRule {
-    readonly id: "E013";
-    readonly severity: "error";
-    readonly ruleName = "Output Explosion";
-    readonly description = "Tool output exceeds declared size limit. Large outputs overwhelm LLM context and break agent reasoning.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: OutputSizeContext): Diagnostic[];
-}
-export declare const E013OutputExplosion: E013OutputExplosionRule;
-export {};
-//# sourceMappingURL=e013-output-explosion.d.ts.map

package/dist/runtime/analysis/rules/errors/e013-output-explosion.js

@@ -1,36 +0,0 @@
-/**
- * E013: Output Explosion
- *
- * Condition: Tool output exceeds declared size limit
- *
- * Why this is fatal:
- * - Large outputs overwhelm LLM context
- * - Breaks agent reasoning
- * - Indicates design issue (pagination, filtering needed)
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E013OutputExplosionRule extends BaseRule {
-    id = ERROR_CODES.E013;
-    severity = 'error';
-    ruleName = 'Output Explosion';
-    description = 'Tool output exceeds declared size limit. Large outputs overwhelm LLM context and break agent reasoning.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.actualSize > behavioralCtx.maxSize) {
-            const actualSizeKB = (behavioralCtx.actualSize / 1024).toFixed(2);
-            const maxSizeKB = (behavioralCtx.maxSize / 1024).toFixed(2);
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" returned ${actualSizeKB}KB, exceeding declared limit of ${behavioralCtx.limitString} (${maxSizeKB}KB).`, behavioralCtx.toolName, undefined, `Reduce output size by: paginating results, adding filters, or updating contract limit if legitimate (max_output_size: ${Math.ceil(behavioralCtx.actualSize / 1024)}kb).`));
-        }
-        return diagnostics;
-    }
-}
-export const E013OutputExplosion = new E013OutputExplosionRule();
-//# sourceMappingURL=e013-output-explosion.js.map

package/dist/runtime/analysis/rules/errors/e014-hidden-dependency.d.ts

@@ -1,42 +0,0 @@
-/**
- * E014: Hidden Dependency
- *
- * Condition: Tool calls other tools during execution without declaring them in contract
- *
- * Why this is fatal:
- * - Breaks isolation assumption
- * - Creates hidden coupling
- * - Makes tool behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for hidden dependency detection.
- */
-export interface HiddenDependencyContext {
-    /** Tool name */
-    toolName: string;
-    /** List of tool calls that are not declared */
-    hiddenDependencies: Array<{
-        toolName: string;
-        timestamp: number;
-    }>;
-    /** List of declared dependencies that don't exist in the MCP server */
-    missingDependencies?: string[];
-    /** Declared dependencies from contract — reserved for future validation/consumer use */
-    declaredDependencies: string[];
-}
-declare class E014HiddenDependencyRule extends BaseRule {
-    readonly id: "E014";
-    readonly severity: "error";
-    readonly ruleName = "Hidden Dependency";
-    readonly description = "Tool calls other tools during execution without declaring them in contract. This breaks isolation.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: HiddenDependencyContext): Diagnostic[];
-}
-export declare const E014HiddenDependency: E014HiddenDependencyRule;
-export {};
-//# sourceMappingURL=e014-hidden-dependency.d.ts.map

package/dist/runtime/analysis/rules/errors/e014-hidden-dependency.js

@@ -1,46 +0,0 @@
-/**
- * E014: Hidden Dependency
- *
- * Condition: Tool calls other tools during execution without declaring them in contract
- *
- * Why this is fatal:
- * - Breaks isolation assumption
- * - Creates hidden coupling
- * - Makes tool behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E014HiddenDependencyRule extends BaseRule {
-    id = ERROR_CODES.E014;
-    severity = 'error';
-    ruleName = 'Hidden Dependency';
-    description = 'Tool calls other tools during execution without declaring them in contract. This breaks isolation.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        // Check for hidden dependencies (tools called but not declared)
-        if (behavioralCtx.hiddenDependencies.length > 0) {
-            const dependencyList = behavioralCtx.hiddenDependencies
-                .map(dep => `  - ${dep.toolName}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" called other tools without declaring them:\n${dependencyList}`, behavioralCtx.toolName, undefined, `Declare dependencies in contract (guarantees.dependencies: [${behavioralCtx.hiddenDependencies.map(d => `"${d.toolName}"`).join(', ')}]) or remove the tool calls.`));
-        }
-        // Check for missing dependencies (declared but don't exist in MCP server)
-        if (behavioralCtx.missingDependencies &&
-            behavioralCtx.missingDependencies.length > 0) {
-            const missingList = behavioralCtx.missingDependencies
-                .map(dep => `  - ${dep}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" declares dependencies that don't exist in the MCP server:\n${missingList}`, behavioralCtx.toolName, undefined, `Remove non-existent dependencies from contract (guarantees.dependencies) or ensure these tools are implemented: [${behavioralCtx.missingDependencies.map(d => `"${d}"`).join(', ')}]`));
-        }
-        return diagnostics;
-    }
-}
-export const E014HiddenDependency = new E014HiddenDependencyRule();
-//# sourceMappingURL=e014-hidden-dependency.js.map