canicode 0.8.8 → 0.9.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { GetFileResponse, Node } from '@figma/rest-api-spec';
 
-var version = "0.8.8";
+var version = "0.9.0";
 
 declare const SeveritySchema: z.ZodEnum<{
     blocking: "blocking";
@@ -14,15 +14,15 @@ declare const SEVERITY_WEIGHT: Record<Severity, number>;
 declare const SEVERITY_LABELS: Record<Severity, string>;
 
 declare const CategorySchema: z.ZodEnum<{
-    layout: "layout";
-    token: "token";
-    component: "component";
-    naming: "naming";
-    "ai-readability": "ai-readability";
-    "handoff-risk": "handoff-risk";
+    "pixel-critical": "pixel-critical";
+    "responsive-critical": "responsive-critical";
+    "code-quality": "code-quality";
+    "token-management": "token-management";
+    semantic: "semantic";
+    interaction: "interaction";
 }>;
 type Category = z.infer<typeof CategorySchema>;
-declare const CATEGORIES: ("layout" | "token" | "component" | "naming" | "ai-readability" | "handoff-risk")[];
+declare const CATEGORIES: ("pixel-critical" | "responsive-critical" | "code-quality" | "token-management" | "semantic" | "interaction")[];
 declare const CATEGORY_LABELS: Record<Category, string>;
 
 /**
@@ -55,12 +55,14 @@ declare const AnalysisNodeTypeSchema: z.ZodEnum<{
     LINK_UNFURL: "LINK_UNFURL";
     TABLE: "TABLE";
     TABLE_CELL: "TABLE_CELL";
+    SLOT: "SLOT";
 }>;
 type AnalysisNodeType = z.infer<typeof AnalysisNodeTypeSchema>;
 declare const LayoutModeSchema: z.ZodEnum<{
     NONE: "NONE";
     HORIZONTAL: "HORIZONTAL";
     VERTICAL: "VERTICAL";
+    GRID: "GRID";
 }>;
 type LayoutMode = z.infer<typeof LayoutModeSchema>;
 declare const LayoutAlignSchema: z.ZodEnum<{
@@ -76,6 +78,42 @@ declare const LayoutPositioningSchema: z.ZodEnum<{
     ABSOLUTE: "ABSOLUTE";
 }>;
 type LayoutPositioning = z.infer<typeof LayoutPositioningSchema>;
+declare const LayoutConstraintSchema: z.ZodObject<{
+    horizontal: z.ZodEnum<{
+        CENTER: "CENTER";
+        LEFT: "LEFT";
+        RIGHT: "RIGHT";
+        LEFT_RIGHT: "LEFT_RIGHT";
+        SCALE: "SCALE";
+    }>;
+    vertical: z.ZodEnum<{
+        CENTER: "CENTER";
+        SCALE: "SCALE";
+        TOP: "TOP";
+        BOTTOM: "BOTTOM";
+        TOP_BOTTOM: "TOP_BOTTOM";
+    }>;
+}, z.core.$strip>;
+type LayoutConstraint = z.infer<typeof LayoutConstraintSchema>;
+declare const LayoutWrapSchema: z.ZodEnum<{
+    NO_WRAP: "NO_WRAP";
+    WRAP: "WRAP";
+}>;
+type LayoutWrap = z.infer<typeof LayoutWrapSchema>;
+declare const OverflowDirectionSchema: z.ZodEnum<{
+    NONE: "NONE";
+    HORIZONTAL_SCROLLING: "HORIZONTAL_SCROLLING";
+    VERTICAL_SCROLLING: "VERTICAL_SCROLLING";
+    HORIZONTAL_AND_VERTICAL_SCROLLING: "HORIZONTAL_AND_VERTICAL_SCROLLING";
+}>;
+type OverflowDirection = z.infer<typeof OverflowDirectionSchema>;
+declare const GridChildAlignSchema: z.ZodEnum<{
+    MIN: "MIN";
+    CENTER: "CENTER";
+    MAX: "MAX";
+    AUTO: "AUTO";
+}>;
+type GridChildAlign = z.infer<typeof GridChildAlignSchema>;
 /**
  * Lightweight FigmaNode type for analysis
  * Contains only properties needed by rules
@@ -109,12 +147,14 @@ declare const BaseAnalysisNodeSchema: z.ZodObject<{
         LINK_UNFURL: "LINK_UNFURL";
         TABLE: "TABLE";
         TABLE_CELL: "TABLE_CELL";
+        SLOT: "SLOT";
     }>;
     visible: z.ZodDefault<z.ZodBoolean>;
     layoutMode: z.ZodOptional<z.ZodEnum<{
         NONE: "NONE";
         HORIZONTAL: "HORIZONTAL";
         VERTICAL: "VERTICAL";
+        GRID: "GRID";
     }>>;
     layoutAlign: z.ZodOptional<z.ZodEnum<{
         MIN: "MIN";
@@ -144,6 +184,65 @@ declare const BaseAnalysisNodeSchema: z.ZodObject<{
     paddingRight: z.ZodOptional<z.ZodNumber>;
     paddingTop: z.ZodOptional<z.ZodNumber>;
     paddingBottom: z.ZodOptional<z.ZodNumber>;
+    minWidth: z.ZodOptional<z.ZodNumber>;
+    maxWidth: z.ZodOptional<z.ZodNumber>;
+    minHeight: z.ZodOptional<z.ZodNumber>;
+    maxHeight: z.ZodOptional<z.ZodNumber>;
+    layoutGrow: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        horizontal: z.ZodEnum<{
+            CENTER: "CENTER";
+            LEFT: "LEFT";
+            RIGHT: "RIGHT";
+            LEFT_RIGHT: "LEFT_RIGHT";
+            SCALE: "SCALE";
+        }>;
+        vertical: z.ZodEnum<{
+            CENTER: "CENTER";
+            SCALE: "SCALE";
+            TOP: "TOP";
+            BOTTOM: "BOTTOM";
+            TOP_BOTTOM: "TOP_BOTTOM";
+        }>;
+    }, z.core.$strip>>;
+    layoutWrap: z.ZodOptional<z.ZodEnum<{
+        NO_WRAP: "NO_WRAP";
+        WRAP: "WRAP";
+    }>>;
+    counterAxisSpacing: z.ZodOptional<z.ZodNumber>;
+    counterAxisAlignContent: z.ZodOptional<z.ZodEnum<{
+        AUTO: "AUTO";
+        SPACE_BETWEEN: "SPACE_BETWEEN";
+    }>>;
+    gridRowCount: z.ZodOptional<z.ZodNumber>;
+    gridColumnCount: z.ZodOptional<z.ZodNumber>;
+    gridRowGap: z.ZodOptional<z.ZodNumber>;
+    gridColumnGap: z.ZodOptional<z.ZodNumber>;
+    gridColumnsSizing: z.ZodOptional<z.ZodString>;
+    gridRowsSizing: z.ZodOptional<z.ZodString>;
+    gridChildHorizontalAlign: z.ZodOptional<z.ZodEnum<{
+        MIN: "MIN";
+        CENTER: "CENTER";
+        MAX: "MAX";
+        AUTO: "AUTO";
+    }>>;
+    gridChildVerticalAlign: z.ZodOptional<z.ZodEnum<{
+        MIN: "MIN";
+        CENTER: "CENTER";
+        MAX: "MAX";
+        AUTO: "AUTO";
+    }>>;
+    gridRowSpan: z.ZodOptional<z.ZodNumber>;
+    gridColumnSpan: z.ZodOptional<z.ZodNumber>;
+    gridRowAnchorIndex: z.ZodOptional<z.ZodNumber>;
+    gridColumnAnchorIndex: z.ZodOptional<z.ZodNumber>;
+    clipsContent: z.ZodOptional<z.ZodBoolean>;
+    overflowDirection: z.ZodOptional<z.ZodEnum<{
+        NONE: "NONE";
+        HORIZONTAL_SCROLLING: "HORIZONTAL_SCROLLING";
+        VERTICAL_SCROLLING: "VERTICAL_SCROLLING";
+        HORIZONTAL_AND_VERTICAL_SCROLLING: "HORIZONTAL_AND_VERTICAL_SCROLLING";
+    }>>;
     absoluteBoundingBox: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
@@ -156,10 +255,19 @@ declare const BaseAnalysisNodeSchema: z.ZodObject<{
     styles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     fills: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     strokes: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    strokeWeight: z.ZodOptional<z.ZodNumber>;
+    individualStrokeWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     effects: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    cornerRadius: z.ZodOptional<z.ZodNumber>;
+    opacity: z.ZodOptional<z.ZodNumber>;
     boundVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     characters: z.ZodOptional<z.ZodString>;
     style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    textTruncation: z.ZodOptional<z.ZodEnum<{
+        DISABLED: "DISABLED";
+        ENDING: "ENDING";
+    }>>;
+    maxLines: z.ZodOptional<z.ZodNumber>;
     devStatus: z.ZodOptional<z.ZodObject<{
         type: z.ZodEnum<{
             NONE: "NONE";
@@ -168,6 +276,7 @@ declare const BaseAnalysisNodeSchema: z.ZodObject<{
         }>;
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    interactions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     isAsset: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type AnalysisNode = z.infer<typeof BaseAnalysisNodeSchema> & {
@@ -182,12 +291,15 @@ declare const AnalysisFileSchema: z.ZodObject<{
     name: z.ZodString;
     lastModified: z.ZodString;
     version: z.ZodString;
+    sourceUrl: z.ZodOptional<z.ZodString>;
     document: z.ZodType<AnalysisNode, unknown, z.core.$ZodTypeInternals<AnalysisNode, unknown>>;
     components: z.ZodRecord<z.ZodString, z.ZodObject<{
         key: z.ZodString;
         name: z.ZodString;
         description: z.ZodString;
     }, z.core.$strip>>;
+    componentDefinitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<AnalysisNode, unknown, z.core.$ZodTypeInternals<AnalysisNode, unknown>>>>;
+    interactionDestinations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<AnalysisNode, unknown, z.core.$ZodTypeInternals<AnalysisNode, unknown>>>>;
     styles: z.ZodRecord<z.ZodString, z.ZodObject<{
         key: z.ZodString;
         name: z.ZodString;
@@ -203,12 +315,12 @@ declare const RuleDefinitionSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     category: z.ZodEnum<{
-        layout: "layout";
-        token: "token";
-        component: "component";
-        naming: "naming";
-        "ai-readability": "ai-readability";
-        "handoff-risk": "handoff-risk";
+        "pixel-critical": "pixel-critical";
+        "responsive-critical": "responsive-critical";
+        "code-quality": "code-quality";
+        "token-management": "token-management";
+        semantic: "semantic";
+        interaction: "interaction";
     }>;
     why: z.ZodString;
     impact: z.ZodString;
@@ -238,18 +350,32 @@ interface RuleContext {
     file: AnalysisFile;
     parent?: AnalysisNode | undefined;
     depth: number;
+    /** Depth relative to the nearest COMPONENT/INSTANCE ancestor. Resets at component boundaries. */
+    componentDepth: number;
     maxDepth: number;
     path: string[];
+    /** Ancestor node types from root to parent (excludes current node). */
+    ancestorTypes: string[];
     siblings?: AnalysisNode[] | undefined;
+    /** Per-analysis shared state. Created fresh for each analysis run, eliminating module-level mutable state. */
+    analysisState: Map<string, unknown>;
 }
+/**
+ * Get or initialize per-analysis state for a rule.
+ * Each key gets its own lazily-initialized state that persists for the duration of one analysis run.
+ */
+declare function getAnalysisState<T>(context: RuleContext, key: string, init: () => T): T;
 /**
  * Rule violation result from check function
  */
 interface RuleViolation {
     ruleId: string;
+    subType?: string;
     nodeId: string;
     nodePath: string;
     message: string;
+    suggestion: string;
+    guide?: string;
 }
 /**
  * Rule check function signature
@@ -265,7 +391,7 @@ interface Rule {
 /**
  * Rule ID type for type safety
  */
-type RuleId = "no-auto-layout" | "absolute-position-in-auto-layout" | "fixed-width-in-responsive-context" | "missing-responsive-behavior" | "group-usage" | "fixed-size-in-auto-layout" | "missing-min-width" | "missing-max-width" | "deep-nesting" | "overflow-hidden-abuse" | "inconsistent-sibling-layout-direction" | "raw-color" | "raw-font" | "inconsistent-spacing" | "magic-number-spacing" | "raw-shadow" | "raw-opacity" | "multiple-fill-colors" | "missing-component" | "detached-instance" | "nested-instance-override" | "variant-not-used" | "component-property-unused" | "single-use-component" | "missing-component-description" | "default-name" | "non-semantic-name" | "inconsistent-naming-convention" | "numeric-suffix-name" | "too-long-name" | "ambiguous-structure" | "z-index-dependent-layout" | "missing-layout-hint" | "invisible-layer" | "empty-frame" | "hardcode-risk" | "text-truncation-unhandled" | "image-no-placeholder" | "prototype-link-in-design" | "no-dev-status";
+type RuleId = "no-auto-layout" | "absolute-position-in-auto-layout" | "non-layout-container" | "fixed-size-in-auto-layout" | "missing-size-constraint" | "missing-component" | "detached-instance" | "variant-structure-mismatch" | "deep-nesting" | "raw-value" | "irregular-spacing" | "missing-interaction-state" | "missing-prototype" | "non-standard-naming" | "non-semantic-name" | "inconsistent-naming-convention";
 /**
  * Categories that support depthWeight
  */
@@ -292,12 +418,12 @@ type Issue = z.infer<typeof IssueSchema>;
 
 declare const CategoryScoreSchema: z.ZodObject<{
     category: z.ZodEnum<{
-        layout: "layout";
-        token: "token";
-        component: "component";
-        naming: "naming";
-        "ai-readability": "ai-readability";
-        "handoff-risk": "handoff-risk";
+        "pixel-critical": "pixel-critical";
+        "responsive-critical": "responsive-critical";
+        "code-quality": "code-quality";
+        "token-management": "token-management";
+        semantic: "semantic";
+        interaction: "interaction";
     }>;
     score: z.ZodNumber;
     maxScore: z.ZodNumber;
@@ -326,12 +452,12 @@ declare const ReportSchema: z.ZodObject<{
     totalScore: z.ZodNumber;
     categoryScores: z.ZodArray<z.ZodObject<{
         category: z.ZodEnum<{
-            layout: "layout";
-            token: "token";
-            component: "component";
-            naming: "naming";
-            "ai-readability": "ai-readability";
-            "handoff-risk": "handoff-risk";
+            "pixel-critical": "pixel-critical";
+            "responsive-critical": "responsive-critical";
+            "code-quality": "code-quality";
+            "token-management": "token-management";
+            semantic: "semantic";
+            interaction: "interaction";
         }>;
         score: z.ZodNumber;
         maxScore: z.ZodNumber;
@@ -364,6 +490,19 @@ declare const ReportSchema: z.ZodObject<{
 }, z.core.$strip>;
 type Report = z.infer<typeof ReportSchema>;
 
+/** Zod schema for CLI visual-compare options (raw CLI input). */
+declare const VisualCompareCliOptionsSchema: z.ZodObject<{
+    figmaUrl: z.ZodOptional<z.ZodString>;
+    figmaScreenshot: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<number, string | number>>>;
+    height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<number, string | number>>>;
+    figmaScale: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<number, string | number>>>;
+    expandRoot: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type VisualCompareCliOptions = z.infer<typeof VisualCompareCliOptionsSchema>;
+
 /**
  * Analysis issue with calculated score and metadata
  */
@@ -375,12 +514,22 @@ interface AnalysisIssue {
     maxDepth: number;
     calculatedScore: number;
 }
+/**
+ * Information about a rule that threw during analysis
+ */
+interface RuleFailure {
+    ruleId: string;
+    nodeName: string;
+    nodeId: string;
+    error: string;
+}
 /**
  * Analysis result from the rule engine
  */
 interface AnalysisResult {
     file: AnalysisFile;
     issues: AnalysisIssue[];
+    failedRules: RuleFailure[];
     maxDepth: number;
     nodeCount: number;
     analyzedAt: string;
@@ -477,10 +626,14 @@ declare function gradeToClassName(grade: Grade): string;
  * Calculate scores from analysis result using density + diversity scoring
  *
  * Density Score = 100 - (weighted issue count / node count) * 100
- * Diversity Score = (1 - unique rules / total category rules) * 100
+ * Diversity Score = (1 - weighted triggered rule scores / total category scores) * 100
  * Final Score = density * 0.7 + diversity * 0.3
+ *
+ * @param result Analysis result with issues
+ * @param configs Optional preset-adjusted config map used to produce the issues.
+ *                If not provided, diversity totals are reconstructed from issue.config values.
  */
-declare function calculateScores(result: AnalysisResult): ScoreReport;
+declare function calculateScores(result: AnalysisResult, configs?: Record<RuleId, RuleConfig>): ScoreReport;
 /**
  * Format score report as a summary string
  */
@@ -497,7 +650,258 @@ declare function getSeverityLabel(severity: Severity): string;
  * Build a JSON-serializable analysis result summary.
  * Shared by CLI (--json) and MCP server (analyze tool response).
  */
-declare function buildResultJson(fileName: string, result: AnalysisResult, scores: ScoreReport): Record<string, unknown>;
+declare function buildResultJson(fileName: string, result: AnalysisResult, scores: ScoreReport, options?: {
+    fileKey?: string;
+}): Record<string, unknown>;
+
+/**
+ * Extract a DOM-like design tree from AnalysisFile.
+ * Converts Figma node tree to a concise text format with inline CSS styles.
+ * AI reads this 1:1 to generate HTML+CSS — no information loss, 50-100x smaller.
+ */
+
+/** Options for design tree generation. */
+interface DesignTreeOptions {
+    /** Directory containing <nodeId>.svg files for VECTOR nodes */
+    vectorDir?: string;
+    /** Directory containing downloaded PNGs and mapping.json for IMAGE fill nodes */
+    imageDir?: string;
+}
+/**
+ * Generate a design tree string from an AnalysisFile.
+ */
+interface DesignTreeResult {
+    /** The design tree text */
+    tree: string;
+    /** Estimated token count (~4 chars per token for mixed code/text) */
+    estimatedTokens: number;
+    /** Raw byte size */
+    bytes: number;
+}
+/**
+ * Generate a design tree string from an AnalysisFile.
+ */
+declare function generateDesignTree(file: AnalysisFile, options?: DesignTreeOptions): string;
+/**
+ * Generate a design tree with token/size statistics.
+ * Use this when you need to measure token consumption for AI context budget.
+ */
+declare function generateDesignTreeWithStats(file: AnalysisFile, options?: DesignTreeOptions): DesignTreeResult;
+
+/**
+ * Strip specific information types from design-tree text for ablation experiments.
+ * Post-processes the generated text — does NOT modify design-tree.ts.
+ *
+ * Flow: generateDesignTree() → stripDesignTree() → send to LLM
+ */
+/** All strip types available (including utility strips not used in experiments). */
+type DesignTreeStripType = "layout-direction-spacing" | "size-constraints" | "position-stacking" | "color-values" | "typography" | "shadows-effects" | "component-references" | "component-descriptions" | "node-names-hierarchy" | "overflow-text-behavior" | "hover-interaction-states" | "variable-references" | "style-references";
+/**
+ * Experiment-relevant strip types only.
+ * Excludes trivially obvious types (color, typography, shadows, overflow, hover)
+ * and no-op types (position-stacking, component-descriptions).
+ */
+type DesignTreeInfoType = "layout-direction-spacing" | "size-constraints" | "component-references" | "node-names-hierarchy" | "variable-references" | "style-references";
+/** All strip types (used for exhaustive testing). */
+declare const ALL_STRIP_TYPES: readonly DesignTreeStripType[];
+/**
+ * Strip experiment types used in calibration ablation (six types).
+ * Keep in sync with `StripTypeEnum` / `STRIP_TYPE_RULES` in the agents layer.
+ * `size-constraints` pairs with responsive rules `missing-size-constraint`, `fixed-size-in-auto-layout`.
+ */
+declare const DESIGN_TREE_INFO_TYPES: readonly DesignTreeInfoType[];
+/**
+ * Strip a specific information type from a design-tree text.
+ * Returns a new string with the target information removed.
+ */
+declare function stripDesignTree(tree: string, type: DesignTreeStripType): string;
+
+declare const DifficultySchema: z.ZodEnum<{
+    easy: "easy";
+    moderate: "moderate";
+    hard: "hard";
+    failed: "failed";
+}>;
+type Difficulty = z.infer<typeof DifficultySchema>;
+declare const RuleRelatedStruggleSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+    description: z.ZodString;
+    actualImpact: z.ZodEnum<{
+        easy: "easy";
+        moderate: "moderate";
+        hard: "hard";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+type RuleRelatedStruggle = z.infer<typeof RuleRelatedStruggleSchema>;
+declare const UncoveredStruggleSchema: z.ZodObject<{
+    description: z.ZodString;
+    suggestedCategory: z.ZodString;
+    estimatedImpact: z.ZodEnum<{
+        easy: "easy";
+        moderate: "moderate";
+        hard: "hard";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+type UncoveredStruggle = z.infer<typeof UncoveredStruggleSchema>;
+declare const ConversionRecordSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    nodePath: z.ZodString;
+    generatedCode: z.ZodString;
+    difficulty: z.ZodEnum<{
+        easy: "easy";
+        moderate: "moderate";
+        hard: "hard";
+        failed: "failed";
+    }>;
+    notes: z.ZodString;
+    ruleRelatedStruggles: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        description: z.ZodString;
+        actualImpact: z.ZodEnum<{
+            easy: "easy";
+            moderate: "moderate";
+            hard: "hard";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    uncoveredStruggles: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        suggestedCategory: z.ZodString;
+        estimatedImpact: z.ZodEnum<{
+            easy: "easy";
+            moderate: "moderate";
+            hard: "hard";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>;
+type ConversionRecord = z.infer<typeof ConversionRecordSchema>;
+declare const StripTypeEnum: z.ZodEnum<{
+    "layout-direction-spacing": "layout-direction-spacing";
+    "size-constraints": "size-constraints";
+    "component-references": "component-references";
+    "node-names-hierarchy": "node-names-hierarchy";
+    "variable-references": "variable-references";
+    "style-references": "style-references";
+}>;
+declare const StripDeltaResultSchema: z.ZodObject<{
+    stripType: z.ZodEnum<{
+        "layout-direction-spacing": "layout-direction-spacing";
+        "size-constraints": "size-constraints";
+        "component-references": "component-references";
+        "node-names-hierarchy": "node-names-hierarchy";
+        "variable-references": "variable-references";
+        "style-references": "style-references";
+    }>;
+    baselineSimilarity: z.ZodNumber;
+    strippedSimilarity: z.ZodNumber;
+    delta: z.ZodNumber;
+    deltaDifficulty: z.ZodEnum<{
+        easy: "easy";
+        moderate: "moderate";
+        hard: "hard";
+        failed: "failed";
+    }>;
+    baselineResponsiveSimilarity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    strippedResponsiveSimilarity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    responsiveDelta: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    responsiveViewport: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    baselineInputTokens: z.ZodOptional<z.ZodNumber>;
+    strippedInputTokens: z.ZodOptional<z.ZodNumber>;
+    tokenDelta: z.ZodOptional<z.ZodNumber>;
+    baselineHtmlBytes: z.ZodOptional<z.ZodNumber>;
+    strippedHtmlBytes: z.ZodOptional<z.ZodNumber>;
+    htmlBytesDelta: z.ZodOptional<z.ZodNumber>;
+    baselineCssClassCount: z.ZodOptional<z.ZodNumber>;
+    strippedCssClassCount: z.ZodOptional<z.ZodNumber>;
+    baselineCssVariableCount: z.ZodOptional<z.ZodNumber>;
+    strippedCssVariableCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const StripDeltasArraySchema: z.ZodArray<z.ZodObject<{
+    stripType: z.ZodEnum<{
+        "layout-direction-spacing": "layout-direction-spacing";
+        "size-constraints": "size-constraints";
+        "component-references": "component-references";
+        "node-names-hierarchy": "node-names-hierarchy";
+        "variable-references": "variable-references";
+        "style-references": "style-references";
+    }>;
+    baselineSimilarity: z.ZodNumber;
+    strippedSimilarity: z.ZodNumber;
+    delta: z.ZodNumber;
+    deltaDifficulty: z.ZodEnum<{
+        easy: "easy";
+        moderate: "moderate";
+        hard: "hard";
+        failed: "failed";
+    }>;
+    baselineResponsiveSimilarity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    strippedResponsiveSimilarity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    responsiveDelta: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    responsiveViewport: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    baselineInputTokens: z.ZodOptional<z.ZodNumber>;
+    strippedInputTokens: z.ZodOptional<z.ZodNumber>;
+    tokenDelta: z.ZodOptional<z.ZodNumber>;
+    baselineHtmlBytes: z.ZodOptional<z.ZodNumber>;
+    strippedHtmlBytes: z.ZodOptional<z.ZodNumber>;
+    htmlBytesDelta: z.ZodOptional<z.ZodNumber>;
+    baselineCssClassCount: z.ZodOptional<z.ZodNumber>;
+    strippedCssClassCount: z.ZodOptional<z.ZodNumber>;
+    baselineCssVariableCount: z.ZodOptional<z.ZodNumber>;
+    strippedCssVariableCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+type StripDeltaResult = z.infer<typeof StripDeltaResultSchema>;
+declare const RuleImpactAssessmentSchema: z.ZodArray<z.ZodObject<{
+    ruleId: z.ZodString;
+    issueCount: z.ZodNumber;
+    actualImpact: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>>;
+declare const UncoveredStrugglesInputSchema: z.ZodArray<z.ZodObject<{
+    description: z.ZodString;
+    suggestedCategory: z.ZodString;
+    estimatedImpact: z.ZodString;
+}, z.core.$strip>>;
+
+/**
+ * Delta-based difficulty mapping for ablation experiments.
+ * Converts pixel similarity delta (baseline - stripped) to a difficulty level.
+ *
+ * Used by calibration pipeline to objectively measure rule impact
+ * instead of relying on Converter self-assessment.
+ */
+
+/**
+ * Map a strip experiment's similarity delta to a difficulty level.
+ *
+ * Delta = baseline similarity - stripped similarity (percentage points).
+ * Higher delta means removing that information caused more pixel degradation.
+ *
+ * Thresholds from issue #191:
+ * - ≤ 5%p  → easy    (removing info barely matters)
+ * - 6-15%p → moderate (noticeable degradation)
+ * - 16-30%p → hard   (significant degradation)
+ * - > 30%p → failed  (critical information)
+ */
+declare function stripDeltaToDifficulty(delta: number): Difficulty;
+/**
+ * Map a token count delta percentage to a difficulty level.
+ *
+ * tokenDelta = baselineInputTokens - strippedInputTokens.
+ * tokenDeltaPercent = tokenDelta / baselineInputTokens * 100.
+ * Higher percentage means removing that info significantly reduces token cost,
+ * i.e. the info contributed a lot of tokens — its absence matters for token management.
+ *
+ * Thresholds:
+ * - ≤ 5%  → easy    (minimal token impact)
+ * - 6-20% → moderate (noticeable token savings)
+ * - 21-40% → hard   (significant token impact)
+ * - > 40% → failed  (critical for token budget)
+ */
+declare function tokenDeltaToDifficulty(baselineTokens: number, strippedTokens: number): Difficulty;
 
 /**
  * Registry for all rules
@@ -547,8 +951,26 @@ declare const ruleRegistry: RuleRegistry;
 declare function defineRule(rule: Rule): Rule;
 
 /**
- * Central configuration for all rules
- * Edit scores/severity here without touching rule logic
+ * Maps each rule ID to its category.
+ * Categories are based on ablation experiment data (PR #149, #150):
+ * - pixel-critical: ΔV ≥ 5% — layout info removal directly degrades pixel accuracy
+ * - responsive-critical: ΔV ≥ 15% at expanded viewport — size info critical for responsive
+ * - code-quality: ΔV ≈ 0% but CSS classes -8~15 — affects code structure, not pixels
+ * - token-management: raw values without design tokens — wrong input = wrong output
+ * - semantic: ΔV < 2%, negligible code difference — naming and semantic issues
+ */
+declare const RULE_ID_CATEGORY: Record<RuleId, Category>;
+/**
+ * Central configuration for all rules.
+ * Scores based on ablation experiment + AI implementation interview (#200):
+ * - pixel-critical: -10 ~ -7 (layout strip caused ΔV +5.4%)
+ * - responsive-critical: -8 ~ -6 (size-constraints ΔV +15.9% at responsive viewports)
+ * - code-quality: -7 ~ -3 (CSS classes -8~15, no pixel impact)
+ * - token-management: -5 ~ -4 (wrong input = wrong output, irregular spacing actively causes errors)
+ * - interaction: -1 (uncalibrated — no metric to validate, kept minimal #210)
+ * - semantic: -4 ~ -1 (non-semantic-name upgraded per interview — causes actual implementation errors)
+ *
+ * Category weights removed (#196) — overall score is simple average of categories.
  */
 declare const RULE_CONFIGS: Record<RuleId, RuleConfig>;
 /**
@@ -566,55 +988,24 @@ declare function getRuleOption<T>(ruleId: RuleId, optionKey: string, defaultValu
 
 declare const noAutoLayout: Rule;
 declare const absolutePositionInAutoLayout: Rule;
-declare const fixedWidthInResponsiveContext: Rule;
-declare const missingResponsiveBehavior: Rule;
-declare const groupUsage: Rule;
 declare const fixedSizeInAutoLayout: Rule;
-declare const missingMinWidth: Rule;
-declare const missingMaxWidth: Rule;
+declare const missingSizeConstraint: Rule;
+declare const nonLayoutContainer: Rule;
 declare const deepNesting: Rule;
-declare const overflowHiddenAbuse: Rule;
-declare const inconsistentSiblingLayoutDirection: Rule;
 
-declare const rawColor: Rule;
-declare const rawFont: Rule;
-declare const inconsistentSpacing: Rule;
-declare const magicNumberSpacing: Rule;
-declare const rawShadow: Rule;
-declare const rawOpacity: Rule;
-declare const multipleFillColors: Rule;
+declare const rawValue: Rule;
+declare const irregularSpacing: Rule;
 
 declare const missingComponent: Rule;
 declare const detachedInstance: Rule;
-declare const nestedInstanceOverride: Rule;
-declare const variantNotUsed: Rule;
-declare const componentPropertyUnused: Rule;
-declare const singleUseComponent: Rule;
-declare const missingComponentDescription: Rule;
-/**
- * Reset deduplication state between analysis runs.
- * Call this at the start of each analysis if the process is long-running
- * (e.g. MCP server mode).
- */
-declare function resetMissingComponentDescriptionState(): void;
+declare const variantStructureMismatch: Rule;
 
-declare const defaultName: Rule;
 declare const nonSemanticName: Rule;
 declare const inconsistentNamingConvention: Rule;
-declare const numericSuffixName: Rule;
-declare const tooLongName: Rule;
-
-declare const ambiguousStructure: Rule;
-declare const zIndexDependentLayout: Rule;
-declare const missingLayoutHint: Rule;
-declare const invisibleLayer: Rule;
-declare const emptyFrame: Rule;
+declare const nonStandardNaming: Rule;
 
-declare const hardcodeRisk: Rule;
-declare const textTruncationUnhandled: Rule;
-declare const imageNoPlaceholder: Rule;
-declare const prototypeLinkInDesign: Rule;
-declare const noDevStatus: Rule;
+declare const missingInteractionState: Rule;
+declare const missingPrototype: Rule;
 
 declare const FigmaUrlInfoSchema: z.ZodObject<{
     fileKey: z.ZodString;
@@ -626,6 +1017,13 @@ declare function parseFigmaUrl(url: string): FigmaUrlInfo;
 declare class FigmaUrlParseError extends Error {
     constructor(message: string);
 }
+/**
+ * Extract the commentable node ID from a potentially nested instance path.
+ * Instance-internal IDs like "I3010:7457;1442:7704" use semicolons to
+ * separate path segments. The Figma Comments API only accepts simple IDs
+ * (e.g. "3010:7457"), so we take the first segment and strip the "I" prefix.
+ */
+declare function toCommentableNodeId(nodeId: string): string;
 declare function buildFigmaDeepLink(fileKey: string, nodeId: string): string;
 
 interface GetFileNodesResponse {
@@ -654,6 +1052,11 @@ declare class FigmaClient {
         format?: "png" | "svg" | "jpg";
         scale?: number;
     }): Promise<Record<string, string | null>>;
+    /**
+     * Get original image fill URLs by imageRef.
+     * Returns a mapping of imageRef → download URL for all image fills in the file.
+     */
+    getImageFills(fileKey: string): Promise<Record<string, string>>;
     /**
      * Download an image URL and return as base64
      */
@@ -675,6 +1078,11 @@ declare function transformFigmaResponse(fileKey: string, response: GetFileRespon
  * Returns the first node's subtree as the document.
  */
 declare function transformFileNodesResponse(fileKey: string, response: GetFileNodesResponse): AnalysisFile;
+/**
+ * Transform component master nodes from a /v1/files/{key}/nodes response.
+ * Each requested node ID is transformed into an AnalysisNode if present.
+ */
+declare function transformComponentMasterNodes(response: GetFileNodesResponse, requestedIds: string[]): Record<string, AnalysisNode>;
 
 /**
  * Load Figma data from a JSON file
@@ -691,25 +1099,32 @@ declare class FigmaFileLoadError extends Error {
 }
 
 /**
- * Parse MCP get_metadata XML output into an AnalysisFile.
- *
- * The XML represents a subtree of the Figma file. We wrap it in a
- * DOCUMENT node and fill in minimal file metadata.
+ * Recursively collect all unique componentId values from INSTANCE nodes.
  */
-declare function parseMcpMetadataXml(xml: string, fileKey: string, fileName?: string): AnalysisFile;
+declare function collectComponentIds(node: AnalysisNode): Set<string>;
 /**
- * Enrich an AnalysisFile (from get_metadata) with style data extracted
- * from get_design_context code output.
+ * Recursively collect all unique interaction destination IDs from nodes.
+ * These are the node IDs that interactions (e.g., ON_HOVER → CHANGE_TO) point to.
+ */
+declare function collectInteractionDestinationIds(node: AnalysisNode): Set<string>;
+/**
+ * Resolve component master node trees via multi-pass fetching.
+ *
+ * Pass 1: collect component IDs from the document tree, fetch their masters.
+ * Pass 2+: collect component IDs from fetched masters that were not in previous passes.
+ * Repeats up to maxPasses (default 2).
  *
- * The design context code is React+Tailwind generated for a specific node.
- * We parse Tailwind classes to extract layout, color, spacing, and effect
- * properties, then merge them into matching AnalysisNodes in the tree.
+ * Batches API calls at BATCH_SIZE IDs per request.
+ * Skips IDs that return null (e.g. external library components).
+ */
+declare function resolveComponentDefinitions(client: FigmaClient, fileKey: string, document: AnalysisNode, maxPasses?: number): Promise<Record<string, AnalysisNode>>;
+/**
+ * Resolve interaction destination nodes (e.g., hover variants).
  *
- * @param file - AnalysisFile from parseMcpMetadataXml
- * @param designContextCode - Code string from get_design_context
- * @param targetNodeId - The node ID that get_design_context was called for (optional)
+ * Collects all destinationId values from interactions in the document,
+ * excludes those already in componentDefinitions, and fetches them.
  */
-declare function enrichWithDesignContext(file: AnalysisFile, designContextCode: string, targetNodeId?: string): void;
+declare function resolveInteractionDestinations(client: FigmaClient, fileKey: string, document: AnalysisNode, existingDefinitions?: Record<string, AnalysisNode>): Promise<Record<string, AnalysisNode>>;
 
 declare const SamplingStrategySchema: z.ZodEnum<{
     all: "all";
@@ -718,13 +1133,13 @@ declare const SamplingStrategySchema: z.ZodEnum<{
 }>;
 type SamplingStrategy = z.infer<typeof SamplingStrategySchema>;
 declare const CalibrationStatusSchema: z.ZodEnum<{
+    failed: "failed";
     pending: "pending";
     analyzing: "analyzing";
     converting: "converting";
     evaluating: "evaluating";
     tuning: "tuning";
     completed: "completed";
-    failed: "failed";
 }>;
 type CalibrationStatus = z.infer<typeof CalibrationStatusSchema>;
 declare const CalibrationConfigSchema: z.ZodObject<{
@@ -738,8 +1153,10 @@ declare const CalibrationConfigSchema: z.ZodObject<{
         random: "random";
     }>>;
     outputPath: z.ZodDefault<z.ZodString>;
+    runDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type CalibrationConfig = z.infer<typeof CalibrationConfigSchema>;
+type CalibrationConfigInput = z.input<typeof CalibrationConfigSchema>;
 interface CalibrationRun {
     config: CalibrationConfig;
     status: CalibrationStatus;
@@ -772,90 +1189,6 @@ interface NodeIssueDetail {
     message: string;
 }
 
-declare const DifficultySchema: z.ZodEnum<{
-    failed: "failed";
-    easy: "easy";
-    moderate: "moderate";
-    hard: "hard";
-}>;
-type Difficulty = z.infer<typeof DifficultySchema>;
-declare const RuleRelatedStruggleSchema: z.ZodObject<{
-    ruleId: z.ZodString;
-    description: z.ZodString;
-    actualImpact: z.ZodEnum<{
-        failed: "failed";
-        easy: "easy";
-        moderate: "moderate";
-        hard: "hard";
-    }>;
-}, z.core.$strip>;
-type RuleRelatedStruggle = z.infer<typeof RuleRelatedStruggleSchema>;
-declare const UncoveredStruggleSchema: z.ZodObject<{
-    description: z.ZodString;
-    suggestedCategory: z.ZodString;
-    estimatedImpact: z.ZodEnum<{
-        failed: "failed";
-        easy: "easy";
-        moderate: "moderate";
-        hard: "hard";
-    }>;
-}, z.core.$strip>;
-type UncoveredStruggle = z.infer<typeof UncoveredStruggleSchema>;
-declare const ConversionRecordSchema: z.ZodObject<{
-    nodeId: z.ZodString;
-    nodePath: z.ZodString;
-    generatedCode: z.ZodString;
-    difficulty: z.ZodEnum<{
-        failed: "failed";
-        easy: "easy";
-        moderate: "moderate";
-        hard: "hard";
-    }>;
-    notes: z.ZodString;
-    ruleRelatedStruggles: z.ZodArray<z.ZodObject<{
-        ruleId: z.ZodString;
-        description: z.ZodString;
-        actualImpact: z.ZodEnum<{
-            failed: "failed";
-            easy: "easy";
-            moderate: "moderate";
-            hard: "hard";
-        }>;
-    }, z.core.$strip>>;
-    uncoveredStruggles: z.ZodArray<z.ZodObject<{
-        description: z.ZodString;
-        suggestedCategory: z.ZodString;
-        estimatedImpact: z.ZodEnum<{
-            failed: "failed";
-            easy: "easy";
-            moderate: "moderate";
-            hard: "hard";
-        }>;
-    }, z.core.$strip>>;
-    durationMs: z.ZodNumber;
-}, z.core.$strip>;
-type ConversionRecord = z.infer<typeof ConversionRecordSchema>;
-interface ConversionExecutorResult {
-    generatedCode: string;
-    difficulty: Difficulty;
-    notes: string;
-    ruleRelatedStruggles: RuleRelatedStruggle[];
-    uncoveredStruggles: UncoveredStruggle[];
-}
-type ConversionExecutor = (nodeId: string, fileKey: string, flaggedRuleIds: string[]) => Promise<ConversionExecutorResult>;
-interface ConversionAgentInput {
-    fileKey: string;
-    nodes: Array<{
-        nodeId: string;
-        nodePath: string;
-        flaggedRuleIds: string[];
-    }>;
-}
-interface ConversionAgentOutput {
-    records: ConversionRecord[];
-    skippedNodeIds: string[];
-}
-
 declare const MismatchTypeSchema: z.ZodEnum<{
     overscored: "overscored";
     underscored: "underscored";
@@ -881,14 +1214,26 @@ declare const MismatchCaseSchema: z.ZodObject<{
         suggestion: "suggestion";
     }>>;
     actualDifficulty: z.ZodEnum<{
-        failed: "failed";
         easy: "easy";
         moderate: "moderate";
         hard: "hard";
+        failed: "failed";
     }>;
     reasoning: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type MismatchCase = z.infer<typeof MismatchCaseSchema>;
+interface StripDeltaForEval {
+    /** Pixel similarity delta (baseline - stripped) at design viewport */
+    pixelDelta: number;
+    /** Responsive pixel similarity delta at expanded viewport (null if not measured) */
+    responsiveDelta: number | null;
+    /** Baseline design-tree input token count */
+    baselineInputTokens: number | null;
+    /** Stripped design-tree input token count */
+    strippedInputTokens: number | null;
+}
 interface EvaluationAgentInput {
     nodeIssueSummaries: Array<{
         nodeId: string;
@@ -914,12 +1259,53 @@ interface EvaluationAgentInput {
         score: number;
         severity: string;
     }>;
+    /**
+     * Responsive viewport comparison delta (similarity - responsiveSimilarity).
+     * Positive = design breaks at expanded viewport. Used to evaluate responsive-critical rules.
+     * null/undefined = no responsive comparison available.
+     */
+    responsiveDelta?: number | null | undefined;
+    /**
+     * Strip ablation results keyed by strip type.
+     * Contains pixel delta, token counts, responsive delta, and HTML metrics per strip.
+     * Used to objectively override AI self-assessment with category-appropriate metrics.
+     * undefined = no strip ablation data available.
+     */
+    stripDeltas?: Record<string, StripDeltaForEval> | undefined;
+    /**
+     * Whether the conversion was whole-design (single root record covering the entire page).
+     * When true, evaluation merges all nodeIssueSummaries' flaggedRuleIds into the single record
+     * so rules flagged on child nodes aren't silently dropped.
+     */
+    wholeDesign?: boolean | undefined;
 }
 interface EvaluationAgentOutput {
     mismatches: MismatchCase[];
     validatedRules: string[];
 }
 
+declare const CrossRunEvidenceGroupSchema: z.ZodObject<{
+    overscoredCount: z.ZodNumber;
+    underscoredCount: z.ZodNumber;
+    overscoredDifficulties: z.ZodArray<z.ZodString>;
+    underscoredDifficulties: z.ZodArray<z.ZodString>;
+    allPro: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allCon: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    lastConfidence: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+    lastDecision: z.ZodOptional<z.ZodEnum<{
+        APPROVE: "APPROVE";
+        REJECT: "REJECT";
+        REVISE: "REVISE";
+        HOLD: "HOLD";
+    }>>;
+}, z.core.$strip>;
+type CrossRunEvidenceGroup = z.infer<typeof CrossRunEvidenceGroupSchema>;
+type CrossRunEvidence = Record<string, CrossRunEvidenceGroup>;
+
 declare const ConfidenceSchema: z.ZodEnum<{
     high: "high";
     medium: "medium";
@@ -949,6 +1335,7 @@ declare const ScoreAdjustmentSchema: z.ZodObject<{
         low: "low";
     }>;
     supportingCases: z.ZodNumber;
+    proposedDisable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type ScoreAdjustment = z.infer<typeof ScoreAdjustmentSchema>;
 declare const NewRuleProposalSchema: z.ZodObject<{
@@ -976,17 +1363,63 @@ interface TuningAgentInput {
         currentSeverity?: string | undefined;
         actualDifficulty: string;
         reasoning: string;
+        category?: string | undefined;
+        description?: string | undefined;
     }>;
     ruleScores: Record<string, {
         score: number;
         severity: string;
     }>;
+    priorEvidence?: CrossRunEvidence;
 }
 interface TuningAgentOutput {
     adjustments: ScoreAdjustment[];
     newRuleProposals: NewRuleProposal[];
 }
 
+declare const GapEntrySchema: z.ZodObject<{
+    category: z.ZodString;
+    description: z.ZodString;
+    pixelImpact: z.ZodOptional<z.ZodString>;
+    coveredByRule: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    coveredByExistingRule: z.ZodOptional<z.ZodBoolean>;
+    existingRule: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    causedByInterpretation: z.ZodOptional<z.ZodBoolean>;
+    actionable: z.ZodOptional<z.ZodBoolean>;
+    suggestedRuleCategory: z.ZodOptional<z.ZodString>;
+    area: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GapEntry = z.infer<typeof GapEntrySchema>;
+declare const GapAnalyzerOutputSchema: z.ZodObject<{
+    fixture: z.ZodOptional<z.ZodString>;
+    similarity: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    gaps: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        description: z.ZodString;
+        pixelImpact: z.ZodOptional<z.ZodString>;
+        coveredByRule: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        coveredByExistingRule: z.ZodOptional<z.ZodBoolean>;
+        existingRule: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        causedByInterpretation: z.ZodOptional<z.ZodBoolean>;
+        actionable: z.ZodOptional<z.ZodBoolean>;
+        suggestedRuleCategory: z.ZodOptional<z.ZodString>;
+        area: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodOptional<z.ZodObject<{
+        totalGaps: z.ZodNumber;
+        actionableGaps: z.ZodNumber;
+        coveredByExistingRules: z.ZodNumber;
+        newRuleCandidates: z.ZodNumber;
+        renderingArtifacts: z.ZodNumber;
+    }, z.core.$strip>>;
+    newRuleSuggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type GapAnalyzerOutput = z.infer<typeof GapAnalyzerOutputSchema>;
+
 /**
  * Extract rule scores map from analysis result for downstream agents
  */
@@ -1002,23 +1435,6 @@ declare function extractRuleScores(result: AnalysisResult): Record<string, {
  */
 declare function runAnalysisAgent(input: AnalysisAgentInput): AnalysisAgentOutput;
 
-/**
- * Conversion Agent - Step 2 of calibration pipeline
- *
- * Attempts code conversion for each node via an injected executor.
- * Uses dependency inversion: the executor handles actual LLM/MCP calls.
- * Failures on individual nodes are captured, not thrown.
- */
-declare function runConversionAgent(input: ConversionAgentInput, executor: ConversionExecutor): Promise<ConversionAgentOutput>;
-
-/**
- * Prompt template for the conversion executor.
- *
- * The executor (typically an LLM session with Figma MCP access) receives
- * this prompt to guide code generation and difficulty assessment.
- */
-declare function buildConversionPrompt(nodeId: string, fileKey: string, flaggedRuleIds: string[]): string;
-
 /**
  * Evaluation Agent - Step 3 of calibration pipeline
  *
@@ -1035,6 +1451,7 @@ declare function runEvaluationAgent(input: EvaluationAgentInput): EvaluationAgen
  */
 declare function runTuningAgent(input: TuningAgentInput): TuningAgentOutput;
 
+/** Data structure for generating calibration report markdown. */
 interface CalibrationReportData {
     fileKey: string;
     fileName: string;
@@ -1048,31 +1465,22 @@ interface CalibrationReportData {
     validatedRules: string[];
     adjustments: ScoreAdjustment[];
     newRuleProposals: NewRuleProposal[];
+    /** Design tree token metrics (optional — present when design-tree stats are available) */
+    tokenMetrics?: {
+        designTreeTokens: number;
+        designTreeBytes: number;
+        tokensPerNode: number;
+    } | undefined;
 }
 /**
  * Generate a CALIBRATION_REPORT.md from calibration pipeline results
  */
 declare function generateCalibrationReport(data: CalibrationReportData): string;
 
-interface CalibrationRunOptions {
-    enableActivityLog?: boolean;
-}
-interface CalibrationRunResult {
-    status: CalibrationStatus;
-    scoreReport: ScoreReport;
-    nodeIssueSummaries: NodeIssueSummary[];
-    mismatches: MismatchCase[];
-    validatedRules: string[];
-    adjustments: ScoreAdjustment[];
-    newRuleProposals: NewRuleProposal[];
-    reportPath: string;
-    logPath?: string | undefined;
-    error?: string;
-}
 /**
  * Run Step 1 only: analysis + save JSON output
  */
-declare function runCalibrationAnalyze(config: CalibrationConfig): Promise<{
+declare function runCalibrationAnalyze(config: CalibrationConfigInput): Promise<{
     analysisOutput: ReturnType<typeof runAnalysisAgent> extends infer T ? T : never;
     ruleScores: Record<string, {
         score: number;
@@ -1091,37 +1499,17 @@ declare function runCalibrationEvaluate(analysisJson: {
     analyzedAt: string;
     nodeCount: number;
     issueCount: number;
-}, conversionJson: {
-    records: Array<{
-        nodeId: string;
-        nodePath: string;
-        difficulty: string;
-        ruleRelatedStruggles: Array<{
-            ruleId: string;
-            description: string;
-            actualImpact: string;
-        }>;
-        uncoveredStruggles: Array<{
-            description: string;
-            suggestedCategory: string;
-            estimatedImpact: string;
-        }>;
-    }>;
-    skippedNodeIds: string[];
-}, ruleScores: Record<string, {
+}, conversionJson: Record<string, unknown>, ruleScores: Record<string, {
     score: number;
     severity: string;
-}>): {
+}>, options?: {
+    collectEvidence?: boolean | undefined;
+    fixtureName?: string | undefined;
+}): {
     evaluationOutput: EvaluationAgentOutput;
     tuningOutput: TuningAgentOutput;
     report: string;
 };
-/**
- * Run the full calibration pipeline
- *
- * Sequence: validate -> load file -> analysis -> node selection -> conversion -> evaluation -> tuning -> report
- */
-declare function runCalibration(config: CalibrationConfig, executor: ConversionExecutor, options?: CalibrationRunOptions): Promise<CalibrationRunResult>;
 
 interface ActivityStep {
     step: string;
@@ -1132,17 +1520,17 @@ interface ActivityStep {
 declare class ActivityLogger {
     private logPath;
     private initialized;
-    constructor(fixturePath?: string, logDir?: string);
+    constructor(runDir: string);
     /**
      * Ensure the log directory and file header exist
      */
     private ensureInitialized;
     /**
-     * Log a pipeline step
+     * Log a pipeline step as a JSON Lines entry
      */
     logStep(activity: ActivityStep): Promise<void>;
     /**
-     * Log a summary at pipeline completion
+     * Log a summary at pipeline completion as a JSON Lines entry
      */
     logSummary(summary: {
         totalDurationMs: number;
@@ -1155,4 +1543,4 @@ declare class ActivityLogger {
     getLogPath(): string;
 }
 
-export { ActivityLogger, type AnalysisAgentInput, type AnalysisAgentOutput, type AnalysisFile, AnalysisFileSchema, type AnalysisIssue, type AnalysisNode, AnalysisNodeSchema, type AnalysisNodeType, AnalysisNodeTypeSchema, type AnalysisResult, CATEGORIES, CATEGORY_LABELS, type CalibrationConfig, CalibrationConfigSchema, type CalibrationRun, type CalibrationStatus, CalibrationStatusSchema, type Category, CategorySchema, type CategoryScore, type CategoryScoreResult, CategoryScoreSchema, type Confidence, ConfidenceSchema, type ConversionAgentInput, type ConversionAgentOutput, type ConversionExecutor, type ConversionExecutorResult, type ConversionRecord, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, type Difficulty, DifficultySchema, type EvaluationAgentInput, type EvaluationAgentOutput, FigmaClient, FigmaClientError, type FigmaClientOptions, FigmaFileLoadError, type FigmaUrlInfo, FigmaUrlInfoSchema, FigmaUrlParseError, type GetFileNodesResponse, type Grade, type Issue, IssueSchema, type LayoutAlign, LayoutAlignSchema, type LayoutMode, LayoutModeSchema, type LayoutPositioning, LayoutPositioningSchema, type MismatchCase, MismatchCaseSchema, type MismatchType, MismatchTypeSchema, type NewRuleProposal, NewRuleProposalSchema, type NodeIssueDetail, type NodeIssueSummary, NodeIssueSummarySchema, type Preset, RULE_CONFIGS, type Report, type ReportMetadata, ReportMetadataSchema, ReportSchema, type Rule, type RuleCheckFn, type RuleConfig, RuleConfigSchema, type RuleContext, type RuleDefinition, RuleDefinitionSchema, RuleEngine, type RuleEngineOptions, type RuleId, type RuleRelatedStruggle, RuleRelatedStruggleSchema, type RuleViolation, SEVERITY_LABELS, SEVERITY_WEIGHT, type SamplingStrategy, SamplingStrategySchema, type ScoreAdjustment, ScoreAdjustmentSchema, type ScoreReport, type Severity, SeveritySchema, type TuningAgentInput, type TuningAgentOutput, type UncoveredStruggle, UncoveredStruggleSchema, version as VERSION, absolutePositionInAutoLayout, ambiguousStructure, analyzeFile, buildConversionPrompt, buildFigmaDeepLink, buildResultJson, calculateScores, componentPropertyUnused, createRuleEngine, deepNesting, defaultName, defineRule, detachedInstance, emptyFrame, enrichWithDesignContext, extractRuleScores, fixedSizeInAutoLayout, fixedWidthInResponsiveContext, formatScoreSummary, generateCalibrationReport, getCategoryLabel, getConfigsWithPreset, getRuleOption, getSeverityLabel, gradeToClassName, groupUsage, hardcodeRisk, imageNoPlaceholder, inconsistentNamingConvention, inconsistentSiblingLayoutDirection, inconsistentSpacing, invisibleLayer, loadFigmaFileFromJson, magicNumberSpacing, missingComponent, missingComponentDescription, missingLayoutHint, missingMaxWidth, missingMinWidth, missingResponsiveBehavior, multipleFillColors, nestedInstanceOverride, noAutoLayout, noDevStatus, nonSemanticName, numericSuffixName, overflowHiddenAbuse, parseFigmaJson, parseFigmaUrl, parseMcpMetadataXml, prototypeLinkInDesign, rawColor, rawFont, rawOpacity, rawShadow, resetMissingComponentDescriptionState, ruleRegistry, runAnalysisAgent, runCalibration, runCalibrationAnalyze, runCalibrationEvaluate, runConversionAgent, runEvaluationAgent, runTuningAgent, singleUseComponent, supportsDepthWeight, textTruncationUnhandled, tooLongName, transformFigmaResponse, transformFileNodesResponse, variantNotUsed, zIndexDependentLayout };
+export { ALL_STRIP_TYPES, ActivityLogger, type AnalysisAgentInput, type AnalysisAgentOutput, type AnalysisFile, AnalysisFileSchema, type AnalysisIssue, type AnalysisNode, AnalysisNodeSchema, type AnalysisNodeType, AnalysisNodeTypeSchema, type AnalysisResult, CATEGORIES, CATEGORY_LABELS, type CalibrationConfig, type CalibrationConfigInput, CalibrationConfigSchema, type CalibrationRun, type CalibrationStatus, CalibrationStatusSchema, type Category, CategorySchema, type CategoryScore, type CategoryScoreResult, CategoryScoreSchema, type Confidence, ConfidenceSchema, type ConversionRecord, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, DESIGN_TREE_INFO_TYPES, type DesignTreeInfoType, type DesignTreeOptions, type DesignTreeResult, type DesignTreeStripType, type Difficulty, DifficultySchema, type EvaluationAgentInput, type EvaluationAgentOutput, FigmaClient, FigmaClientError, type FigmaClientOptions, FigmaFileLoadError, type FigmaUrlInfo, FigmaUrlInfoSchema, FigmaUrlParseError, type GapAnalyzerOutput, GapAnalyzerOutputSchema, type GapEntry, GapEntrySchema, type GetFileNodesResponse, type Grade, type GridChildAlign, GridChildAlignSchema, type Issue, IssueSchema, type LayoutAlign, LayoutAlignSchema, type LayoutConstraint, LayoutConstraintSchema, type LayoutMode, LayoutModeSchema, type LayoutPositioning, LayoutPositioningSchema, type LayoutWrap, LayoutWrapSchema, type MismatchCase, MismatchCaseSchema, type MismatchType, MismatchTypeSchema, type NewRuleProposal, NewRuleProposalSchema, type NodeIssueDetail, type NodeIssueSummary, NodeIssueSummarySchema, type OverflowDirection, OverflowDirectionSchema, type Preset, RULE_CONFIGS, RULE_ID_CATEGORY, type Report, type ReportMetadata, ReportMetadataSchema, ReportSchema, type Rule, type RuleCheckFn, type RuleConfig, RuleConfigSchema, type RuleContext, type RuleDefinition, RuleDefinitionSchema, RuleEngine, type RuleEngineOptions, type RuleFailure, type RuleId, RuleImpactAssessmentSchema, type RuleRelatedStruggle, RuleRelatedStruggleSchema, type RuleViolation, SEVERITY_LABELS, SEVERITY_WEIGHT, type SamplingStrategy, SamplingStrategySchema, type ScoreAdjustment, ScoreAdjustmentSchema, type ScoreReport, type Severity, SeveritySchema, type StripDeltaForEval, type StripDeltaResult, StripDeltaResultSchema, StripDeltasArraySchema, StripTypeEnum, type TuningAgentInput, type TuningAgentOutput, type UncoveredStruggle, UncoveredStruggleSchema, UncoveredStrugglesInputSchema, version as VERSION, type VisualCompareCliOptions, VisualCompareCliOptionsSchema, absolutePositionInAutoLayout, analyzeFile, buildFigmaDeepLink, buildResultJson, calculateScores, collectComponentIds, collectInteractionDestinationIds, createRuleEngine, deepNesting, defineRule, detachedInstance, extractRuleScores, fixedSizeInAutoLayout, formatScoreSummary, generateCalibrationReport, generateDesignTree, generateDesignTreeWithStats, getAnalysisState, getCategoryLabel, getConfigsWithPreset, getRuleOption, getSeverityLabel, gradeToClassName, inconsistentNamingConvention, irregularSpacing, loadFigmaFileFromJson, missingComponent, missingInteractionState, missingPrototype, missingSizeConstraint, noAutoLayout, nonLayoutContainer, nonSemanticName, nonStandardNaming, parseFigmaJson, parseFigmaUrl, rawValue, resolveComponentDefinitions, resolveInteractionDestinations, ruleRegistry, runAnalysisAgent, runCalibrationAnalyze, runCalibrationEvaluate, runEvaluationAgent, runTuningAgent, stripDeltaToDifficulty, stripDesignTree, supportsDepthWeight, toCommentableNodeId, tokenDeltaToDifficulty, transformComponentMasterNodes, transformFigmaResponse, transformFileNodesResponse, variantStructureMismatch };