@syrin/cli 1.3.0

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

@@ -0,0 +1,25 @@
+/**
+ * E109: 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 E109NonSerializableRule extends BaseRule {
+    readonly id: "E109";
+    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 E109NonSerializable: E109NonSerializableRule;
+export {};
+//# sourceMappingURL=e109-non-serializable.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * E109: 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';
+/**
+ * Types that are not serializable in JSON.
+ */
+const NON_SERIALIZABLE_TYPES = Object.freeze(new Set(['function', 'undefined', 'symbol', 'bigint']));
+/**
+ * Check if a type is non-serializable.
+ */
+function isNonSerializableType(type) {
+    return NON_SERIALIZABLE_TYPES.has(type.toLowerCase());
+}
+class E109NonSerializableRule extends BaseRule {
+    id = ERROR_CODES.E109;
+    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 E109NonSerializable = new E109NonSerializableRule();
+//# sourceMappingURL=e109-non-serializable.js.map

package/dist/runtime/analysis/rules/errors/e110-tool-ambiguity.d.ts

@@ -0,0 +1,25 @@
+/**
+ * E110: Hard Tool Ambiguity
+ *
+ * Condition:
+ * - Two or more tools:
+ *   - Overlapping descriptions
+ *   - Overlapping schemas
+ *   - No clear differentiator
+ *
+ * Why:
+ * - Tool selection becomes nondeterministic
+ * - Agent behavior changes across runs/models
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+declare class E110ToolAmbiguityRule extends BaseRule {
+    readonly id: "E110";
+    readonly severity: "error";
+    readonly ruleName = "Hard Tool Ambiguity";
+    readonly description = "Multiple tools match the same intent. LLM tool selection is ambiguous.";
+    check(ctx: AnalysisContext): Diagnostic[];
+}
+export declare const E110ToolAmbiguity: E110ToolAmbiguityRule;
+export {};
+//# sourceMappingURL=e110-tool-ambiguity.d.ts.map

package/dist/runtime/analysis/rules/errors/e110-tool-ambiguity.js

@@ -0,0 +1,73 @@
+/**
+ * E110: Hard Tool Ambiguity
+ *
+ * Condition:
+ * - Two or more tools:
+ *   - Overlapping descriptions
+ *   - Overlapping schemas
+ *   - No clear differentiator
+ *
+ * Why:
+ * - Tool selection becomes nondeterministic
+ * - Agent behavior changes across runs/models
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+/**
+ * Calculate similarity between two sets of tokens.
+ */
+function tokenSimilarity(tokens1, tokens2) {
+    if (tokens1.size === 0 || tokens2.size === 0) {
+        return 0.0;
+    }
+    const intersection = new Set([...tokens1].filter(t => tokens2.has(t)));
+    const union = new Set([...tokens1, ...tokens2]);
+    return intersection.size / union.size;
+}
+/**
+ * Calculate schema overlap between two tools.
+ */
+function schemaOverlap(inputs1, inputs2) {
+    const names1 = new Set(inputs1.map(i => i.name.toLowerCase()));
+    const names2 = new Set(inputs2.map(i => i.name.toLowerCase()));
+    const nameOverlapSet = new Set([...names1].filter(n => names2.has(n)));
+    const nameOverlap = nameOverlapSet.size;
+    const totalNames = new Set([...names1, ...names2]).size;
+    if (totalNames === 0) {
+        return 0.0;
+    }
+    return nameOverlap / totalNames;
+}
+class E110ToolAmbiguityRule extends BaseRule {
+    id = ERROR_CODES.E110;
+    severity = 'error';
+    ruleName = 'Hard Tool Ambiguity';
+    description = 'Multiple tools match the same intent. LLM tool selection is ambiguous.';
+    check(ctx) {
+        const diagnostics = [];
+        for (let i = 0; i < ctx.tools.length; i++) {
+            const tool1 = ctx.tools[i];
+            if (!tool1)
+                continue;
+            for (let j = i + 1; j < ctx.tools.length; j++) {
+                const tool2 = ctx.tools[j];
+                if (!tool2)
+                    continue;
+                // Calculate description similarity
+                const descSimilarity = tokenSimilarity(tool1.descriptionTokens, tool2.descriptionTokens);
+                // Calculate schema overlap
+                const inputOverlap = schemaOverlap(tool1.inputs, tool2.inputs);
+                const outputOverlap = schemaOverlap(tool1.outputs, tool2.outputs);
+                const schemaOverlapScore = (inputOverlap + outputOverlap) / 2;
+                // If both description and schema are very similar, it's ambiguous
+                // Threshold: >0.7 description similarity AND >0.5 schema overlap
+                if (descSimilarity > 0.7 && schemaOverlapScore > 0.5) {
+                    diagnostics.push(this.createDiagnostic(`Multiple tools match the same intent: "${tool1.name}", "${tool2.name}". LLM tool selection is ambiguous.`, undefined, undefined, `Differentiate "${tool1.name}" and "${tool2.name}" by making their descriptions and schemas more distinct.`));
+                }
+            }
+        }
+        return diagnostics;
+    }
+}
+export const E110ToolAmbiguity = new E110ToolAmbiguityRule();
+//# sourceMappingURL=e110-tool-ambiguity.js.map

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

@@ -0,0 +1,57 @@
+/**
+ * E200: 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 E200InputValidationFailedRule extends BaseRule {
+    readonly id: "E200";
+    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 E200InputValidationFailed: E200InputValidationFailedRule;
+export {};
+//# sourceMappingURL=e200-input-validation-failed.d.ts.map

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

@@ -0,0 +1,71 @@
+/**
+ * E200: 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 E200InputValidationFailedRule extends BaseRule {
+    id = ERROR_CODES.E200;
+    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);
+        const errorDetail = behavioralCtx.parsedError?.field
+            ? parsedMessage
+            : baseError;
+        const scope = behavioralCtx.testName
+            ? `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}"`
+            : `Tool "${behavioralCtx.toolName}"`;
+        const message = `${scope} input validation failed: ${errorDetail}`;
+        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 E200InputValidationFailed = new E200InputValidationFailedRule();
+//# sourceMappingURL=e200-input-validation-failed.js.map

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

@@ -0,0 +1,43 @@
+/**
+ * E300: 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 E300OutputValidationFailedRule extends BaseRule {
+    readonly id: "E300";
+    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 E300OutputValidationFailed: E300OutputValidationFailedRule;
+export {};
+//# sourceMappingURL=e300-output-validation-failed.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * E300: 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 E300OutputValidationFailedRule extends BaseRule {
+    id = ERROR_CODES.E300;
+    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}`;
+        }
+        // Merge details, filtering out undefined values
+        const details = Object.fromEntries(Object.entries({
+            ...behavioralCtx.details,
+            testName: behavioralCtx.testName,
+            testInput: behavioralCtx.testInput,
+            expectedOutputSchema: behavioralCtx.expectedOutputSchema,
+        }).filter(([, v]) => v !== undefined));
+        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.', details));
+        return diagnostics;
+    }
+}
+export const E300OutputValidationFailed = new E300OutputValidationFailedRule();
+//# sourceMappingURL=e300-output-validation-failed.js.map

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

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

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

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

package/dist/runtime/analysis/rules/errors/e400-tool-execution-failed.d.ts

@@ -0,0 +1,38 @@
+/**
+ * E400: Tool Execution Failed
+ *
+ * Condition: Tool raises an exception during execution
+ *
+ * Why this is fatal:
+ * - Tool crashes instead of handling errors gracefully
+ * - Breaks agent reliability
+ * - Indicates missing error handling or input validation
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+/**
+ * Context for execution error detection.
+ */
+export interface ExecutionErrorContext {
+    /** Tool name */
+    toolName: string;
+    /** Execution errors */
+    errors: Array<{
+        message: string;
+        code?: string;
+    }>;
+}
+declare class E400ToolExecutionFailedRule extends BaseRule {
+    readonly id: "E400";
+    readonly severity: "error";
+    readonly ruleName = "Tool Execution Failed";
+    readonly description = "Tool raises an exception during execution. Tool should handle errors gracefully instead of crashing.";
+    check(_ctx: AnalysisContext): Diagnostic[];
+    /**
+     * Check with behavioral context (called from test orchestrator).
+     */
+    checkWithBehavioralContext(behavioralCtx: ExecutionErrorContext): Diagnostic[];
+}
+export declare const E400ToolExecutionFailed: E400ToolExecutionFailedRule;
+export {};
+//# sourceMappingURL=e400-tool-execution-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e400-tool-execution-failed.js

@@ -0,0 +1,37 @@
+/**
+ * E400: Tool Execution Failed
+ *
+ * Condition: Tool raises an exception during execution
+ *
+ * Why this is fatal:
+ * - Tool crashes instead of handling errors gracefully
+ * - Breaks agent reliability
+ * - Indicates missing error handling or input validation
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+class E400ToolExecutionFailedRule extends BaseRule {
+    id = ERROR_CODES.E400;
+    severity = 'error';
+    ruleName = 'Tool Execution Failed';
+    description = 'Tool raises an exception during execution. Tool should handle errors gracefully instead of crashing.';
+    check(_ctx) {
+        // This rule requires behavioral context
+        return [];
+    }
+    /**
+     * Check with behavioral context (called from test orchestrator).
+     */
+    checkWithBehavioralContext(behavioralCtx) {
+        const diagnostics = [];
+        if (behavioralCtx.errors.length > 0) {
+            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 and validates inputs before processing.'));
+        }
+        return diagnostics;
+    }
+}
+export const E400ToolExecutionFailed = new E400ToolExecutionFailedRule();
+//# sourceMappingURL=e400-tool-execution-failed.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * E403: 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 E403UnboundedExecutionRule extends BaseRule {
+    readonly id: "E403";
+    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 E403UnboundedExecution: E403UnboundedExecutionRule;
+export {};
+//# sourceMappingURL=e403-unbounded-execution.d.ts.map

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

@@ -0,0 +1,66 @@
+/**
+ * E403: 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 E403UnboundedExecutionRule extends BaseRule {
+    id = ERROR_CODES.E403;
+    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 E403UnboundedExecution = new E403UnboundedExecutionRule();
+//# sourceMappingURL=e403-unbounded-execution.js.map