@syrin/cli 1.3.2 → 1.4.1

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

@@ -1,39 +0,0 @@
-/**
- * E014: 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 E014OutputExplosionRule extends BaseRule {
-    readonly id: "E014";
-    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 E014OutputExplosion: E014OutputExplosionRule;
-export {};
-//# sourceMappingURL=e014-output-explosion.d.ts.map

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

@@ -1,36 +0,0 @@
-/**
- * E014: 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 E014OutputExplosionRule extends BaseRule {
-    id = ERROR_CODES.E014;
-    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 E014OutputExplosion = new E014OutputExplosionRule();
-//# sourceMappingURL=e014-output-explosion.js.map

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

@@ -1,42 +0,0 @@
-/**
- * E015: 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 E015HiddenDependencyRule extends BaseRule {
-    readonly id: "E015";
-    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 E015HiddenDependency: E015HiddenDependencyRule;
-export {};
-//# sourceMappingURL=e015-hidden-dependency.d.ts.map

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

@@ -1,46 +0,0 @@
-/**
- * E015: 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 E015HiddenDependencyRule extends BaseRule {
-    id = ERROR_CODES.E015;
-    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 E015HiddenDependency = new E015HiddenDependencyRule();
-//# sourceMappingURL=e015-hidden-dependency.js.map

package/dist/runtime/analysis/rules/errors/e015-unbounded-execution.d.ts

@@ -1,44 +0,0 @@
-/**
- * E015: Unbounded Execution
- *
- * Condition: Tool execution timed out or failed to terminate
- *
- * Why this is fatal:
- * - Tool may hang indefinitely
- * - Breaks agent reliability
- * - Indicates design issue (missing timeouts, infinite loops)
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unbounded execution detection.
- */
-export interface UnboundedExecutionContext {
-    /** Tool name */
-    toolName: string;
-    /** Whether execution timed out */
-    timedOut: boolean;
-    /** Declared max execution time (e.g., "5m", "2h") or undefined if using default */
-    declaredTimeout?: string;
-    /** Actual timeout used in milliseconds */
-    actualTimeoutMs?: number;
-    /** Execution errors */
-    errors: Array<{
-        message: string;
-        code?: string;
-    }>;
-}
-declare class E015UnboundedExecutionRule extends BaseRule {
-    readonly id: "E015";
-    readonly severity: "error";
-    readonly ruleName = "Unbounded Execution";
-    readonly description = "Tool execution timed out or failed to terminate. Tool may hang indefinitely, breaking agent reliability.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnboundedExecutionContext): Diagnostic[];
-}
-export declare const E015UnboundedExecution: E015UnboundedExecutionRule;
-export {};
-//# sourceMappingURL=e015-unbounded-execution.d.ts.map

package/dist/runtime/analysis/rules/errors/e015-unbounded-execution.js

@@ -1,66 +0,0 @@
-/**
- * E015: Unbounded Execution
- *
- * Condition: Tool execution timed out or failed to terminate
- *
- * Why this is fatal:
- * - Tool may hang indefinitely
- * - Breaks agent reliability
- * - Indicates design issue (missing timeouts, infinite loops)
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Format timeout in milliseconds to human-readable string.
- */
-function formatTimeout(ms) {
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    const s = Math.floor(ms / 1000);
-    if (s < 60) {
-        return `${s}s`;
-    }
-    const m = Math.floor(s / 60);
-    if (m < 60) {
-        return `${m}m`;
-    }
-    const h = Math.floor(m / 60);
-    return `${h}h`;
-}
-class E015UnboundedExecutionRule extends BaseRule {
-    id = ERROR_CODES.E015;
-    severity = 'error';
-    ruleName = 'Unbounded Execution';
-    description = 'Tool execution timed out or failed to terminate. Tool may hang indefinitely, breaking agent reliability.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.timedOut) {
-            const timeoutInfo = behavioralCtx.declaredTimeout
-                ? ` (exceeded declared timeout: ${behavioralCtx.declaredTimeout})`
-                : behavioralCtx.actualTimeoutMs
-                    ? ` (exceeded default timeout: ${formatTimeout(behavioralCtx.actualTimeoutMs)})`
-                    : '';
-            const suggestion = behavioralCtx.declaredTimeout
-                ? `Tool exceeded its declared max_execution_time (${behavioralCtx.declaredTimeout}). Either fix the tool to complete within this time, or update the contract if a longer timeout is legitimate.`
-                : 'Add timeouts, fix infinite loops, or optimize slow operations. If tool legitimately takes longer, declare max_execution_time in contract (e.g., "5m", "2h").';
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" execution timed out${timeoutInfo}. Tool may hang indefinitely.`, behavioralCtx.toolName, undefined, suggestion));
-        }
-        if (behavioralCtx.errors.length > 0 && !behavioralCtx.timedOut) {
-            const errorMessages = behavioralCtx.errors
-                .map(e => `  - ${e.message}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" execution failed:\n${errorMessages}`, behavioralCtx.toolName, undefined, 'Fix tool implementation errors. Ensure tool handles all input cases gracefully.'));
-        }
-        return diagnostics;
-    }
-}
-export const E015UnboundedExecution = new E015UnboundedExecutionRule();
-//# sourceMappingURL=e015-unbounded-execution.js.map

package/dist/runtime/analysis/rules/errors/e016-output-validation-failed.d.ts

@@ -1,43 +0,0 @@
-/**
- * E016: Output Structure Validation Failed
- *
- * Condition: Tool output doesn't match declared output schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Breaks agent's ability to reason about tool outputs
- * - Can cause downstream errors in tool chains
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for output validation failure detection.
- */
-export interface OutputValidationContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name (if applicable) */
-    testName?: string;
-    /** Test input that caused the failure */
-    testInput?: Record<string, unknown>;
-    /** Expected output schema name */
-    expectedOutputSchema?: string;
-    /** Validation error details */
-    error?: string;
-    /** Additional validation details */
-    details?: Record<string, unknown>;
-}
-declare class E016OutputValidationFailedRule extends BaseRule {
-    readonly id: "E016";
-    readonly severity: "error";
-    readonly ruleName = "Output Structure Validation Failed";
-    readonly description = "Tool output doesn't match declared output schema. This breaks agent's ability to reason about tool outputs.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: OutputValidationContext): Diagnostic[];
-}
-export declare const E016OutputValidationFailed: E016OutputValidationFailedRule;
-export {};
-//# sourceMappingURL=e016-output-validation-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e016-output-validation-failed.js

@@ -1,42 +0,0 @@
-/**
- * E016: Output Structure Validation Failed
- *
- * Condition: Tool output doesn't match declared output schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Breaks agent's ability to reason about tool outputs
- * - Can cause downstream errors in tool chains
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E016OutputValidationFailedRule extends BaseRule {
-    id = ERROR_CODES.E016;
-    severity = 'error';
-    ruleName = 'Output Structure Validation Failed';
-    description = "Tool output doesn't match declared output schema. This breaks agent's ability to reason about tool outputs.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        const errorMessage = behavioralCtx.error || 'Output structure does not match schema';
-        let message = `Tool "${behavioralCtx.toolName}" output validation failed: ${errorMessage}`;
-        if (behavioralCtx.testName) {
-            message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" output validation failed: ${errorMessage}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Fix output structure to match declared schema or update schema to match actual output. Ensure output schema accurately reflects tool behavior.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            expectedOutputSchema: behavioralCtx.expectedOutputSchema,
-            ...behavioralCtx.details,
-        }));
-        return diagnostics;
-    }
-}
-export const E016OutputValidationFailed = new E016OutputValidationFailedRule();
-//# sourceMappingURL=e016-output-validation-failed.js.map

package/dist/runtime/analysis/rules/errors/e016-unbounded-execution.d.ts

@@ -1,44 +0,0 @@
-/**
- * E016: Unbounded Execution
- *
- * Condition: Tool execution timed out or failed to terminate
- *
- * Why this is fatal:
- * - Tool may hang indefinitely
- * - Breaks agent reliability
- * - Indicates design issue (missing timeouts, infinite loops)
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unbounded execution detection.
- */
-export interface UnboundedExecutionContext {
-    /** Tool name */
-    toolName: string;
-    /** Whether execution timed out */
-    timedOut: boolean;
-    /** Declared max execution time (e.g., "5m", "2h") or undefined if using default */
-    declaredTimeout?: string;
-    /** Actual timeout used in milliseconds */
-    actualTimeoutMs?: number;
-    /** Execution errors */
-    errors: Array<{
-        message: string;
-        code?: string;
-    }>;
-}
-declare class E016UnboundedExecutionRule extends BaseRule {
-    readonly id: "E016";
-    readonly severity: "error";
-    readonly ruleName = "Unbounded Execution";
-    readonly description = "Tool execution timed out or failed to terminate. Tool may hang indefinitely, breaking agent reliability.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnboundedExecutionContext): Diagnostic[];
-}
-export declare const E016UnboundedExecution: E016UnboundedExecutionRule;
-export {};
-//# sourceMappingURL=e016-unbounded-execution.d.ts.map

package/dist/runtime/analysis/rules/errors/e016-unbounded-execution.js

@@ -1,66 +0,0 @@
-/**
- * E016: Unbounded Execution
- *
- * Condition: Tool execution timed out or failed to terminate
- *
- * Why this is fatal:
- * - Tool may hang indefinitely
- * - Breaks agent reliability
- * - Indicates design issue (missing timeouts, infinite loops)
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Format timeout in milliseconds to human-readable string.
- */
-function formatTimeout(ms) {
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    const s = Math.floor(ms / 1000);
-    if (s < 60) {
-        return `${s}s`;
-    }
-    const m = Math.floor(s / 60);
-    if (m < 60) {
-        return `${m}m`;
-    }
-    const h = Math.floor(m / 60);
-    return `${h}h`;
-}
-class E016UnboundedExecutionRule extends BaseRule {
-    id = ERROR_CODES.E016;
-    severity = 'error';
-    ruleName = 'Unbounded Execution';
-    description = 'Tool execution timed out or failed to terminate. Tool may hang indefinitely, breaking agent reliability.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.timedOut) {
-            const timeoutInfo = behavioralCtx.declaredTimeout
-                ? ` (exceeded declared timeout: ${behavioralCtx.declaredTimeout})`
-                : behavioralCtx.actualTimeoutMs
-                    ? ` (exceeded default timeout: ${formatTimeout(behavioralCtx.actualTimeoutMs)})`
-                    : '';
-            const suggestion = behavioralCtx.declaredTimeout
-                ? `Tool exceeded its declared max_execution_time (${behavioralCtx.declaredTimeout}). Either fix the tool to complete within this time, or update the contract if a longer timeout is legitimate.`
-                : 'Add timeouts, fix infinite loops, or optimize slow operations. If tool legitimately takes longer, declare max_execution_time in contract (e.g., "5m", "2h").';
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" execution timed out${timeoutInfo}. Tool may hang indefinitely.`, behavioralCtx.toolName, undefined, suggestion));
-        }
-        if (behavioralCtx.errors.length > 0 && !behavioralCtx.timedOut) {
-            const errorMessages = behavioralCtx.errors
-                .map(e => `  - ${e.message}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" execution failed:\n${errorMessages}`, behavioralCtx.toolName, undefined, 'Fix tool implementation errors. Ensure tool handles all input cases gracefully.'));
-        }
-        return diagnostics;
-    }
-}
-export const E016UnboundedExecution = new E016UnboundedExecutionRule();
-//# sourceMappingURL=e016-unbounded-execution.js.map

package/dist/runtime/analysis/rules/errors/e017-input-validation-failed.d.ts

@@ -1,57 +0,0 @@
-/**
- * E017: Input Validation Failed
- *
- * Condition: Tool input doesn't match declared input schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Tool doesn't handle invalid inputs gracefully
- * - Can cause runtime errors in production
- * - Indicates missing input validation or schema mismatch
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for input validation failure detection.
- */
-export interface InputValidationContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name (if applicable) */
-    testName?: string;
-    /** Test input that caused the failure */
-    testInput?: Record<string, unknown>;
-    /** Validation error details */
-    error?: string;
-    /** Parsed error details (field, message, etc.) */
-    parsedError?: {
-        field?: string;
-        message?: string;
-        inputValue?: string;
-        inputType?: string;
-        errorType?: string;
-    };
-    /** Additional validation details */
-    details?: Record<string, unknown>;
-}
-declare class E017InputValidationFailedRule extends BaseRule {
-    readonly id: "E017";
-    readonly severity: "error";
-    readonly ruleName = "Input Validation Failed";
-    readonly description = "Tool input doesn't match declared input schema. Tool doesn't handle invalid inputs gracefully.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Build parsed error message fragment for a field.
-     * @param parsed - Parsed error details
-     * @param baseError - Base error message as fallback
-     * @returns Error message fragment describing the field validation issue
-     */
-    private buildParsedErrorMessage;
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: InputValidationContext): Diagnostic[];
-}
-export declare const E017InputValidationFailed: E017InputValidationFailedRule;
-export {};
-//# sourceMappingURL=e017-input-validation-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e017-input-validation-failed.js

@@ -1,80 +0,0 @@
-/**
- * E017: Input Validation Failed
- *
- * Condition: Tool input doesn't match declared input schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Tool doesn't handle invalid inputs gracefully
- * - Can cause runtime errors in production
- * - Indicates missing input validation or schema mismatch
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E017InputValidationFailedRule extends BaseRule {
-    id = ERROR_CODES.E017;
-    severity = 'error';
-    ruleName = 'Input Validation Failed';
-    description = "Tool input doesn't match declared input schema. Tool doesn't handle invalid inputs gracefully.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Build parsed error message fragment for a field.
-     * @param parsed - Parsed error details
-     * @param baseError - Base error message as fallback
-     * @returns Error message fragment describing the field validation issue
-     */
-    buildParsedErrorMessage(parsed, baseError) {
-        if (!parsed?.field) {
-            return baseError;
-        }
-        if (parsed.message && parsed.inputType) {
-            return `Field "${parsed.field}" - ${parsed.message} (received invalid type ${parsed.inputType})`;
-        }
-        else if (parsed.message) {
-            return `Field "${parsed.field}" - ${parsed.message}`;
-        }
-        else if (parsed.inputType) {
-            return `Field "${parsed.field}" received invalid type ${parsed.inputType}`;
-        }
-        else {
-            return baseError;
-        }
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        // Build a clear error message
-        const baseError = behavioralCtx.error || 'Invalid input';
-        const parsedMessage = this.buildParsedErrorMessage(behavioralCtx.parsedError, baseError);
-        let message;
-        if (behavioralCtx.testName) {
-            // Test-specific error message
-            if (behavioralCtx.parsedError?.field) {
-                message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" input validation failed: ${parsedMessage}`;
-            }
-            else {
-                message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" input validation failed: ${baseError}`;
-            }
-        }
-        else if (behavioralCtx.parsedError?.field) {
-            message = `Tool "${behavioralCtx.toolName}" input validation failed: ${parsedMessage}`;
-        }
-        else {
-            message = `Tool "${behavioralCtx.toolName}" input validation failed: ${baseError}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Fix input validation to handle edge cases gracefully, update input schema to match actual validation, or add proper error handling for invalid inputs.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            parsedError: behavioralCtx.parsedError,
-            ...behavioralCtx.details,
-        }));
-        return diagnostics;
-    }
-}
-export const E017InputValidationFailed = new E017InputValidationFailedRule();
-//# sourceMappingURL=e017-input-validation-failed.js.map

package/dist/runtime/analysis/rules/errors/e017-output-validation-failed.d.ts

@@ -1,43 +0,0 @@
-/**
- * E017: Output Structure Validation Failed
- *
- * Condition: Tool output doesn't match declared output schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Breaks agent's ability to reason about tool outputs
- * - Can cause downstream errors in tool chains
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for output validation failure detection.
- */
-export interface OutputValidationContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name (if applicable) */
-    testName?: string;
-    /** Test input that caused the failure */
-    testInput?: Record<string, unknown>;
-    /** Expected output schema name */
-    expectedOutputSchema?: string;
-    /** Validation error details */
-    error?: string;
-    /** Additional validation details */
-    details?: Record<string, unknown>;
-}
-declare class E017OutputValidationFailedRule extends BaseRule {
-    readonly id: "E017";
-    readonly severity: "error";
-    readonly ruleName = "Output Structure Validation Failed";
-    readonly description = "Tool output doesn't match declared output schema. This breaks agent's ability to reason about tool outputs.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: OutputValidationContext): Diagnostic[];
-}
-export declare const E017OutputValidationFailed: E017OutputValidationFailedRule;
-export {};
-//# sourceMappingURL=e017-output-validation-failed.d.ts.map