@syrin/cli 1.3.2 → 1.4.0

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

@@ -1,25 +0,0 @@
-/**
- * E005: 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 E005ToolAmbiguityRule extends BaseRule {
-    readonly id: "E005";
-    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 E005ToolAmbiguity: E005ToolAmbiguityRule;
-export {};
-//# sourceMappingURL=e005-tool-ambiguity.d.ts.map

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

@@ -1,73 +0,0 @@
-/**
- * E005: 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 E005ToolAmbiguityRule extends BaseRule {
-    id = ERROR_CODES.E005;
-    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 E005ToolAmbiguity = new E005ToolAmbiguityRule();
-//# sourceMappingURL=e005-tool-ambiguity.js.map

package/dist/runtime/analysis/rules/errors/e006-param-not-in-description.d.ts

@@ -1,22 +0,0 @@
-/**
- * E006: Required Input Not Mentioned in Description
- *
- * Condition:
- * - Required input exists
- * - Tool description does not reference it directly or indirectly
- *
- * Why:
- * - LLM does not know parameter exists or matters
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E006ParamNotInDescriptionRule extends BaseRule {
-    readonly id: "E006";
-    readonly severity: "error";
-    readonly ruleName = "Required Input Not Mentioned in Description";
-    readonly description = "Required parameter is not referenced in tool description. LLM may not know parameter exists.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E006ParamNotInDescription: E006ParamNotInDescriptionRule;
-export {};
-//# sourceMappingURL=e006-param-not-in-description.d.ts.map

package/dist/runtime/analysis/rules/errors/e006-param-not-in-description.js

@@ -1,57 +0,0 @@
-/**
- * E006: Required Input Not Mentioned in Description
- *
- * Condition:
- * - Required input exists
- * - Tool description does not reference it directly or indirectly
- *
- * Why:
- * - LLM does not know parameter exists or matters
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Check if a parameter name appears in the description (case-insensitive).
- */
-function isParameterMentioned(description, paramName) {
-    const descLower = description.toLowerCase();
-    const paramLower = paramName.toLowerCase();
-    // Exact match
-    if (descLower.includes(paramLower)) {
-        return true;
-    }
-    // Check if words from param name appear in description
-    const paramWords = paramLower.split(/\W+/).filter(w => w.length > 2);
-    const descWords = descLower.split(/\W+/);
-    for (const word of paramWords) {
-        if (descWords.includes(word)) {
-            return true;
-        }
-    }
-    return false;
-}
-class E006ParamNotInDescriptionRule extends BaseRule {
-    id = ERROR_CODES.E006;
-    severity = 'error';
-    ruleName = 'Required Input Not Mentioned in Description';
-    description = 'Required parameter is not referenced in tool description. LLM may not know parameter exists.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            const description = tool.description || '';
-            for (const input of tool.inputs) {
-                // Only check required inputs
-                if (!input.required) {
-                    continue;
-                }
-                // Check if parameter is mentioned in description
-                if (!isParameterMentioned(description, input.name)) {
-                    diagnostics.push(this.createDiagnostic(`Required parameter "${input.name}" is not referenced in "${tool.name}" description.`, tool.name, input.name, `Mention "${input.name}" in the tool description so the LLM knows it exists and is required.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E006ParamNotInDescription = new E006ParamNotInDescriptionRule();
-//# sourceMappingURL=e006-param-not-in-description.js.map

package/dist/runtime/analysis/rules/errors/e007-output-not-guaranteed.d.ts

@@ -1,23 +0,0 @@
-/**
- * E007: Output Used Downstream but Not Guaranteed
- *
- * Condition:
- * - Tool output is optional / nullable
- * - Used downstream without fallback
- *
- * Why:
- * - Silent null propagation
- * - Hard-to-debug failures
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E007OutputNotGuaranteedRule extends BaseRule {
-    readonly id: "E007";
-    readonly severity: "error";
-    readonly ruleName = "Output Used Downstream but Not Guaranteed";
-    readonly description = "Output of tool is not guaranteed, but is used by downstream tools without fallback.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E007OutputNotGuaranteed: E007OutputNotGuaranteedRule;
-export {};
-//# sourceMappingURL=e007-output-not-guaranteed.d.ts.map

package/dist/runtime/analysis/rules/errors/e007-output-not-guaranteed.js

@@ -1,56 +0,0 @@
-/**
- * E007: Output Used Downstream but Not Guaranteed
- *
- * Condition:
- * - Tool output is optional / nullable
- * - Used downstream without fallback
- *
- * Why:
- * - Silent null propagation
- * - Hard-to-debug failures
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E007OutputNotGuaranteedRule extends BaseRule {
-    id = ERROR_CODES.E007;
-    severity = 'error';
-    ruleName = 'Output Used Downstream but Not Guaranteed';
-    description = 'Output of tool is not guaranteed, but is used by downstream tools without fallback.';
-    check(ctx) {
-        const diagnostics = [];
-        // Only check high-confidence dependencies (>= 0.8)
-        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
-        for (const dep of highConfidenceDeps) {
-            // Find the output field
-            const fromTool = ctx.indexes.toolIndex.get(dep.fromTool.toLowerCase());
-            if (!fromTool) {
-                continue;
-            }
-            const fromField = fromTool.outputs.find(f => f.name === dep.fromField);
-            if (!fromField) {
-                continue;
-            }
-            // Find the downstream input field
-            const toTool = ctx.indexes.toolIndex.get(dep.toTool.toLowerCase());
-            if (!toTool) {
-                continue;
-            }
-            const toField = toTool.inputs.find(f => f.name === dep.toField);
-            if (!toField) {
-                continue;
-            }
-            // Check if output is not guaranteed and downstream requires it without fallback
-            // Optional upstream always triggers when downstream requires it
-            // Nullable upstream only triggers when downstream is required AND not nullable (can't handle null)
-            if ((!fromField.required && toField.required === true) ||
-                (fromField.nullable === true &&
-                    toField.required === true &&
-                    toField.nullable !== true)) {
-                diagnostics.push(this.createDiagnostic(`Output of "${dep.fromTool}" (field: "${dep.fromField}") is nullable but is used by "${dep.toTool}" without fallback.`, dep.fromTool, dep.fromField, `Make the output of "${dep.fromTool}" non-nullable, or ensure "${dep.toTool}" handles null values.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E007OutputNotGuaranteed = new E007OutputNotGuaranteedRule();
-//# sourceMappingURL=e007-output-not-guaranteed.js.map

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