@documentation-robotics/cli 0.1.0 → 0.1.5

package/dist/audit/differential-analyzer.js

@@ -0,0 +1,183 @@
+class DifferentialAnalyzer {
+  /**
+   * Compare two audit reports
+   */
+  analyze(before, after) {
+    const { comparison: coverageComparison, skipped: skippedLayers } = this.analyzeCoverage(before.coverage, after.coverage), gapChanges = this.analyzeGaps(before.gaps, after.gaps), duplicateChanges = this.analyzeDuplicates(before.duplicates, after.duplicates), balanceChanges = this.analyzeBalance(before.balance, after.balance), connectivityChanges = this.analyzeConnectivity(before.connectivity, after.connectivity);
+    return {
+      summary: this.generateSummary(after.timestamp, coverageComparison, gapChanges, duplicateChanges, balanceChanges),
+      detailed: {
+        coverageByLayer: coverageComparison,
+        gapChanges,
+        duplicateChanges,
+        balanceChanges,
+        connectivityChanges,
+        skippedLayers
+      }
+    };
+  }
+  /**
+   * Analyze coverage changes across layers
+   */
+  analyzeCoverage(before, after) {
+    const comparison = /* @__PURE__ */ new Map(), skipped = [], beforeMap = new Map(before.map((c) => [c.layer, c])), afterMap = new Map(after.map((c) => [c.layer, c]));
+    for (const beforeCoverage of before)
+      afterMap.has(beforeCoverage.layer) || skipped.push({
+        layer: beforeCoverage.layer,
+        reason: "only-in-before",
+        coverage: beforeCoverage
+      });
+    for (const afterCoverage of after) {
+      const beforeCoverage = beforeMap.get(afterCoverage.layer);
+      if (!beforeCoverage) {
+        skipped.push({
+          layer: afterCoverage.layer,
+          reason: "only-in-after",
+          coverage: afterCoverage
+        });
+        continue;
+      }
+      const deltas = {
+        isolationChange: afterCoverage.isolationPercentage - beforeCoverage.isolationPercentage,
+        densityChange: afterCoverage.relationshipsPerNodeType - beforeCoverage.relationshipsPerNodeType,
+        utilizationChange: afterCoverage.utilizationPercentage - beforeCoverage.utilizationPercentage,
+        nodeTypeCountChange: afterCoverage.nodeTypeCount - beforeCoverage.nodeTypeCount,
+        relationshipCountChange: afterCoverage.relationshipCount - beforeCoverage.relationshipCount
+      }, improvements = [], regressions = [];
+      deltas.isolationChange < -5 ? improvements.push(`Isolation reduced by ${Math.abs(deltas.isolationChange).toFixed(1)}%`) : deltas.isolationChange > 5 && regressions.push(`Isolation increased by ${deltas.isolationChange.toFixed(1)}%`), deltas.densityChange > 0.5 ? improvements.push(`Density increased by ${deltas.densityChange.toFixed(2)}`) : deltas.densityChange < -0.5 && regressions.push(`Density decreased by ${Math.abs(deltas.densityChange).toFixed(2)}`), deltas.utilizationChange > 5 ? improvements.push(`Predicate utilization increased by ${deltas.utilizationChange.toFixed(1)}%`) : deltas.utilizationChange < -5 && regressions.push(`Predicate utilization decreased by ${Math.abs(deltas.utilizationChange).toFixed(1)}%`), comparison.set(afterCoverage.layer, {
+        layer: afterCoverage.layer,
+        before: beforeCoverage,
+        after: afterCoverage,
+        deltas,
+        improvements,
+        regressions
+      });
+    }
+    return { comparison, skipped };
+  }
+  /**
+   * Analyze gap changes
+   */
+  analyzeGaps(before, after) {
+    const beforeSigs = new Set(before.map((g) => this.gapSignature(g))), afterSigs = new Set(after.map((g) => this.gapSignature(g))), resolved = before.filter((g) => !afterSigs.has(this.gapSignature(g))), newGaps = after.filter((g) => !beforeSigs.has(this.gapSignature(g))), persistent = after.filter((g) => beforeSigs.has(this.gapSignature(g))), resolutionRate = before.length > 0 ? resolved.length / before.length * 100 : 0;
+    return {
+      before,
+      after,
+      resolved,
+      newGaps,
+      persistent,
+      resolutionRate
+    };
+  }
+  /**
+   * Generate gap signature for comparison
+   */
+  gapSignature(gap) {
+    return `${gap.sourceNodeType}:${gap.destinationNodeType}:${gap.suggestedPredicate}`;
+  }
+  /**
+   * Analyze duplicate changes
+   */
+  analyzeDuplicates(before, after) {
+    const beforeSigs = new Set(before.map((d) => this.duplicateSignature(d))), afterSigs = new Set(after.map((d) => this.duplicateSignature(d))), resolved = before.filter((d) => !afterSigs.has(this.duplicateSignature(d))), newDuplicates = after.filter((d) => !beforeSigs.has(this.duplicateSignature(d))), persistent = after.filter((d) => beforeSigs.has(this.duplicateSignature(d))), eliminationRate = before.length > 0 ? resolved.length / before.length * 100 : 0;
+    return {
+      before,
+      after,
+      resolved,
+      newDuplicates,
+      persistent,
+      eliminationRate
+    };
+  }
+  /**
+   * Generate duplicate signature for comparison
+   */
+  duplicateSignature(dup) {
+    const sorted = [...dup.relationships].sort();
+    return `${sorted[0]}:${sorted[1]}`;
+  }
+  /**
+   * Analyze balance changes
+   */
+  analyzeBalance(before, after) {
+    const beforeMap = new Map(before.map((b) => [b.nodeType, b])), improvements = [], regressions = [], newlyBalanced = [];
+    for (const afterAssessment of after) {
+      const beforeAssessment = beforeMap.get(afterAssessment.nodeType);
+      if (!beforeAssessment)
+        continue;
+      const beforeDistance = this.distanceFromBalance(beforeAssessment), afterDistance = this.distanceFromBalance(afterAssessment);
+      afterDistance < beforeDistance ? improvements.push(afterAssessment) : afterDistance > beforeDistance && regressions.push(afterAssessment), beforeAssessment.status !== "balanced" && afterAssessment.status === "balanced" && newlyBalanced.push(afterAssessment);
+    }
+    return {
+      before,
+      after,
+      improvements,
+      regressions,
+      newlyBalanced
+    };
+  }
+  /**
+   * Calculate distance from balanced state
+   */
+  distanceFromBalance(assessment) {
+    const [min, max] = assessment.targetRange, target = (min + max) / 2;
+    return Math.abs(assessment.currentCount - target);
+  }
+  /**
+   * Analyze connectivity changes
+   */
+  analyzeConnectivity(before, after) {
+    const beforeStats = {
+      componentCount: before.components.length,
+      isolatedNodes: before.stats.isolatedNodes,
+      averageDegree: before.stats.averageDegree
+    }, afterStats = {
+      componentCount: after.components.length,
+      isolatedNodes: after.stats.isolatedNodes,
+      averageDegree: after.stats.averageDegree
+    };
+    return {
+      before: beforeStats,
+      after: afterStats,
+      deltas: {
+        componentChange: afterStats.componentCount - beforeStats.componentCount,
+        isolationChange: afterStats.isolatedNodes - beforeStats.isolatedNodes,
+        degreeChange: afterStats.averageDegree - beforeStats.averageDegree
+      }
+    };
+  }
+  /**
+   * Generate summary report
+   */
+  generateSummary(timestamp, coverageComparison, gapChanges, duplicateChanges, balanceChanges) {
+    const coverageChanges = Array.from(coverageComparison.values()).map((comp) => ({
+      layer: comp.layer,
+      before: {
+        isolation: comp.before.isolationPercentage,
+        density: comp.before.relationshipsPerNodeType
+      },
+      after: {
+        isolation: comp.after.isolationPercentage,
+        density: comp.after.relationshipsPerNodeType
+      },
+      delta: {
+        isolation: comp.deltas.isolationChange,
+        density: comp.deltas.densityChange
+      }
+    })), relationshipsAdded = Array.from(coverageComparison.values()).reduce((sum, comp) => sum + comp.deltas.relationshipCountChange, 0), balanceImprovements = balanceChanges.newlyBalanced.map((b) => `${b.nodeType} achieved balanced density (${b.currentCount} relationships)`);
+    return {
+      timestamp,
+      coverageChanges,
+      relationshipsAdded: Math.max(0, relationshipsAdded),
+      // Only count additions
+      gapsResolved: gapChanges.resolved.length,
+      remainingGaps: gapChanges.after.length,
+      duplicatesResolved: duplicateChanges.resolved.length,
+      balanceImprovements
+    };
+  }
+}
+export {
+  DifferentialAnalyzer
+};
+//# sourceMappingURL=differential-analyzer.js.map

package/dist/audit/differential-analyzer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/audit/differential-analyzer.ts"],
+  "sourcesContent": ["/**\n * Differential analysis for before/after audit comparison\n *\n * Analyzes changes between two audit snapshots to identify\n * improvements, regressions, and trends in relationship quality.\n */\n\nimport {\n  AuditReport,\n  SummaryReport,\n  CoverageMetrics,\n  GapCandidate,\n  DuplicateCandidate,\n  BalanceAssessment,\n} from \"./types.js\";\n\n/**\n * Detailed differential analysis result\n */\nexport interface DifferentialAnalysis {\n  summary: SummaryReport;\n  detailed: {\n    coverageByLayer: Map<string, CoverageComparison>;\n    gapChanges: GapChanges;\n    duplicateChanges: DuplicateChanges;\n    balanceChanges: BalanceChanges;\n    connectivityChanges: ConnectivityComparison;\n    skippedLayers: SkippedLayer[]; // Layers that couldn't be compared\n  };\n}\n\n/**\n * Information about a layer that was skipped during comparison\n */\nexport interface SkippedLayer {\n  layer: string;\n  reason: \"only-in-before\" | \"only-in-after\";\n  coverage?: CoverageMetrics; // Coverage metrics if available\n}\n\n/**\n * Coverage comparison for a single layer\n */\nexport interface CoverageComparison {\n  layer: string;\n  before: CoverageMetrics;\n  after: CoverageMetrics;\n  deltas: {\n    isolationChange: number; // Negative = improvement\n    densityChange: number; // Positive = improvement\n    utilizationChange: number; // Positive = improvement\n    nodeTypeCountChange: number;\n    relationshipCountChange: number;\n  };\n  improvements: string[];\n  regressions: string[];\n}\n\n/**\n * Gap analysis changes\n */\nexport interface GapChanges {\n  before: GapCandidate[];\n  after: GapCandidate[];\n  resolved: GapCandidate[]; // Gaps that disappeared\n  newGaps: GapCandidate[]; // New gaps introduced\n  persistent: GapCandidate[]; // Gaps still present\n  /** Percentage of gaps resolved (0-100) */\n  resolutionRate: number;\n}\n\n/**\n * Duplicate analysis changes\n */\nexport interface DuplicateChanges {\n  before: DuplicateCandidate[];\n  after: DuplicateCandidate[];\n  resolved: DuplicateCandidate[]; // Duplicates eliminated\n  newDuplicates: DuplicateCandidate[]; // New duplicates introduced\n  persistent: DuplicateCandidate[]; // Still duplicated\n  /** Percentage of duplicates eliminated (0-100) */\n  eliminationRate: number;\n}\n\n/**\n * Balance assessment changes\n */\nexport interface BalanceChanges {\n  before: BalanceAssessment[];\n  after: BalanceAssessment[];\n  improvements: BalanceAssessment[]; // Moved toward balanced\n  regressions: BalanceAssessment[]; // Moved away from balanced\n  newlyBalanced: BalanceAssessment[]; // Achieved balanced status\n}\n\n/**\n * Connectivity comparison\n */\nexport interface ConnectivityComparison {\n  before: {\n    componentCount: number;\n    isolatedNodes: number;\n    averageDegree: number;\n  };\n  after: {\n    componentCount: number;\n    isolatedNodes: number;\n    averageDegree: number;\n  };\n  deltas: {\n    componentChange: number; // Negative = more connected\n    isolationChange: number; // Negative = improvement\n    degreeChange: number; // Positive = more connected\n  };\n}\n\n/**\n * Analyzer for comparing audit snapshots\n */\nexport class DifferentialAnalyzer {\n  /**\n   * Compare two audit reports\n   */\n  analyze(before: AuditReport, after: AuditReport): DifferentialAnalysis {\n    const { comparison: coverageComparison, skipped: skippedLayers } =\n      this.analyzeCoverage(before.coverage as CoverageMetrics[], after.coverage as CoverageMetrics[]);\n    const gapChanges = this.analyzeGaps(before.gaps as GapCandidate[], after.gaps as GapCandidate[]);\n    const duplicateChanges = this.analyzeDuplicates(\n      before.duplicates as DuplicateCandidate[],\n      after.duplicates as DuplicateCandidate[],\n    );\n    const balanceChanges = this.analyzeBalance(before.balance as BalanceAssessment[], after.balance as BalanceAssessment[]);\n    const connectivityChanges = this.analyzeConnectivity(\n      before.connectivity,\n      after.connectivity,\n    );\n\n    const summary = this.generateSummary(\n      after.timestamp,\n      coverageComparison,\n      gapChanges,\n      duplicateChanges,\n      balanceChanges,\n    );\n\n    return {\n      summary,\n      detailed: {\n        coverageByLayer: coverageComparison,\n        gapChanges,\n        duplicateChanges,\n        balanceChanges,\n        connectivityChanges,\n        skippedLayers,\n      },\n    };\n  }\n\n  /**\n   * Analyze coverage changes across layers\n   */\n  private analyzeCoverage(\n    before: CoverageMetrics[],\n    after: CoverageMetrics[],\n  ): {\n    comparison: Map<string, CoverageComparison>;\n    skipped: SkippedLayer[];\n  } {\n    const comparison = new Map<string, CoverageComparison>();\n    const skipped: SkippedLayer[] = [];\n\n    // Create lookup maps for before and after states\n    const beforeMap = new Map(before.map((c) => [c.layer, c]));\n    const afterMap = new Map(after.map((c) => [c.layer, c]));\n\n    // Check for layers only in \"before\"\n    for (const beforeCoverage of before) {\n      if (!afterMap.has(beforeCoverage.layer)) {\n        skipped.push({\n          layer: beforeCoverage.layer,\n          reason: \"only-in-before\",\n          coverage: beforeCoverage,\n        });\n      }\n    }\n\n    for (const afterCoverage of after) {\n      const beforeCoverage = beforeMap.get(afterCoverage.layer);\n      if (!beforeCoverage) {\n        // New layer in after state - track as skipped\n        skipped.push({\n          layer: afterCoverage.layer,\n          reason: \"only-in-after\",\n          coverage: afterCoverage,\n        });\n        continue;\n      }\n\n      const deltas = {\n        isolationChange:\n          afterCoverage.isolationPercentage -\n          beforeCoverage.isolationPercentage,\n        densityChange:\n          afterCoverage.relationshipsPerNodeType -\n          beforeCoverage.relationshipsPerNodeType,\n        utilizationChange:\n          afterCoverage.utilizationPercentage -\n          beforeCoverage.utilizationPercentage,\n        nodeTypeCountChange:\n          afterCoverage.nodeTypeCount - beforeCoverage.nodeTypeCount,\n        relationshipCountChange:\n          afterCoverage.relationshipCount - beforeCoverage.relationshipCount,\n      };\n\n      const improvements: string[] = [];\n      const regressions: string[] = [];\n\n      // Analyze changes\n      if (deltas.isolationChange < -5) {\n        improvements.push(\n          `Isolation reduced by ${Math.abs(deltas.isolationChange).toFixed(1)}%`,\n        );\n      } else if (deltas.isolationChange > 5) {\n        regressions.push(\n          `Isolation increased by ${deltas.isolationChange.toFixed(1)}%`,\n        );\n      }\n\n      if (deltas.densityChange > 0.5) {\n        improvements.push(\n          `Density increased by ${deltas.densityChange.toFixed(2)}`,\n        );\n      } else if (deltas.densityChange < -0.5) {\n        regressions.push(\n          `Density decreased by ${Math.abs(deltas.densityChange).toFixed(2)}`,\n        );\n      }\n\n      if (deltas.utilizationChange > 5) {\n        improvements.push(\n          `Predicate utilization increased by ${deltas.utilizationChange.toFixed(1)}%`,\n        );\n      } else if (deltas.utilizationChange < -5) {\n        regressions.push(\n          `Predicate utilization decreased by ${Math.abs(deltas.utilizationChange).toFixed(1)}%`,\n        );\n      }\n\n      comparison.set(afterCoverage.layer, {\n        layer: afterCoverage.layer,\n        before: beforeCoverage,\n        after: afterCoverage,\n        deltas,\n        improvements,\n        regressions,\n      });\n    }\n\n    return { comparison, skipped };\n  }\n\n  /**\n   * Analyze gap changes\n   */\n  private analyzeGaps(\n    before: GapCandidate[],\n    after: GapCandidate[],\n  ): GapChanges {\n    // Create gap signatures for comparison\n    const beforeSigs = new Set(\n      before.map((g) => this.gapSignature(g)),\n    );\n    const afterSigs = new Set(after.map((g) => this.gapSignature(g)));\n\n    const resolved = before.filter(\n      (g) => !afterSigs.has(this.gapSignature(g)),\n    );\n    const newGaps = after.filter(\n      (g) => !beforeSigs.has(this.gapSignature(g)),\n    );\n    const persistent = after.filter((g) =>\n      beforeSigs.has(this.gapSignature(g)),\n    );\n\n    const resolutionRate =\n      before.length > 0 ? (resolved.length / before.length) * 100 : 0;\n\n    return {\n      before,\n      after,\n      resolved,\n      newGaps,\n      persistent,\n      resolutionRate,\n    };\n  }\n\n  /**\n   * Generate gap signature for comparison\n   */\n  private gapSignature(gap: GapCandidate): string {\n    return `${gap.sourceNodeType}:${gap.destinationNodeType}:${gap.suggestedPredicate}`;\n  }\n\n  /**\n   * Analyze duplicate changes\n   */\n  private analyzeDuplicates(\n    before: DuplicateCandidate[],\n    after: DuplicateCandidate[],\n  ): DuplicateChanges {\n    const beforeSigs = new Set(\n      before.map((d) => this.duplicateSignature(d)),\n    );\n    const afterSigs = new Set(\n      after.map((d) => this.duplicateSignature(d)),\n    );\n\n    const resolved = before.filter(\n      (d) => !afterSigs.has(this.duplicateSignature(d)),\n    );\n    const newDuplicates = after.filter(\n      (d) => !beforeSigs.has(this.duplicateSignature(d)),\n    );\n    const persistent = after.filter((d) =>\n      beforeSigs.has(this.duplicateSignature(d)),\n    );\n\n    const eliminationRate =\n      before.length > 0 ? (resolved.length / before.length) * 100 : 0;\n\n    return {\n      before,\n      after,\n      resolved,\n      newDuplicates,\n      persistent,\n      eliminationRate,\n    };\n  }\n\n  /**\n   * Generate duplicate signature for comparison\n   */\n  private duplicateSignature(dup: DuplicateCandidate): string {\n    // Sort relationship IDs for consistent comparison\n    const sorted = [...dup.relationships].sort();\n    return `${sorted[0]}:${sorted[1]}`;\n  }\n\n  /**\n   * Analyze balance changes\n   */\n  private analyzeBalance(\n    before: BalanceAssessment[],\n    after: BalanceAssessment[],\n  ): BalanceChanges {\n    const beforeMap = new Map(before.map((b) => [b.nodeType, b]));\n\n    const improvements: BalanceAssessment[] = [];\n    const regressions: BalanceAssessment[] = [];\n    const newlyBalanced: BalanceAssessment[] = [];\n\n    for (const afterAssessment of after) {\n      const beforeAssessment = beforeMap.get(afterAssessment.nodeType);\n      if (!beforeAssessment) {\n        continue;\n      }\n\n      // Check if moved toward balanced\n      const beforeDistance = this.distanceFromBalance(beforeAssessment);\n      const afterDistance = this.distanceFromBalance(afterAssessment);\n\n      if (afterDistance < beforeDistance) {\n        improvements.push(afterAssessment);\n      } else if (afterDistance > beforeDistance) {\n        regressions.push(afterAssessment);\n      }\n\n      // Check if newly balanced\n      if (\n        beforeAssessment.status !== \"balanced\" &&\n        afterAssessment.status === \"balanced\"\n      ) {\n        newlyBalanced.push(afterAssessment);\n      }\n    }\n\n    return {\n      before,\n      after,\n      improvements,\n      regressions,\n      newlyBalanced,\n    };\n  }\n\n  /**\n   * Calculate distance from balanced state\n   */\n  private distanceFromBalance(assessment: BalanceAssessment): number {\n    const [min, max] = assessment.targetRange;\n    const target = (min + max) / 2;\n    return Math.abs(assessment.currentCount - target);\n  }\n\n  /**\n   * Analyze connectivity changes\n   */\n  private analyzeConnectivity(\n    before: AuditReport[\"connectivity\"],\n    after: AuditReport[\"connectivity\"],\n  ): ConnectivityComparison {\n    const beforeStats = {\n      componentCount: before.components.length,\n      isolatedNodes: before.stats.isolatedNodes,\n      averageDegree: before.stats.averageDegree,\n    };\n\n    const afterStats = {\n      componentCount: after.components.length,\n      isolatedNodes: after.stats.isolatedNodes,\n      averageDegree: after.stats.averageDegree,\n    };\n\n    return {\n      before: beforeStats,\n      after: afterStats,\n      deltas: {\n        componentChange: afterStats.componentCount - beforeStats.componentCount,\n        isolationChange: afterStats.isolatedNodes - beforeStats.isolatedNodes,\n        degreeChange: afterStats.averageDegree - beforeStats.averageDegree,\n      },\n    };\n  }\n\n  /**\n   * Generate summary report\n   */\n  private generateSummary(\n    timestamp: string,\n    coverageComparison: Map<string, CoverageComparison>,\n    gapChanges: GapChanges,\n    duplicateChanges: DuplicateChanges,\n    balanceChanges: BalanceChanges,\n  ): SummaryReport {\n    const coverageChanges = Array.from(coverageComparison.values()).map(\n      (comp) => ({\n        layer: comp.layer,\n        before: {\n          isolation: comp.before.isolationPercentage,\n          density: comp.before.relationshipsPerNodeType,\n        },\n        after: {\n          isolation: comp.after.isolationPercentage,\n          density: comp.after.relationshipsPerNodeType,\n        },\n        delta: {\n          isolation: comp.deltas.isolationChange,\n          density: comp.deltas.densityChange,\n        },\n      }),\n    );\n\n    // Calculate total relationships added\n    const relationshipsAdded = Array.from(coverageComparison.values()).reduce(\n      (sum, comp) => sum + comp.deltas.relationshipCountChange,\n      0,\n    );\n\n    // Generate balance improvement descriptions\n    const balanceImprovements = balanceChanges.newlyBalanced.map(\n      (b) => `${b.nodeType} achieved balanced density (${b.currentCount} relationships)`,\n    );\n\n    return {\n      timestamp,\n      coverageChanges,\n      relationshipsAdded: Math.max(0, relationshipsAdded), // Only count additions\n      gapsResolved: gapChanges.resolved.length,\n      remainingGaps: gapChanges.after.length,\n      duplicatesResolved: duplicateChanges.resolved.length,\n      balanceImprovements,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/audit/index.js

@@ -0,0 +1,32 @@
+import { CoverageAnalyzer } from "./relationships/analysis/coverage-analyzer.js";
+import { DuplicateDetector } from "./relationships/analysis/duplicate-detector.js";
+import { GapAnalyzer } from "./relationships/analysis/gap-analyzer.js";
+import { BalanceAssessor } from "./relationships/analysis/balance-assessor.js";
+import { RelationshipGraph } from "./relationships/graph/relationship-graph.js";
+import { ConnectivityAnalyzer } from "./relationships/graph/connectivity.js";
+import { SnapshotStorage } from "./snapshot-storage.js";
+import { DifferentialAnalyzer } from "./differential-analyzer.js";
+import { AuditAIRunner } from "./ai/runner.js";
+import { PromptTemplates } from "./relationships/ai/prompts.js";
+import { ResponseParser } from "./relationships/ai/parser.js";
+import { AIEvaluator, InMemoryProgressTracker } from "./relationships/ai/evaluator.js";
+import { AuditOrchestrator } from "./relationships/spec/orchestrator.js";
+import { ModelAuditOrchestrator } from "./relationships/model/orchestrator.js";
+export {
+  AIEvaluator,
+  AuditAIRunner,
+  AuditOrchestrator,
+  BalanceAssessor,
+  ConnectivityAnalyzer,
+  CoverageAnalyzer,
+  DifferentialAnalyzer,
+  DuplicateDetector,
+  GapAnalyzer,
+  InMemoryProgressTracker,
+  ModelAuditOrchestrator,
+  PromptTemplates,
+  RelationshipGraph,
+  ResponseParser,
+  SnapshotStorage
+};
+//# sourceMappingURL=index.js.map

package/dist/audit/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/audit/index.ts"],
+  "sourcesContent": ["/**\n * Relationship Audit System - Public API\n *\n * Exports all audit analysis components and types.\n */\n\n// Type definitions\nexport type {\n  CoverageMetrics,\n  DuplicateCandidate,\n  GapCandidate,\n  BalanceAssessment,\n  ConnectedComponent,\n  NodeDegree,\n  TransitiveChain,\n  SummaryReport,\n  AuditReport,\n  ConnectivityStats,\n  LayerData,\n} from \"./types.js\";\n\n// Analysis components\nexport { CoverageAnalyzer } from \"./relationships/analysis/coverage-analyzer.js\";\nexport { DuplicateDetector } from \"./relationships/analysis/duplicate-detector.js\";\nexport { GapAnalyzer } from \"./relationships/analysis/gap-analyzer.js\";\nexport type { GapAnalysisResult } from \"./relationships/analysis/gap-analyzer.js\";\nexport { BalanceAssessor } from \"./relationships/analysis/balance-assessor.js\";\n\n// Graph components\nexport { RelationshipGraph } from \"./relationships/graph/relationship-graph.js\";\nexport { ConnectivityAnalyzer } from \"./relationships/graph/connectivity.js\";\n\n// Snapshot and differential analysis components\nexport { SnapshotStorage } from \"./snapshot-storage.js\";\nexport type { SnapshotMetadata, SnapshotStorageConfig } from \"./snapshot-storage.js\";\nexport { DifferentialAnalyzer } from \"./differential-analyzer.js\";\nexport type {\n  DifferentialAnalysis,\n  CoverageComparison,\n  GapChanges,\n  DuplicateChanges,\n  BalanceChanges,\n  ConnectivityComparison,\n  SkippedLayer,\n} from \"./differential-analyzer.js\";\n\n// AI evaluation components\nexport { AuditAIRunner } from \"./ai/runner.js\";\nexport { PromptTemplates } from \"./relationships/ai/prompts.js\";\nexport { ResponseParser } from \"./relationships/ai/parser.js\";\nexport type {\n  RelationshipRecommendation,\n  LayerReview,\n  InterLayerValidation,\n} from \"./relationships/ai/parser.js\";\nexport { AIEvaluator, InMemoryProgressTracker } from \"./relationships/ai/evaluator.js\";\nexport type { ProgressTracker, AIEvaluationConfig } from \"./relationships/ai/evaluator.js\";\n\n// Spec relationship orchestrator\nexport { AuditOrchestrator } from \"./relationships/spec/orchestrator.js\";\nexport type { AuditOptions, AuditComponents } from \"./relationships/spec/orchestrator.js\";\n\n// Model relationship orchestrator\nexport { ModelAuditOrchestrator } from \"./relationships/model/orchestrator.js\";\nexport type { ModelAuditOptions } from \"./relationships/model/orchestrator.js\";\n"],
+  "mappings": "AAsBA,SAAS,wBAAwB;AACjC,SAAS,yBAAyB;AAClC,SAAS,mBAAmB;AAE5B,SAAS,uBAAuB;AAGhC,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AAGrC,SAAS,uBAAuB;AAEhC,SAAS,4BAA4B;AAYrC,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,sBAAsB;AAM/B,SAAS,aAAa,+BAA+B;AAIrD,SAAS,yBAAyB;AAIlC,SAAS,8BAA8B;",
+  "names": []
+}

package/dist/audit/nodes/ai/evaluator.js

@@ -0,0 +1,49 @@
+import { NodePromptTemplates } from "./prompts.js";
+import { NodeResponseParser } from "./parser.js";
+import { AuditAIRunner, AIEvaluationAbortError } from "../../ai/runner.js";
+import { getErrorMessage } from "../../../utils/errors.js";
+const INVOKE_TIMEOUT_MS = 5 * 60 * 1e3;
+class NodeAIEvaluator {
+  runner;
+  promptTemplates;
+  responseParser;
+  constructor() {
+    this.runner = new AuditAIRunner(), this.promptTemplates = new NodePromptTemplates(), this.responseParser = new NodeResponseParser();
+  }
+  /**
+   * Evaluate each layer sequentially, returning one LayerAIReview per layer.
+   * Layers with zero schemas are skipped.
+   * Fails fast after maxConsecutiveFailures consecutive Claude invocation failures.
+   */
+  async evaluateLayers(layerDefs, schemasByLayer) {
+    const reviews = [];
+    for (const layerDef of layerDefs) {
+      const schemas = schemasByLayer.get(layerDef.id) ?? [];
+      if (schemas.length === 0)
+        continue;
+      const standard = layerDef.inspiredBy ? `${layerDef.inspiredBy.standard} ${layerDef.inspiredBy.version}` : this.promptTemplates.getFallbackStandard(layerDef.id);
+      process.stderr.write(`  Evaluating layer: ${layerDef.id} (${schemas.length} node types)...
+`);
+      try {
+        const prompt = this.promptTemplates.layerEvaluation({ layerDef, schemas }), response = await this.runner.invoke(prompt, `layer: ${layerDef.id}`, INVOKE_TIMEOUT_MS), nodeEvaluations = this.responseParser.parseLayerEvaluation(response), avgAlignmentScore = nodeEvaluations.length > 0 ? nodeEvaluations.reduce((sum, e) => sum + e.alignmentScore, 0) / nodeEvaluations.length : 0, avgDocumentationScore = nodeEvaluations.length > 0 ? nodeEvaluations.reduce((sum, e) => sum + e.documentationScore, 0) / nodeEvaluations.length : 0;
+        reviews.push({
+          layerId: layerDef.id,
+          standard,
+          nodeEvaluations,
+          avgAlignmentScore: Math.round(avgAlignmentScore * 10) / 10,
+          avgDocumentationScore: Math.round(avgDocumentationScore * 10) / 10
+        });
+      } catch (error) {
+        const msg = getErrorMessage(error);
+        if (process.stderr.write(`  \u26A0\uFE0F  Failed to evaluate layer ${layerDef.id}: ${msg}
+`), error instanceof AIEvaluationAbortError)
+          throw error;
+      }
+    }
+    return reviews;
+  }
+}
+export {
+  NodeAIEvaluator
+};
+//# sourceMappingURL=evaluator.js.map

package/dist/audit/nodes/ai/evaluator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/ai/evaluator.ts"],
+  "sourcesContent": ["import type { LayerDefinition, ParsedNodeSchema, LayerAIReview } from \"../types.js\";\nimport { NodePromptTemplates } from \"./prompts.js\";\nimport { NodeResponseParser } from \"./parser.js\";\nimport { AuditAIRunner, AIEvaluationAbortError } from \"../../ai/runner.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\n\nconst INVOKE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes per invocation\n\nexport class NodeAIEvaluator {\n  private readonly runner: AuditAIRunner;\n  private readonly promptTemplates: NodePromptTemplates;\n  private readonly responseParser: NodeResponseParser;\n\n  constructor() {\n    this.runner = new AuditAIRunner();\n    this.promptTemplates = new NodePromptTemplates();\n    this.responseParser = new NodeResponseParser();\n  }\n\n  /**\n   * Evaluate each layer sequentially, returning one LayerAIReview per layer.\n   * Layers with zero schemas are skipped.\n   * Fails fast after maxConsecutiveFailures consecutive Claude invocation failures.\n   */\n  async evaluateLayers(\n    layerDefs: LayerDefinition[],\n    schemasByLayer: Map<string, ParsedNodeSchema[]>\n  ): Promise<LayerAIReview[]> {\n    const reviews: LayerAIReview[] = [];\n\n    for (const layerDef of layerDefs) {\n      const schemas = schemasByLayer.get(layerDef.id) ?? [];\n      if (schemas.length === 0) {\n        continue;\n      }\n\n      const standard = layerDef.inspiredBy\n        ? `${layerDef.inspiredBy.standard} ${layerDef.inspiredBy.version}`\n        : this.promptTemplates.getFallbackStandard(layerDef.id);\n\n      process.stderr.write(`  Evaluating layer: ${layerDef.id} (${schemas.length} node types)...\\n`);\n\n      try {\n        const prompt = this.promptTemplates.layerEvaluation({ layerDef, schemas });\n        const response = await this.runner.invoke(prompt, `layer: ${layerDef.id}`, INVOKE_TIMEOUT_MS);\n        const nodeEvaluations = this.responseParser.parseLayerEvaluation(response);\n\n        const avgAlignmentScore =\n          nodeEvaluations.length > 0\n            ? nodeEvaluations.reduce((sum, e) => sum + e.alignmentScore, 0) / nodeEvaluations.length\n            : 0;\n        const avgDocumentationScore =\n          nodeEvaluations.length > 0\n            ? nodeEvaluations.reduce((sum, e) => sum + e.documentationScore, 0) /\n              nodeEvaluations.length\n            : 0;\n\n        reviews.push({\n          layerId: layerDef.id,\n          standard,\n          nodeEvaluations,\n          avgAlignmentScore: Math.round(avgAlignmentScore * 10) / 10,\n          avgDocumentationScore: Math.round(avgDocumentationScore * 10) / 10,\n        });\n      } catch (error: unknown) {\n        const msg = getErrorMessage(error);\n        process.stderr.write(`  \u26A0\uFE0F  Failed to evaluate layer ${layerDef.id}: ${msg}\\n`);\n\n        if (error instanceof AIEvaluationAbortError) {\n          throw error;\n        }\n      }\n    }\n\n    return reviews;\n  }\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AACpC,SAAS,0BAA0B;AACnC,SAAS,eAAe,8BAA8B;AACtD,SAAS,uBAAuB;AAEhC,MAAM,oBAAoB,IAAI,KAAK;AAE7B,MAAO,gBAAe;EACT;EACA;EACA;EAEjB,cAAA;AACE,SAAK,SAAS,IAAI,cAAa,GAC/B,KAAK,kBAAkB,IAAI,oBAAmB,GAC9C,KAAK,iBAAiB,IAAI,mBAAkB;EAC9C;;;;;;EAOA,MAAM,eACJ,WACA,gBAA+C;AAE/C,UAAM,UAA2B,CAAA;AAEjC,eAAW,YAAY,WAAW;AAChC,YAAM,UAAU,eAAe,IAAI,SAAS,EAAE,KAAK,CAAA;AACnD,UAAI,QAAQ,WAAW;AACrB;AAGF,YAAM,WAAW,SAAS,aACtB,GAAG,SAAS,WAAW,QAAQ,IAAI,SAAS,WAAW,OAAO,KAC9D,KAAK,gBAAgB,oBAAoB,SAAS,EAAE;AAExD,cAAQ,OAAO,MAAM,uBAAuB,SAAS,EAAE,KAAK,QAAQ,MAAM;CAAmB;AAE7F,UAAI;AACF,cAAM,SAAS,KAAK,gBAAgB,gBAAgB,EAAE,UAAU,QAAO,CAAE,GACnE,WAAW,MAAM,KAAK,OAAO,OAAO,QAAQ,UAAU,SAAS,EAAE,IAAI,iBAAiB,GACtF,kBAAkB,KAAK,eAAe,qBAAqB,QAAQ,GAEnE,oBACJ,gBAAgB,SAAS,IACrB,gBAAgB,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,gBAAgB,CAAC,IAAI,gBAAgB,SAChF,GACA,wBACJ,gBAAgB,SAAS,IACrB,gBAAgB,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,oBAAoB,CAAC,IAChE,gBAAgB,SAChB;AAEN,gBAAQ,KAAK;UACX,SAAS,SAAS;UAClB;UACA;UACA,mBAAmB,KAAK,MAAM,oBAAoB,EAAE,IAAI;UACxD,uBAAuB,KAAK,MAAM,wBAAwB,EAAE,IAAI;SACjE;MACH,SAAS,OAAgB;AACvB,cAAM,MAAM,gBAAgB,KAAK;AAGjC,YAFA,QAAQ,OAAO,MAAM,4CAAkC,SAAS,EAAE,KAAK,GAAG;CAAI,GAE1E,iBAAiB;AACnB,gBAAM;MAEV;IACF;AAEA,WAAO;EACT;;",
+  "names": []
+}

package/dist/audit/nodes/ai/parser.js

@@ -0,0 +1,55 @@
+import { getErrorMessage } from "../../../utils/errors.js";
+class NodeResponseParser {
+  /**
+   * Parse NodeAIEvaluation[] from a Claude response string.
+   * Tries code-fenced JSON first, falls back to raw array extraction.
+   */
+  parseLayerEvaluation(response) {
+    const codeBlockMatch = response.match(/```json\n([\s\S]*?)\n```/), rawArrayMatch = response.match(/\[[\s\S]*\]/), jsonMatch = codeBlockMatch ?? rawArrayMatch;
+    if (!jsonMatch) {
+      const truncated = response.substring(0, 200);
+      throw new Error(`Failed to extract JSON array from AI response. Expected JSON array in code block or raw JSON array.
+Received: ${truncated}${response.length > 200 ? "..." : ""}`);
+    }
+    const jsonString = codeBlockMatch ? codeBlockMatch[1] : jsonMatch[0];
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonString);
+    } catch (error) {
+      const truncated = jsonString.substring(0, 200);
+      throw new Error(`Failed to parse JSON from AI response: ${getErrorMessage(error)}
+Received: ${truncated}${jsonString.length > 200 ? "..." : ""}`);
+    }
+    if (!Array.isArray(parsed))
+      throw new Error("Expected JSON array of node evaluations from AI response");
+    return parsed.map((item, index) => this.validateItem(item, index));
+  }
+  validateItem(item, index) {
+    if (typeof item != "object" || item === null)
+      throw new Error(`Node evaluation at index ${index} is not a valid object`);
+    const obj = item;
+    if (!obj.specNodeId || typeof obj.specNodeId != "string")
+      throw new Error(`Node evaluation at index ${index} missing or invalid field: specNodeId (must be non-empty string)`);
+    if (typeof obj.alignmentScore != "number")
+      throw new Error(`Node evaluation at index ${index} missing or invalid field: alignmentScore (must be number)`);
+    if (typeof obj.documentationScore != "number")
+      throw new Error(`Node evaluation at index ${index} missing or invalid field: documentationScore (must be number)`);
+    if (!obj.alignmentReasoning || typeof obj.alignmentReasoning != "string")
+      throw new Error(`Node evaluation at index ${index} missing or invalid field: alignmentReasoning (must be non-empty string)`);
+    if (!obj.documentationReasoning || typeof obj.documentationReasoning != "string")
+      throw new Error(`Node evaluation at index ${index} missing or invalid field: documentationReasoning (must be non-empty string)`);
+    const suggestions = Array.isArray(obj.suggestions) && obj.suggestions.every((s) => typeof s == "string") ? obj.suggestions : [];
+    return {
+      specNodeId: obj.specNodeId,
+      alignmentScore: Math.max(0, Math.min(100, Math.round(obj.alignmentScore))),
+      alignmentReasoning: obj.alignmentReasoning,
+      documentationScore: Math.max(0, Math.min(100, Math.round(obj.documentationScore))),
+      documentationReasoning: obj.documentationReasoning,
+      suggestions
+    };
+  }
+}
+export {
+  NodeResponseParser
+};
+//# sourceMappingURL=parser.js.map

package/dist/audit/nodes/ai/parser.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/ai/parser.ts"],
+  "sourcesContent": ["import type { NodeAIEvaluation } from \"../types.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\n\nexport class NodeResponseParser {\n  /**\n   * Parse NodeAIEvaluation[] from a Claude response string.\n   * Tries code-fenced JSON first, falls back to raw array extraction.\n   */\n  parseLayerEvaluation(response: string): NodeAIEvaluation[] {\n    // 1. Try code block: ```json\\n...\\n```\n    const codeBlockMatch = response.match(/```json\\n([\\s\\S]*?)\\n```/);\n    // 2. Fall back to raw array\n    const rawArrayMatch = response.match(/\\[[\\s\\S]*\\]/);\n\n    const jsonMatch = codeBlockMatch ?? rawArrayMatch;\n    if (!jsonMatch) {\n      const truncated = response.substring(0, 200);\n      throw new Error(\n        `Failed to extract JSON array from AI response. Expected JSON array in code block or raw JSON array.\\nReceived: ${truncated}${response.length > 200 ? \"...\" : \"\"}`\n      );\n    }\n\n    const jsonString = codeBlockMatch ? codeBlockMatch[1] : jsonMatch[0];\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(jsonString);\n    } catch (error: unknown) {\n      const truncated = jsonString.substring(0, 200);\n      throw new Error(\n        `Failed to parse JSON from AI response: ${getErrorMessage(error)}\\nReceived: ${truncated}${jsonString.length > 200 ? \"...\" : \"\"}`\n      );\n    }\n\n    if (!Array.isArray(parsed)) {\n      throw new Error(\"Expected JSON array of node evaluations from AI response\");\n    }\n\n    return parsed.map((item: unknown, index: number) => this.validateItem(item, index));\n  }\n\n  private validateItem(item: unknown, index: number): NodeAIEvaluation {\n    if (typeof item !== \"object\" || item === null) {\n      throw new Error(`Node evaluation at index ${index} is not a valid object`);\n    }\n\n    const obj = item as Record<string, unknown>;\n\n    if (!obj.specNodeId || typeof obj.specNodeId !== \"string\") {\n      throw new Error(\n        `Node evaluation at index ${index} missing or invalid field: specNodeId (must be non-empty string)`\n      );\n    }\n\n    if (typeof obj.alignmentScore !== \"number\") {\n      throw new Error(\n        `Node evaluation at index ${index} missing or invalid field: alignmentScore (must be number)`\n      );\n    }\n\n    if (typeof obj.documentationScore !== \"number\") {\n      throw new Error(\n        `Node evaluation at index ${index} missing or invalid field: documentationScore (must be number)`\n      );\n    }\n\n    if (!obj.alignmentReasoning || typeof obj.alignmentReasoning !== \"string\") {\n      throw new Error(\n        `Node evaluation at index ${index} missing or invalid field: alignmentReasoning (must be non-empty string)`\n      );\n    }\n\n    if (!obj.documentationReasoning || typeof obj.documentationReasoning !== \"string\") {\n      throw new Error(\n        `Node evaluation at index ${index} missing or invalid field: documentationReasoning (must be non-empty string)`\n      );\n    }\n\n    const suggestions = Array.isArray(obj.suggestions) &&\n      obj.suggestions.every((s) => typeof s === \"string\")\n      ? (obj.suggestions as string[])\n      : [];\n\n    return {\n      specNodeId: obj.specNodeId,\n      alignmentScore: Math.max(0, Math.min(100, Math.round(obj.alignmentScore))),\n      alignmentReasoning: obj.alignmentReasoning,\n      documentationScore: Math.max(0, Math.min(100, Math.round(obj.documentationScore))),\n      documentationReasoning: obj.documentationReasoning,\n      suggestions,\n    };\n  }\n}\n"],
+  "mappings": "AACA,SAAS,uBAAuB;AAE1B,MAAO,mBAAkB;;;;;EAK7B,qBAAqB,UAAgB;AAEnC,UAAM,iBAAiB,SAAS,MAAM,0BAA0B,GAE1D,gBAAgB,SAAS,MAAM,aAAa,GAE5C,YAAY,kBAAkB;AACpC,QAAI,CAAC,WAAW;AACd,YAAM,YAAY,SAAS,UAAU,GAAG,GAAG;AAC3C,YAAM,IAAI,MACR;YAAkH,SAAS,GAAG,SAAS,SAAS,MAAM,QAAQ,EAAE,EAAE;IAEtK;AAEA,UAAM,aAAa,iBAAiB,eAAe,CAAC,IAAI,UAAU,CAAC;AACnE,QAAI;AACJ,QAAI;AACF,eAAS,KAAK,MAAM,UAAU;IAChC,SAAS,OAAgB;AACvB,YAAM,YAAY,WAAW,UAAU,GAAG,GAAG;AAC7C,YAAM,IAAI,MACR,0CAA0C,gBAAgB,KAAK,CAAC;YAAe,SAAS,GAAG,WAAW,SAAS,MAAM,QAAQ,EAAE,EAAE;IAErI;AAEA,QAAI,CAAC,MAAM,QAAQ,MAAM;AACvB,YAAM,IAAI,MAAM,0DAA0D;AAG5E,WAAO,OAAO,IAAI,CAAC,MAAe,UAAkB,KAAK,aAAa,MAAM,KAAK,CAAC;EACpF;EAEQ,aAAa,MAAe,OAAa;AAC/C,QAAI,OAAO,QAAS,YAAY,SAAS;AACvC,YAAM,IAAI,MAAM,4BAA4B,KAAK,wBAAwB;AAG3E,UAAM,MAAM;AAEZ,QAAI,CAAC,IAAI,cAAc,OAAO,IAAI,cAAe;AAC/C,YAAM,IAAI,MACR,4BAA4B,KAAK,kEAAkE;AAIvG,QAAI,OAAO,IAAI,kBAAmB;AAChC,YAAM,IAAI,MACR,4BAA4B,KAAK,4DAA4D;AAIjG,QAAI,OAAO,IAAI,sBAAuB;AACpC,YAAM,IAAI,MACR,4BAA4B,KAAK,gEAAgE;AAIrG,QAAI,CAAC,IAAI,sBAAsB,OAAO,IAAI,sBAAuB;AAC/D,YAAM,IAAI,MACR,4BAA4B,KAAK,0EAA0E;AAI/G,QAAI,CAAC,IAAI,0BAA0B,OAAO,IAAI,0BAA2B;AACvE,YAAM,IAAI,MACR,4BAA4B,KAAK,8EAA8E;AAInH,UAAM,cAAc,MAAM,QAAQ,IAAI,WAAW,KAC/C,IAAI,YAAY,MAAM,CAAC,MAAM,OAAO,KAAM,QAAQ,IAC/C,IAAI,cACL,CAAA;AAEJ,WAAO;MACL,YAAY,IAAI;MAChB,gBAAgB,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,KAAK,MAAM,IAAI,cAAc,CAAC,CAAC;MACzE,oBAAoB,IAAI;MACxB,oBAAoB,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,KAAK,MAAM,IAAI,kBAAkB,CAAC,CAAC;MACjF,wBAAwB,IAAI;MAC5B;;EAEJ;;",
+  "names": []
+}

package/dist/audit/nodes/ai/prompts.js

@@ -0,0 +1,103 @@
+class NodePromptTemplates {
+  /**
+   * Build a per-layer batch prompt that asks Claude to evaluate every node type
+   * for alignment to the layer's inspiring standard and documentation quality.
+   */
+  layerEvaluation(context) {
+    const { layerDef, schemas } = context, standard = layerDef.inspiredBy ? `${layerDef.inspiredBy.standard} ${layerDef.inspiredBy.version}` : this.getFallbackStandard(layerDef.id), inputItems = schemas.map((s) => ({
+      specNodeId: s.specNodeId,
+      title: s.title,
+      description: s.description,
+      attributeNames: Object.keys(s.attributes.properties)
+    }));
+    return `You are evaluating node type definitions in a federated architecture specification.
+
+Layer: ${layerDef.name} (layer ${layerDef.number})
+Inspiring Standard: ${standard}
+
+For each node type, score it on two dimensions (0-100 each):
+
+ALIGNMENT SCORE \u2014 How well does this node type conceptually belong in the ${layerDef.name} layer as defined by ${standard}?
+  90-100: Core concept in the standard, perfect fit for this layer
+  70-89:  Clearly related to the standard, well-placed in this layer
+  50-69:  Loosely related, could belong here or in an adjacent layer
+  30-49:  Weak connection to the standard's domain
+  0-29:   Appears misplaced; would fit better in a different layer
+
+DOCUMENTATION SCORE \u2014 Is the description accurate, useful, and sufficient?
+  90-100: Clear, accurate, implementation-agnostic, and complete
+  70-89:  Mostly good with minor gaps
+  50-69:  Generic or vague but not wrong
+  30-49:  Misleading or too brief to be useful
+  0-29:   Empty, missing, or actively wrong
+
+PATTERN DETECTION \u2014 In addition to scoring, identify two structural anti-patterns. When found, apply the scoring impact below and include a specific remediation suggestion.
+
+PATTERN A \u2014 Cross-layer reference annotation:
+  A node whose sole purpose is to carry metadata that belongs to another layer.
+  Indicators:
+    \u2022 Name uses x- prefix (e.g. x-database, x-ui, x-security, x-apm-*)
+    \u2022 Description says things like "links schema to...", "reference to ... in another layer",
+      "UI rendering hints", "security metadata", "database mapping information"
+    \u2022 Attributes describe properties of another layer's concepts, not this layer's
+  Scoring impact: Alignment score must be 0\u201329. This is a conceptual misalignment \u2014 the node
+    embeds cross-layer coupling inside a layer's type catalog instead of using relationships
+    or metadata attachments.
+  Required suggestion: Recommend moving this to a relationship property or cross-reference
+    annotation, and identify which layer it actually belongs to.
+
+PATTERN B \u2014 Enum-masquerading node type:
+  A node that enumerates a closed set of values but is modeled as a first-class node type.
+  Indicators:
+    \u2022 Has only one attribute (commonly named "value" with type string or enum)
+    \u2022 Name or description uses words like "type", "kind", "mode", "status", or implies
+      a finite set of choices (e.g. "Core JSON data types", "String type definition")
+    \u2022 Represents a primitive value constraint rather than a structural concept
+  Scoring impact: Reduce alignment score by 20\u201330 points. These inflate the type catalog
+    and are modeling primitives incorrectly used.
+  Required suggestion: Recommend collapsing into an \`enum\`-constrained string attribute on
+    the parent schema (or a shared \`$defs\` enum referenced via \`$ref\`), and name the
+    specific attribute and schema where it should live.
+
+Input node types:
+\`\`\`json
+${JSON.stringify(inputItems, null, 2)}
+\`\`\`
+
+Return ONLY a JSON array (no prose, no markdown outside the array) with one object per node type:
+[
+  {
+    "specNodeId": "string",
+    "alignmentScore": 0-100,
+    "alignmentReasoning": "brief explanation",
+    "documentationScore": 0-100,
+    "documentationReasoning": "brief explanation",
+    "suggestions": ["actionable suggestion 1", ...]
+  }
+]`;
+  }
+  /**
+   * Fallback standard names for layers without inspiredBy metadata.
+   * Public so NodeAIEvaluator can use the same mapping for LayerAIReview.standard.
+   */
+  getFallbackStandard(layerId) {
+    return {
+      motivation: "ArchiMate 3.2",
+      business: "ArchiMate 3.2",
+      security: "NIST SP 800-53",
+      application: "ArchiMate 3.2",
+      technology: "ArchiMate 3.2",
+      api: "OpenAPI 3.0",
+      "data-model": "JSON Schema Draft 7",
+      "data-store": "Database design patterns",
+      ux: "Component-based UI patterns",
+      navigation: "Application routing patterns",
+      apm: "OpenTelemetry",
+      testing: "Software testing best practices"
+    }[layerId] ?? "Architecture best practices";
+  }
+}
+export {
+  NodePromptTemplates
+};
+//# sourceMappingURL=prompts.js.map

package/dist/audit/nodes/ai/prompts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/ai/prompts.ts"],
+  "sourcesContent": ["import type { LayerDefinition, ParsedNodeSchema } from \"../types.js\";\n\nexport class NodePromptTemplates {\n  /**\n   * Build a per-layer batch prompt that asks Claude to evaluate every node type\n   * for alignment to the layer's inspiring standard and documentation quality.\n   */\n  layerEvaluation(context: {\n    layerDef: LayerDefinition;\n    schemas: ParsedNodeSchema[];\n  }): string {\n    const { layerDef, schemas } = context;\n    const standard = layerDef.inspiredBy\n      ? `${layerDef.inspiredBy.standard} ${layerDef.inspiredBy.version}`\n      : this.getFallbackStandard(layerDef.id);\n\n    const inputItems = schemas.map((s) => ({\n      specNodeId: s.specNodeId,\n      title: s.title,\n      description: s.description,\n      attributeNames: Object.keys(s.attributes.properties),\n    }));\n\n    return `You are evaluating node type definitions in a federated architecture specification.\n\nLayer: ${layerDef.name} (layer ${layerDef.number})\nInspiring Standard: ${standard}\n\nFor each node type, score it on two dimensions (0-100 each):\n\nALIGNMENT SCORE \u2014 How well does this node type conceptually belong in the ${layerDef.name} layer as defined by ${standard}?\n  90-100: Core concept in the standard, perfect fit for this layer\n  70-89:  Clearly related to the standard, well-placed in this layer\n  50-69:  Loosely related, could belong here or in an adjacent layer\n  30-49:  Weak connection to the standard's domain\n  0-29:   Appears misplaced; would fit better in a different layer\n\nDOCUMENTATION SCORE \u2014 Is the description accurate, useful, and sufficient?\n  90-100: Clear, accurate, implementation-agnostic, and complete\n  70-89:  Mostly good with minor gaps\n  50-69:  Generic or vague but not wrong\n  30-49:  Misleading or too brief to be useful\n  0-29:   Empty, missing, or actively wrong\n\nPATTERN DETECTION \u2014 In addition to scoring, identify two structural anti-patterns. When found, apply the scoring impact below and include a specific remediation suggestion.\n\nPATTERN A \u2014 Cross-layer reference annotation:\n  A node whose sole purpose is to carry metadata that belongs to another layer.\n  Indicators:\n    \u2022 Name uses x- prefix (e.g. x-database, x-ui, x-security, x-apm-*)\n    \u2022 Description says things like \"links schema to...\", \"reference to ... in another layer\",\n      \"UI rendering hints\", \"security metadata\", \"database mapping information\"\n    \u2022 Attributes describe properties of another layer's concepts, not this layer's\n  Scoring impact: Alignment score must be 0\u201329. This is a conceptual misalignment \u2014 the node\n    embeds cross-layer coupling inside a layer's type catalog instead of using relationships\n    or metadata attachments.\n  Required suggestion: Recommend moving this to a relationship property or cross-reference\n    annotation, and identify which layer it actually belongs to.\n\nPATTERN B \u2014 Enum-masquerading node type:\n  A node that enumerates a closed set of values but is modeled as a first-class node type.\n  Indicators:\n    \u2022 Has only one attribute (commonly named \"value\" with type string or enum)\n    \u2022 Name or description uses words like \"type\", \"kind\", \"mode\", \"status\", or implies\n      a finite set of choices (e.g. \"Core JSON data types\", \"String type definition\")\n    \u2022 Represents a primitive value constraint rather than a structural concept\n  Scoring impact: Reduce alignment score by 20\u201330 points. These inflate the type catalog\n    and are modeling primitives incorrectly used.\n  Required suggestion: Recommend collapsing into an \\`enum\\`-constrained string attribute on\n    the parent schema (or a shared \\`$defs\\` enum referenced via \\`$ref\\`), and name the\n    specific attribute and schema where it should live.\n\nInput node types:\n\\`\\`\\`json\n${JSON.stringify(inputItems, null, 2)}\n\\`\\`\\`\n\nReturn ONLY a JSON array (no prose, no markdown outside the array) with one object per node type:\n[\n  {\n    \"specNodeId\": \"string\",\n    \"alignmentScore\": 0-100,\n    \"alignmentReasoning\": \"brief explanation\",\n    \"documentationScore\": 0-100,\n    \"documentationReasoning\": \"brief explanation\",\n    \"suggestions\": [\"actionable suggestion 1\", ...]\n  }\n]`;\n  }\n\n  /**\n   * Fallback standard names for layers without inspiredBy metadata.\n   * Public so NodeAIEvaluator can use the same mapping for LayerAIReview.standard.\n   */\n  getFallbackStandard(layerId: string): string {\n    const standards: Record<string, string> = {\n      motivation: \"ArchiMate 3.2\",\n      business: \"ArchiMate 3.2\",\n      security: \"NIST SP 800-53\",\n      application: \"ArchiMate 3.2\",\n      technology: \"ArchiMate 3.2\",\n      api: \"OpenAPI 3.0\",\n      \"data-model\": \"JSON Schema Draft 7\",\n      \"data-store\": \"Database design patterns\",\n      ux: \"Component-based UI patterns\",\n      navigation: \"Application routing patterns\",\n      apm: \"OpenTelemetry\",\n      testing: \"Software testing best practices\",\n    };\n    return standards[layerId] ?? \"Architecture best practices\";\n  }\n}\n"],
+  "mappings": "AAEM,MAAO,oBAAmB;;;;;EAK9B,gBAAgB,SAGf;AACC,UAAM,EAAE,UAAU,QAAO,IAAK,SACxB,WAAW,SAAS,aACtB,GAAG,SAAS,WAAW,QAAQ,IAAI,SAAS,WAAW,OAAO,KAC9D,KAAK,oBAAoB,SAAS,EAAE,GAElC,aAAa,QAAQ,IAAI,CAAC,OAAO;MACrC,YAAY,EAAE;MACd,OAAO,EAAE;MACT,aAAa,EAAE;MACf,gBAAgB,OAAO,KAAK,EAAE,WAAW,UAAU;MACnD;AAEF,WAAO;;SAEF,SAAS,IAAI,WAAW,SAAS,MAAM;sBAC1B,QAAQ;;;;iFAI8C,SAAS,IAAI,wBAAwB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CvH,KAAK,UAAU,YAAY,MAAM,CAAC,CAAC;;;;;;;;;;;;;;EAcnC;;;;;EAMA,oBAAoB,SAAe;AAejC,WAd0C;MACxC,YAAY;MACZ,UAAU;MACV,UAAU;MACV,aAAa;MACb,YAAY;MACZ,KAAK;MACL,cAAc;MACd,cAAc;MACd,IAAI;MACJ,YAAY;MACZ,KAAK;MACL,SAAS;MAEM,OAAO,KAAK;EAC/B;;",
+  "names": []
+}

package/dist/audit/nodes/analysis/node-completeness-checker.js

@@ -0,0 +1,32 @@
+class NodeCompletenessChecker {
+  check(layerDefs, schemas) {
+    const issues = [], schemaIds = new Set(schemas.map((s) => s.specNodeId)), declaredIds = /* @__PURE__ */ new Set();
+    for (const layer of layerDefs)
+      for (const nodeType of layer.nodeTypes)
+        declaredIds.add(nodeType);
+    const layerById = new Map(layerDefs.map((l) => [l.id, l]));
+    for (const layer of layerDefs)
+      for (const nodeType of layer.nodeTypes)
+        schemaIds.has(nodeType) || issues.push({
+          layerId: layer.id,
+          specNodeId: nodeType,
+          issueType: "missing_schema",
+          detail: `"${nodeType}" is listed in ${layer.id} layer.json but has no corresponding .node.schema.json file.`
+        });
+    for (const schema of schemas)
+      if (!declaredIds.has(schema.specNodeId)) {
+        const layer = layerById.get(schema.layerId);
+        issues.push({
+          layerId: schema.layerId,
+          specNodeId: schema.specNodeId,
+          issueType: "orphaned_schema",
+          detail: `"${schema.specNodeId}" has a schema file but is not listed in ${layer ? layer.id : schema.layerId} layer.json.`
+        });
+      }
+    return issues;
+  }
+}
+export {
+  NodeCompletenessChecker
+};
+//# sourceMappingURL=node-completeness-checker.js.map

package/dist/audit/nodes/analysis/node-completeness-checker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/analysis/node-completeness-checker.ts"],
+  "sourcesContent": ["/**\n * Node schema completeness checker.\n * Pure function \u2014 no I/O.\n *\n * Compares layer.json node_types lists against actual schema files loaded from disk.\n */\n\nimport type { LayerDefinition, ParsedNodeSchema, SchemaCompletenessIssue } from \"../types.js\";\n\nexport class NodeCompletenessChecker {\n  check(\n    layerDefs: LayerDefinition[],\n    schemas: ParsedNodeSchema[]\n  ): SchemaCompletenessIssue[] {\n    const issues: SchemaCompletenessIssue[] = [];\n\n    // Build a set of all specNodeIds present as schema files\n    const schemaIds = new Set(schemas.map((s) => s.specNodeId));\n\n    // Build a set of all specNodeIds declared in layer.json files\n    const declaredIds = new Set<string>();\n    for (const layer of layerDefs) {\n      for (const nodeType of layer.nodeTypes) {\n        declaredIds.add(nodeType);\n      }\n    }\n\n    // Build a quick lookup: layerId \u2192 layer definition\n    const layerById = new Map(layerDefs.map((l) => [l.id, l]));\n\n    // missing_schema: declared in layer.json but no schema file found\n    for (const layer of layerDefs) {\n      for (const nodeType of layer.nodeTypes) {\n        if (!schemaIds.has(nodeType)) {\n          issues.push({\n            layerId: layer.id,\n            specNodeId: nodeType,\n            issueType: \"missing_schema\",\n            detail: `\"${nodeType}\" is listed in ${layer.id} layer.json but has no corresponding .node.schema.json file.`,\n          });\n        }\n      }\n    }\n\n    // orphaned_schema: schema file exists but not listed in any layer.json\n    for (const schema of schemas) {\n      if (!declaredIds.has(schema.specNodeId)) {\n        const layer = layerById.get(schema.layerId);\n        issues.push({\n          layerId: schema.layerId,\n          specNodeId: schema.specNodeId,\n          issueType: \"orphaned_schema\",\n          detail: `\"${schema.specNodeId}\" has a schema file but is not listed in ${layer ? layer.id : schema.layerId} layer.json.`,\n        });\n      }\n    }\n\n    return issues;\n  }\n}\n"],
+  "mappings": "AASM,MAAO,wBAAuB;EAClC,MACE,WACA,SAA2B;AAE3B,UAAM,SAAoC,CAAA,GAGpC,YAAY,IAAI,IAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GAGpD,cAAc,oBAAI,IAAG;AAC3B,eAAW,SAAS;AAClB,iBAAW,YAAY,MAAM;AAC3B,oBAAY,IAAI,QAAQ;AAK5B,UAAM,YAAY,IAAI,IAAI,UAAU,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAGzD,eAAW,SAAS;AAClB,iBAAW,YAAY,MAAM;AAC3B,QAAK,UAAU,IAAI,QAAQ,KACzB,OAAO,KAAK;UACV,SAAS,MAAM;UACf,YAAY;UACZ,WAAW;UACX,QAAQ,IAAI,QAAQ,kBAAkB,MAAM,EAAE;SAC/C;AAMP,eAAW,UAAU;AACnB,UAAI,CAAC,YAAY,IAAI,OAAO,UAAU,GAAG;AACvC,cAAM,QAAQ,UAAU,IAAI,OAAO,OAAO;AAC1C,eAAO,KAAK;UACV,SAAS,OAAO;UAChB,YAAY,OAAO;UACnB,WAAW;UACX,QAAQ,IAAI,OAAO,UAAU,4CAA4C,QAAQ,MAAM,KAAK,OAAO,OAAO;SAC3G;MACH;AAGF,WAAO;EACT;;",
+  "names": []
+}

package/dist/audit/nodes/analysis/node-definition-analyzer.js

@@ -0,0 +1,47 @@
+const GENERIC_DESCRIPTION_RE = /\w+ element in \w+ layer/i;
+function classifyDescription(description) {
+  return !description || description.trim() === "" ? "empty" : GENERIC_DESCRIPTION_RE.test(description) ? "generic" : "good";
+}
+function countDocumentedAttributes(properties) {
+  return Object.values(properties).filter((p) => typeof p.description == "string" && p.description.trim() !== "").length;
+}
+class NodeDefinitionAnalyzer {
+  analyze(schema) {
+    const issues = [];
+    let score = 100;
+    const descriptionQuality = classifyDescription(schema.description), hasDescription = descriptionQuality !== "empty";
+    descriptionQuality === "empty" ? (issues.push({
+      severity: "error",
+      code: "EMPTY_DESCRIPTION",
+      message: `Node type "${schema.specNodeId}" has no description.`
+    }), score -= 30) : descriptionQuality === "generic" ? (issues.push({
+      severity: "warning",
+      code: "GENERIC_DESCRIPTION",
+      message: `Node type "${schema.specNodeId}" uses generic template description: "${schema.description}"`
+    }), score -= 15) : schema.description.trim().length < 20 && (issues.push({
+      severity: "info",
+      code: "SHORT_DESCRIPTION",
+      message: `Node type "${schema.specNodeId}" has a very short description (${schema.description.trim().length} chars).`
+    }), score -= 5);
+    const attributeCount = Object.keys(schema.attributes.properties).length, documentedAttributeCount = countDocumentedAttributes(schema.attributes.properties), attributeDocumentationRatio = attributeCount > 0 ? documentedAttributeCount / attributeCount : 1;
+    return attributeCount > 3 && attributeDocumentationRatio < 0.5 && (issues.push({
+      severity: "warning",
+      code: "LOW_ATTRIBUTE_DOCUMENTATION",
+      message: `Node type "${schema.specNodeId}" has low attribute documentation: ${documentedAttributeCount}/${attributeCount} attributes described.`
+    }), score -= 10), {
+      specNodeId: schema.specNodeId,
+      layerId: schema.layerId,
+      hasDescription,
+      descriptionQuality,
+      attributeCount,
+      documentedAttributeCount,
+      attributeDocumentationRatio,
+      issues,
+      score: Math.max(0, score)
+    };
+  }
+}
+export {
+  NodeDefinitionAnalyzer
+};
+//# sourceMappingURL=node-definition-analyzer.js.map