@syrin/cli 1.3.0

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

@@ -0,0 +1,80 @@
+/**
+ * E018: 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 E018InputValidationFailedRule extends BaseRule {
+    id = ERROR_CODES.E018;
+    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 E018InputValidationFailed = new E018InputValidationFailedRule();
+//# sourceMappingURL=e018-input-validation-failed.js.map

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

@@ -0,0 +1,38 @@
+/**
+ * E018: 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 E018ToolExecutionFailedRule extends BaseRule {
+    readonly id: "E018";
+    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 E018ToolExecutionFailed: E018ToolExecutionFailedRule;
+export {};
+//# sourceMappingURL=e018-tool-execution-failed.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * E018: 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 E018ToolExecutionFailedRule extends BaseRule {
+    id = ERROR_CODES.E018;
+    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 E018ToolExecutionFailed = new E018ToolExecutionFailedRule();
+//# sourceMappingURL=e018-tool-execution-failed.js.map

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

@@ -0,0 +1,38 @@
+/**
+ * E019: 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 E019ToolExecutionFailedRule extends BaseRule {
+    readonly id: "E019";
+    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 E019ToolExecutionFailed: E019ToolExecutionFailedRule;
+export {};
+//# sourceMappingURL=e019-tool-execution-failed.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * E019: 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 E019ToolExecutionFailedRule extends BaseRule {
+    id = ERROR_CODES.E019;
+    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 E019ToolExecutionFailed = new E019ToolExecutionFailedRule();
+//# sourceMappingURL=e019-tool-execution-failed.js.map

package/dist/runtime/analysis/rules/errors/e019-unexpected-test-result.d.ts

@@ -0,0 +1,65 @@
+/**
+ * E019: Unexpected Test Result
+ *
+ * Condition: Test's actual outcome doesn't match its expectation
+ *
+ * Why this is fatal:
+ * - Test contract is inaccurate
+ * - Tool behavior doesn't match declared guarantees
+ * - Can cause false positives/negatives in validation
+ * - Indicates mismatch between expectations and reality
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+/**
+ * Context for unexpected test result detection.
+ */
+export interface UnexpectedTestResultContext {
+    /** Tool name */
+    toolName: string;
+    /** Test name */
+    testName: string;
+    /** Test input */
+    testInput?: Record<string, unknown>;
+    /** Expected outcome (success/error/timeout) */
+    expectedOutcome: 'success' | 'error' | 'timeout';
+    /** Actual outcome (success/error/timeout) */
+    actualOutcome: 'success' | 'error' | 'timeout';
+    /** Expected error code (if expecting error) */
+    expectedErrorCode?: string;
+    /** Expected error type (if expecting error) */
+    expectedErrorType?: string;
+    /** Actual error code (if actual outcome is error) */
+    actualErrorCode?: string;
+    /** Actual error type (if actual outcome is error) */
+    actualErrorType?: string;
+    /** Expected error details (if expecting specific error) */
+    expectedError?: {
+        type?: string;
+        details?: Record<string, unknown>;
+    };
+    /** Actual error details (if actual outcome is error) */
+    actualError?: {
+        code?: string;
+        type?: string;
+        message?: string;
+    };
+}
+declare class E019UnexpectedTestResultRule extends BaseRule {
+    readonly id: "E019";
+    readonly severity: "error";
+    readonly ruleName = "Unexpected Test Result";
+    readonly description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
+    check(_ctx: AnalysisContext): Diagnostic[];
+    /**
+     * Determine if a diagnostic should be created based on behavioral context.
+     */
+    private shouldCreateDiagnostic;
+    /**
+     * Check with behavioral context (called from test orchestrator).
+     */
+    checkWithBehavioralContext(behavioralCtx: UnexpectedTestResultContext): Diagnostic[];
+}
+export declare const E019UnexpectedTestResult: E019UnexpectedTestResultRule;
+export {};
+//# sourceMappingURL=e019-unexpected-test-result.d.ts.map

package/dist/runtime/analysis/rules/errors/e019-unexpected-test-result.js

@@ -0,0 +1,109 @@
+/**
+ * E019: Unexpected Test Result
+ *
+ * Condition: Test's actual outcome doesn't match its expectation
+ *
+ * Why this is fatal:
+ * - Test contract is inaccurate
+ * - Tool behavior doesn't match declared guarantees
+ * - Can cause false positives/negatives in validation
+ * - Indicates mismatch between expectations and reality
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+class E019UnexpectedTestResultRule extends BaseRule {
+    id = ERROR_CODES.E019;
+    severity = 'error';
+    ruleName = 'Unexpected Test Result';
+    description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
+    check(_ctx) {
+        // This rule requires behavioral context
+        return [];
+    }
+    /**
+     * Determine if a diagnostic should be created based on behavioral context.
+     */
+    shouldCreateDiagnostic(behavioralCtx) {
+        // If outcomes don't match, create diagnostic
+        if (behavioralCtx.expectedOutcome !== behavioralCtx.actualOutcome) {
+            return true;
+        }
+        // Outcomes match - check if error details also match (for error cases)
+        if (behavioralCtx.expectedOutcome === 'error') {
+            const expectedType = behavioralCtx.expectedErrorType?.toLowerCase();
+            const actualType = behavioralCtx.actualErrorType?.toLowerCase();
+            if (expectedType && actualType && expectedType !== actualType) {
+                return true; // Type mismatch
+            }
+            if (expectedType && !actualType) {
+                return true; // Expected type but no actual type
+            }
+            const expectedCode = behavioralCtx.expectedErrorCode;
+            const actualCode = behavioralCtx.actualErrorCode;
+            if (expectedCode && actualCode && expectedCode !== actualCode) {
+                return true; // Code mismatch
+            }
+        }
+        return false; // Everything matches
+    }
+    /**
+     * Check with behavioral context (called from test orchestrator).
+     */
+    checkWithBehavioralContext(behavioralCtx) {
+        const diagnostics = [];
+        if (!this.shouldCreateDiagnostic(behavioralCtx)) {
+            return diagnostics;
+        }
+        // If we reach here, there's a mismatch - create diagnostic
+        let message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" expected `;
+        // Build expected description
+        if (behavioralCtx.expectedOutcome === 'success') {
+            message += 'success but got ';
+            if (behavioralCtx.actualOutcome === 'error') {
+                message += `error (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
+            }
+            else if (behavioralCtx.actualOutcome === 'timeout') {
+                message += 'timeout';
+            }
+            else {
+                message += behavioralCtx.actualOutcome;
+            }
+        }
+        else if (behavioralCtx.expectedOutcome === 'error') {
+            message += `error`;
+            if (behavioralCtx.expectedErrorType) {
+                message += ` of type "${behavioralCtx.expectedErrorType}"`;
+            }
+            if (behavioralCtx.expectedErrorCode) {
+                message += ` (code: ${behavioralCtx.expectedErrorCode})`;
+            }
+            message += ' but got ';
+            if (behavioralCtx.actualOutcome === 'success') {
+                message += 'success';
+            }
+            else {
+                message += `${behavioralCtx.actualOutcome} (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
+            }
+            if (behavioralCtx.actualErrorType &&
+                behavioralCtx.expectedErrorType &&
+                behavioralCtx.actualErrorType.toLowerCase() !==
+                    behavioralCtx.expectedErrorType.toLowerCase()) {
+                message += ' with different type';
+            }
+        }
+        else {
+            message += `${behavioralCtx.expectedOutcome} but got ${behavioralCtx.actualOutcome}`;
+        }
+        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Update test expectation to match actual tool behavior, or fix tool implementation to match declared guarantees. Ensure test expectations accurately reflect tool behavior.', {
+            testName: behavioralCtx.testName,
+            testInput: behavioralCtx.testInput,
+            expectedOutcome: behavioralCtx.expectedOutcome,
+            actualOutcome: behavioralCtx.actualOutcome,
+            expectedError: behavioralCtx.expectedError,
+            actualError: behavioralCtx.actualError,
+        }));
+        return diagnostics;
+    }
+}
+export const E019UnexpectedTestResult = new E019UnexpectedTestResultRule();
+//# sourceMappingURL=e019-unexpected-test-result.js.map

package/dist/runtime/analysis/rules/errors/e020-unexpected-test-result.d.ts

@@ -0,0 +1,65 @@
+/**
+ * E020: Unexpected Test Result
+ *
+ * Condition: Test's actual outcome doesn't match its expectation
+ *
+ * Why this is fatal:
+ * - Test contract is inaccurate
+ * - Tool behavior doesn't match declared guarantees
+ * - Can cause false positives/negatives in validation
+ * - Indicates mismatch between expectations and reality
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+/**
+ * Context for unexpected test result detection.
+ */
+export interface UnexpectedTestResultContext {
+    /** Tool name */
+    toolName: string;
+    /** Test name */
+    testName: string;
+    /** Test input */
+    testInput?: Record<string, unknown>;
+    /** Expected outcome (success/error/timeout) */
+    expectedOutcome: 'success' | 'error' | 'timeout';
+    /** Actual outcome (success/error/timeout) */
+    actualOutcome: 'success' | 'error' | 'timeout';
+    /** Expected error code (if expecting error) */
+    expectedErrorCode?: string;
+    /** Expected error type (if expecting error) */
+    expectedErrorType?: string;
+    /** Actual error code (if actual outcome is error) */
+    actualErrorCode?: string;
+    /** Actual error type (if actual outcome is error) */
+    actualErrorType?: string;
+    /** Expected error details (if expecting specific error) */
+    expectedError?: {
+        type?: string;
+        details?: Record<string, unknown>;
+    };
+    /** Actual error details (if actual outcome is error) */
+    actualError?: {
+        code?: string;
+        type?: string;
+        message?: string;
+    };
+}
+declare class E020UnexpectedTestResultRule extends BaseRule {
+    readonly id: "E020";
+    readonly severity: "error";
+    readonly ruleName = "Unexpected Test Result";
+    readonly description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
+    check(_ctx: AnalysisContext): Diagnostic[];
+    /**
+     * Determine if a diagnostic should be created based on behavioral context.
+     */
+    private shouldCreateDiagnostic;
+    /**
+     * Check with behavioral context (called from test orchestrator).
+     */
+    checkWithBehavioralContext(behavioralCtx: UnexpectedTestResultContext): Diagnostic[];
+}
+export declare const E020UnexpectedTestResult: E020UnexpectedTestResultRule;
+export {};
+//# sourceMappingURL=e020-unexpected-test-result.d.ts.map

package/dist/runtime/analysis/rules/errors/e020-unexpected-test-result.js

@@ -0,0 +1,109 @@
+/**
+ * E020: Unexpected Test Result
+ *
+ * Condition: Test's actual outcome doesn't match its expectation
+ *
+ * Why this is fatal:
+ * - Test contract is inaccurate
+ * - Tool behavior doesn't match declared guarantees
+ * - Can cause false positives/negatives in validation
+ * - Indicates mismatch between expectations and reality
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+class E020UnexpectedTestResultRule extends BaseRule {
+    id = ERROR_CODES.E020;
+    severity = 'error';
+    ruleName = 'Unexpected Test Result';
+    description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
+    check(_ctx) {
+        // This rule requires behavioral context
+        return [];
+    }
+    /**
+     * Determine if a diagnostic should be created based on behavioral context.
+     */
+    shouldCreateDiagnostic(behavioralCtx) {
+        // If outcomes don't match, create diagnostic
+        if (behavioralCtx.expectedOutcome !== behavioralCtx.actualOutcome) {
+            return true;
+        }
+        // Outcomes match - check if error details also match (for error cases)
+        if (behavioralCtx.expectedOutcome === 'error') {
+            const expectedType = behavioralCtx.expectedErrorType?.toLowerCase();
+            const actualType = behavioralCtx.actualErrorType?.toLowerCase();
+            if (expectedType && actualType && expectedType !== actualType) {
+                return true; // Type mismatch
+            }
+            if (expectedType && !actualType) {
+                return true; // Expected type but no actual type
+            }
+            const expectedCode = behavioralCtx.expectedErrorCode;
+            const actualCode = behavioralCtx.actualErrorCode;
+            if (expectedCode && actualCode && expectedCode !== actualCode) {
+                return true; // Code mismatch
+            }
+        }
+        return false; // Everything matches
+    }
+    /**
+     * Check with behavioral context (called from test orchestrator).
+     */
+    checkWithBehavioralContext(behavioralCtx) {
+        const diagnostics = [];
+        if (!this.shouldCreateDiagnostic(behavioralCtx)) {
+            return diagnostics;
+        }
+        // If we reach here, there's a mismatch - create diagnostic
+        let message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" expected `;
+        // Build expected description
+        if (behavioralCtx.expectedOutcome === 'success') {
+            message += 'success but got ';
+            if (behavioralCtx.actualOutcome === 'error') {
+                message += `error (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
+            }
+            else if (behavioralCtx.actualOutcome === 'timeout') {
+                message += 'timeout';
+            }
+            else {
+                message += behavioralCtx.actualOutcome;
+            }
+        }
+        else if (behavioralCtx.expectedOutcome === 'error') {
+            message += `error`;
+            if (behavioralCtx.expectedErrorType) {
+                message += ` of type "${behavioralCtx.expectedErrorType}"`;
+            }
+            if (behavioralCtx.expectedErrorCode) {
+                message += ` (code: ${behavioralCtx.expectedErrorCode})`;
+            }
+            message += ' but got ';
+            if (behavioralCtx.actualOutcome === 'success') {
+                message += 'success';
+            }
+            else {
+                message += `${behavioralCtx.actualOutcome} (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
+            }
+            if (behavioralCtx.actualErrorType &&
+                behavioralCtx.expectedErrorType &&
+                behavioralCtx.actualErrorType.toLowerCase() !==
+                    behavioralCtx.expectedErrorType.toLowerCase()) {
+                message += ' with different type';
+            }
+        }
+        else {
+            message += `${behavioralCtx.expectedOutcome} but got ${behavioralCtx.actualOutcome}`;
+        }
+        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Update test expectation to match actual tool behavior, or fix tool implementation to match declared guarantees. Ensure test expectations accurately reflect tool behavior.', {
+            testName: behavioralCtx.testName,
+            testInput: behavioralCtx.testInput,
+            expectedOutcome: behavioralCtx.expectedOutcome,
+            actualOutcome: behavioralCtx.actualOutcome,
+            expectedError: behavioralCtx.expectedError,
+            actualError: behavioralCtx.actualError,
+        }));
+        return diagnostics;
+    }
+}
+export const E020UnexpectedTestResult = new E020UnexpectedTestResultRule();
+//# sourceMappingURL=e020-unexpected-test-result.js.map

package/dist/runtime/analysis/rules/errors/e100-missing-output-schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * E100: Missing Output Schema
+ *
+ * Condition: Tool does not declare an output schema
+ *
+ * Why this is fatal:
+ * - Downstream tools cannot reason about outputs
+ * - LLM will invent structure
+ * - Reproducibility is impossible
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+declare class E100MissingOutputSchemaRule extends BaseRule {
+    readonly id: "E100";
+    readonly severity: "error";
+    readonly ruleName = "Missing Output Schema";
+    readonly description = "Tool does not declare an output schema. Downstream tools cannot safely consume its output.";
+    check(ctx: AnalysisContext): Diagnostic[];
+}
+export declare const E100MissingOutputSchema: E100MissingOutputSchemaRule;
+export {};
+//# sourceMappingURL=e100-missing-output-schema.d.ts.map

package/dist/runtime/analysis/rules/errors/e100-missing-output-schema.js

@@ -0,0 +1,30 @@
+/**
+ * E100: Missing Output Schema
+ *
+ * Condition: Tool does not declare an output schema
+ *
+ * Why this is fatal:
+ * - Downstream tools cannot reason about outputs
+ * - LLM will invent structure
+ * - Reproducibility is impossible
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+class E100MissingOutputSchemaRule extends BaseRule {
+    id = ERROR_CODES.E100;
+    severity = 'error';
+    ruleName = 'Missing Output Schema';
+    description = 'Tool does not declare an output schema. Downstream tools cannot safely consume its output.';
+    check(ctx) {
+        const diagnostics = [];
+        for (const tool of ctx.tools) {
+            // Check if tool has no output fields
+            if (!tool.outputs || tool.outputs.length === 0) {
+                diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" has no output schema. Downstream tools cannot safely consume its output.`, tool.name, undefined, 'Add an output schema to the tool definition to specify the structure of the output.'));
+            }
+        }
+        return diagnostics;
+    }
+}
+export const E100MissingOutputSchema = new E100MissingOutputSchemaRule();
+//# sourceMappingURL=e100-missing-output-schema.js.map

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

@@ -0,0 +1,24 @@
+/**
+ * E101: 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 E101MissingToolDescriptionRule extends BaseRule {
+    readonly id: "E101";
+    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 E101MissingToolDescription: E101MissingToolDescriptionRule;
+export {};
+//# sourceMappingURL=e101-missing-tool-description.d.ts.map