@aiready/cli 0.10.6 → 0.12.0

package/dist/cli.js

@@ -36,357 +36,137 @@ var import_path3 = require("path");
 var import_core3 = require("@aiready/core");
 
 // src/index.ts
-var import_pattern_detect = require("@aiready/pattern-detect");
-var import_context_analyzer = require("@aiready/context-analyzer");
-var import_consistency = require("@aiready/consistency");
 var import_core = require("@aiready/core");
-var severityOrder = {
-  critical: 4,
-  major: 3,
-  minor: 2,
-  info: 1
+var TOOL_PACKAGE_MAP = {
+  [import_core.ToolName.PatternDetect]: "@aiready/pattern-detect",
+  [import_core.ToolName.ContextAnalyzer]: "@aiready/context-analyzer",
+  [import_core.ToolName.NamingConsistency]: "@aiready/consistency",
+  [import_core.ToolName.AiSignalClarity]: "@aiready/ai-signal-clarity",
+  [import_core.ToolName.AgentGrounding]: "@aiready/agent-grounding",
+  [import_core.ToolName.TestabilityIndex]: "@aiready/testability",
+  [import_core.ToolName.DocDrift]: "@aiready/doc-drift",
+  [import_core.ToolName.DependencyHealth]: "@aiready/deps",
+  [import_core.ToolName.ChangeAmplification]: "@aiready/change-amplification",
+  // Aliases handled by registry
+  patterns: "@aiready/pattern-detect",
+  context: "@aiready/context-analyzer",
+  consistency: "@aiready/consistency"
 };
-function sortBySeverity(results) {
-  return results.map((file) => {
-    const sortedIssues = [...file.issues].sort((a, b) => {
-      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
-      if (severityDiff !== 0) return severityDiff;
-      return (a.location?.line || 0) - (b.location?.line || 0);
-    });
-    return { ...file, issues: sortedIssues };
-  }).sort((a, b) => {
-    const aMaxSeverity = Math.max(
-      ...a.issues.map((i) => severityOrder[i.severity] || 0),
-      0
-    );
-    const bMaxSeverity = Math.max(
-      ...b.issues.map((i) => severityOrder[i.severity] || 0),
-      0
-    );
-    if (aMaxSeverity !== bMaxSeverity) {
-      return bMaxSeverity - aMaxSeverity;
-    }
-    if (a.issues.length !== b.issues.length) {
-      return b.issues.length - a.issues.length;
-    }
-    return a.fileName.localeCompare(b.fileName);
-  });
-}
 async function analyzeUnified(options) {
   const startTime = Date.now();
-  const tools = options.tools || ["patterns", "context", "consistency"];
+  const requestedTools = options.tools || [
+    "patterns",
+    "context",
+    "consistency"
+  ];
   const result = {
     summary: {
       totalIssues: 0,
-      toolsRun: tools,
+      toolsRun: [],
       executionTime: 0
     }
   };
-  if (tools.includes("patterns")) {
-    const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "patterns", data: patternResult });
-    }
-    const output = {
-      results: sortBySeverity(patternResult.results),
-      summary: patternResult.summary || {},
-      duplicates: patternResult.duplicates || []
-    };
-    result[import_core.ToolName.PatternDetect] = output;
-    result.patternDetect = output;
-    result.summary.totalIssues += patternResult.results.reduce(
-      (sum, file) => sum + file.issues.length,
-      0
-    );
-  }
-  if (tools.includes("context")) {
-    const contextResults = await (0, import_context_analyzer.analyzeContext)(options);
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "context", data: contextResults });
-    }
-    const sorted = contextResults.sort((a, b) => {
-      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
-      if (severityDiff !== 0) return severityDiff;
-      if (a.tokenCost !== b.tokenCost) return b.tokenCost - a.tokenCost;
-      return b.fragmentationScore - a.fragmentationScore;
-    });
-    const { generateSummary: genContextSummary } = await import("@aiready/context-analyzer");
-    const output = {
-      results: sorted,
-      summary: genContextSummary(sorted)
-    };
-    result[import_core.ToolName.ContextAnalyzer] = output;
-    result.contextAnalyzer = output;
-    result.summary.totalIssues += sorted.length;
-  }
-  if (tools.includes("consistency")) {
-    const consistencyOptions = {
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      ...options.consistency || {}
-    };
-    const report = await (0, import_consistency.analyzeConsistency)(consistencyOptions);
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "consistency", data: report });
-    }
-    result[import_core.ToolName.NamingConsistency] = {
-      results: report.results ? sortBySeverity(report.results) : [],
-      summary: report.summary
-    };
-    result.summary.totalIssues += report.summary.totalIssues;
-  }
-  if (tools.includes("doc-drift")) {
-    const { analyzeDocDrift } = await import("@aiready/doc-drift");
-    const report = await analyzeDocDrift({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "doc-drift", data: report });
-    }
-    result[import_core.ToolName.DocDrift] = {
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    const issueCount = report.issues?.length || (report.results ? report.results.length : 0);
-    result.summary.totalIssues += issueCount;
-  }
-  if (tools.includes("deps-health")) {
-    const { analyzeDeps } = await import("@aiready/deps");
-    const report = await analyzeDeps({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "deps-health", data: report });
-    }
-    result[import_core.ToolName.DependencyHealth] = {
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    const issueCount = report.issues?.length || (report.results ? report.results.length : 0);
-    result.summary.totalIssues += issueCount;
-  }
-  if (tools.includes("ai-signal-clarity")) {
-    const { analyzeAiSignalClarity } = await import("@aiready/ai-signal-clarity");
-    const report = await analyzeAiSignalClarity({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "ai-signal-clarity", data: report });
-    }
-    result[import_core.ToolName.AiSignalClarity] = {
-      ...report,
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += (report.results || report.issues)?.reduce(
-      (sum, r) => sum + (r.issues?.length || 1),
-      0
-    ) || 0;
-  }
-  if (tools.includes("agent-grounding")) {
-    const { analyzeAgentGrounding } = await import("@aiready/agent-grounding");
-    const report = await analyzeAgentGrounding({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "agent-grounding", data: report });
-    }
-    result[import_core.ToolName.AgentGrounding] = {
-      ...report,
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += (report.issues || report.results || []).length;
-  }
-  if (tools.includes("testability")) {
-    const { analyzeTestability } = await import("@aiready/testability");
-    const report = await analyzeTestability({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "testability", data: report });
+  for (const toolName of requestedTools) {
+    let provider = import_core.ToolRegistry.find(toolName);
+    if (!provider) {
+      const packageName = TOOL_PACKAGE_MAP[toolName] || (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+      try {
+        await import(packageName);
+        provider = import_core.ToolRegistry.find(toolName);
+        if (provider) {
+          console.log(
+            `\u2705 Successfully loaded tool provider: ${toolName} from ${packageName}`
+          );
+        } else {
+          console.log(
+            `\u26A0\uFE0F Loaded ${packageName} but provider ${toolName} still not found in registry.`
+          );
+        }
+      } catch (err) {
+        console.log(
+          `\u274C Failed to dynamically load tool ${toolName} (${packageName}):`,
+          err.message
+        );
+      }
     }
-    result[import_core.ToolName.TestabilityIndex] = {
-      ...report,
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += (report.issues || report.results || []).length;
-  }
-  if (tools.includes("change-amplification")) {
-    const { analyzeChangeAmplification } = await import("@aiready/change-amplification");
-    const report = await analyzeChangeAmplification({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "change-amplification", data: report });
+    if (!provider) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
+      );
+      continue;
     }
-    result[import_core.ToolName.ChangeAmplification] = {
-      results: report.results || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += report.summary?.totalIssues || 0;
-  }
-  result.summary.executionTime = Date.now() - startTime;
-  return result;
-}
-async function scoreUnified(results, options) {
-  const toolScores = /* @__PURE__ */ new Map();
-  if (results[import_core.ToolName.PatternDetect]) {
-    const data = results[import_core.ToolName.PatternDetect];
-    const { calculatePatternScore } = await import("@aiready/pattern-detect");
     try {
-      const patternScore = calculatePatternScore(
-        data.duplicates,
-        data.results?.length || 0
-      );
-      const wastedTokens = data.duplicates.reduce(
-        (sum, d) => sum + (d.tokenCost || 0),
+      const output = await provider.analyze(options);
+      if (options.progressCallback) {
+        options.progressCallback({ tool: provider.id, data: output });
+      }
+      result[provider.id] = output;
+      result.summary.toolsRun.push(provider.id);
+      const issueCount = output.results.reduce(
+        (sum, file) => sum + (file.issues?.length || 0),
         0
       );
-      patternScore.tokenBudget = (0, import_core.calculateTokenBudget)({
-        totalContextTokens: wastedTokens * 2,
-        // Estimated context
-        wastedTokens: {
-          duplication: wastedTokens,
-          fragmentation: 0,
-          chattiness: 0
-        }
-      });
-      toolScores.set(import_core.ToolName.PatternDetect, patternScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.ContextAnalyzer]) {
-    const data = results[import_core.ToolName.ContextAnalyzer];
-    const { calculateContextScore } = await import("@aiready/context-analyzer");
-    try {
-      const ctxSummary = data.summary;
-      const contextScore = calculateContextScore(ctxSummary);
-      contextScore.tokenBudget = (0, import_core.calculateTokenBudget)({
-        totalContextTokens: ctxSummary.totalTokens,
-        wastedTokens: {
-          duplication: 0,
-          fragmentation: ctxSummary.totalPotentialSavings || 0,
-          chattiness: 0
+      result.summary.totalIssues += issueCount;
+      if (provider.alias && Array.isArray(provider.alias)) {
+        for (const alias of provider.alias) {
+          if (!result[alias]) {
+            result[alias] = output;
+          }
         }
-      });
-      toolScores.set(import_core.ToolName.ContextAnalyzer, contextScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.NamingConsistency]) {
-    const data = results[import_core.ToolName.NamingConsistency];
-    const { calculateConsistencyScore } = await import("@aiready/consistency");
-    try {
-      const issues = data.results?.flatMap((r) => r.issues) || [];
-      const totalFiles = data.summary?.filesAnalyzed || 0;
-      const consistencyScore = calculateConsistencyScore(issues, totalFiles);
-      toolScores.set(import_core.ToolName.NamingConsistency, consistencyScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.AiSignalClarity]) {
-    const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
-    try {
-      const hrScore = calculateAiSignalClarityScore(
-        results[import_core.ToolName.AiSignalClarity]
+      }
+      const camelCaseId = provider.id.replace(
+        /-([a-z])/g,
+        (g) => g[1].toUpperCase()
       );
-      toolScores.set(import_core.ToolName.AiSignalClarity, hrScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.AgentGrounding]) {
-    const { calculateGroundingScore } = await import("@aiready/agent-grounding");
-    try {
-      const agScore = calculateGroundingScore(results[import_core.ToolName.AgentGrounding]);
-      toolScores.set(import_core.ToolName.AgentGrounding, agScore);
+      if (camelCaseId !== provider.id && !result[camelCaseId]) {
+        result[camelCaseId] = output;
+      }
     } catch (err) {
-      void err;
+      console.error(`\u274C Error running tool '${provider.id}':`, err);
     }
   }
-  if (results[import_core.ToolName.TestabilityIndex]) {
-    const { calculateTestabilityScore } = await import("@aiready/testability");
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+async function scoreUnified(results, options) {
+  const toolScores = /* @__PURE__ */ new Map();
+  for (const toolId of results.summary.toolsRun) {
+    const provider = import_core.ToolRegistry.get(toolId);
+    if (!provider) continue;
+    const output = results[toolId];
+    if (!output) continue;
     try {
-      const tbScore = calculateTestabilityScore(
-        results[import_core.ToolName.TestabilityIndex]
-      );
-      toolScores.set(import_core.ToolName.TestabilityIndex, tbScore);
+      const toolScore = provider.score(output, options);
+      if (!toolScore.tokenBudget) {
+        if (toolId === import_core.ToolName.PatternDetect && output.duplicates) {
+          const wastedTokens = output.duplicates.reduce(
+            (sum, d) => sum + (d.tokenCost || 0),
+            0
+          );
+          toolScore.tokenBudget = (0, import_core.calculateTokenBudget)({
+            totalContextTokens: wastedTokens * 2,
+            wastedTokens: {
+              duplication: wastedTokens,
+              fragmentation: 0,
+              chattiness: 0
+            }
+          });
+        } else if (toolId === import_core.ToolName.ContextAnalyzer && output.summary) {
+          toolScore.tokenBudget = (0, import_core.calculateTokenBudget)({
+            totalContextTokens: output.summary.totalTokens,
+            wastedTokens: {
+              duplication: 0,
+              fragmentation: output.summary.totalPotentialSavings || 0,
+              chattiness: 0
+            }
+          });
+        }
+      }
+      toolScores.set(toolId, toolScore);
     } catch (err) {
-      void err;
+      console.error(`\u274C Error scoring tool '${toolId}':`, err);
     }
   }
-  if (results[import_core.ToolName.DocDrift]) {
-    const data = results[import_core.ToolName.DocDrift];
-    toolScores.set(import_core.ToolName.DocDrift, {
-      toolName: import_core.ToolName.DocDrift,
-      score: data.summary.score || data.summary.totalScore || 0,
-      rawMetrics: data.summary,
-      factors: [],
-      recommendations: (data.summary.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
-    });
-  }
-  if (results[import_core.ToolName.DependencyHealth]) {
-    const data = results[import_core.ToolName.DependencyHealth];
-    toolScores.set(import_core.ToolName.DependencyHealth, {
-      toolName: import_core.ToolName.DependencyHealth,
-      score: data.summary.score || 0,
-      rawMetrics: data.summary,
-      factors: [],
-      recommendations: (data.summary.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
-    });
-  }
-  if (results[import_core.ToolName.ChangeAmplification]) {
-    const data = results[import_core.ToolName.ChangeAmplification];
-    toolScores.set(import_core.ToolName.ChangeAmplification, {
-      toolName: import_core.ToolName.ChangeAmplification,
-      score: data.summary.score || 0,
-      rawMetrics: data.summary,
-      factors: [],
-      recommendations: (data.summary.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
-    });
-  }
   if (toolScores.size === 0) {
     return {
       overall: 0,
@@ -521,12 +301,6 @@ function generateMarkdownReport(report, elapsedTime) {
   }
   return markdown;
 }
-function truncateArray(arr, cap = 8) {
-  if (!Array.isArray(arr)) return "";
-  const shown = arr.slice(0, cap).map((v) => String(v));
-  const more = arr.length - shown.length;
-  return shown.join(", ") + (more > 0 ? `, ... (+${more} more)` : "");
-}
 
 // src/commands/upload.ts
 var import_fs2 = __toESM(require("fs"));
@@ -640,14 +414,14 @@ async function scanAction(directory, options) {
   try {
     const defaults = {
       tools: [
-        "patterns",
-        "context",
-        "consistency",
+        "pattern-detect",
+        "context-analyzer",
+        "naming-consistency",
         "ai-signal-clarity",
         "agent-grounding",
-        "testability",
+        "testability-index",
         "doc-drift",
-        "deps-health",
+        "dependency-health",
         "change-amplification"
       ],
       include: void 0,
@@ -657,35 +431,37 @@ async function scanAction(directory, options) {
         file: void 0
       }
     };
-    let profileTools = options.tools ? options.tools.split(",").map((t) => {
-      const tool = t.trim();
-      if (tool === "hallucination" || tool === "hallucination-risk")
-        return "aiSignalClarity";
-      return tool;
-    }) : void 0;
+    let profileTools = options.tools ? options.tools.split(",").map((t) => t.trim()) : void 0;
     if (options.profile) {
       switch (options.profile.toLowerCase()) {
         case "agentic":
           profileTools = [
-            "ai-signal-clarity",
-            "agent-grounding",
-            "testability"
+            import_core3.ToolName.AiSignalClarity,
+            import_core3.ToolName.AgentGrounding,
+            import_core3.ToolName.TestabilityIndex
           ];
           break;
         case "cost":
-          profileTools = ["patterns", "context"];
+          profileTools = [import_core3.ToolName.PatternDetect, import_core3.ToolName.ContextAnalyzer];
           break;
         case "security":
-          profileTools = ["consistency", "testability"];
+          profileTools = [
+            import_core3.ToolName.NamingConsistency,
+            import_core3.ToolName.TestabilityIndex
+          ];
           break;
         case "onboarding":
-          profileTools = ["context", "consistency", "agent-grounding"];
+          profileTools = [
+            import_core3.ToolName.ContextAnalyzer,
+            import_core3.ToolName.NamingConsistency,
+            import_core3.ToolName.AgentGrounding
+          ];
           break;
         default:
           console.log(
             import_chalk3.default.yellow(
               `
-\u26A0\uFE0F  Unknown profile '${options.profile}'. Using specified tools or defaults.`
+\u26A0\uFE0F  Unknown profile '${options.profile}'. Using defaults.`
             )
           );
       }
@@ -694,16 +470,14 @@ async function scanAction(directory, options) {
       include: options.include?.split(","),
       exclude: options.exclude?.split(",")
     };
-    if (profileTools) {
-      cliOverrides.tools = profileTools;
-    }
+    if (profileTools) cliOverrides.tools = profileTools;
     const baseOptions = await (0, import_core3.loadMergedConfig)(
       resolvedDir,
       defaults,
       cliOverrides
     );
     let finalOptions = { ...baseOptions };
-    if (baseOptions.tools.includes("patterns")) {
+    if (baseOptions.tools.includes(import_core3.ToolName.PatternDetect) || baseOptions.tools.includes("patterns")) {
       const { getSmartDefaults } = await import("@aiready/pattern-detect");
       const patternSmartDefaults = await getSmartDefaults(
         resolvedDir,
@@ -718,256 +492,21 @@ async function scanAction(directory, options) {
     console.log(import_chalk3.default.cyan("\n=== AIReady Run Preview ==="));
     console.log(
       import_chalk3.default.white("Tools to run:"),
-      (finalOptions.tools || ["patterns", "context", "consistency"]).join(", ")
+      (finalOptions.tools || []).join(", ")
     );
-    console.log(import_chalk3.default.white("Will use settings from config and defaults."));
-    console.log(import_chalk3.default.white("\nGeneral settings:"));
-    if (finalOptions.rootDir)
-      console.log(`  rootDir: ${import_chalk3.default.bold(String(finalOptions.rootDir))}`);
-    if (finalOptions.include)
-      console.log(
-        `  include: ${import_chalk3.default.bold(truncateArray(finalOptions.include, 6))}`
-      );
-    if (finalOptions.exclude)
-      console.log(
-        `  exclude: ${import_chalk3.default.bold(truncateArray(finalOptions.exclude, 6))}`
-      );
-    if (finalOptions["pattern-detect"] || finalOptions.minSimilarity) {
-      const patternDetectConfig = finalOptions["pattern-detect"] || {
-        minSimilarity: finalOptions.minSimilarity,
-        minLines: finalOptions.minLines,
-        approx: finalOptions.approx,
-        minSharedTokens: finalOptions.minSharedTokens,
-        maxCandidatesPerBlock: finalOptions.maxCandidatesPerBlock,
-        batchSize: finalOptions.batchSize,
-        streamResults: finalOptions.streamResults,
-        severity: finalOptions.severity,
-        includeTests: finalOptions.includeTests
-      };
-      console.log(import_chalk3.default.white("\nPattern-detect settings:"));
-      console.log(
-        `  minSimilarity: ${import_chalk3.default.bold(patternDetectConfig.minSimilarity ?? "default")}`
-      );
-      console.log(
-        `  minLines: ${import_chalk3.default.bold(patternDetectConfig.minLines ?? "default")}`
-      );
-      if (patternDetectConfig.approx !== void 0)
-        console.log(
-          `  approx: ${import_chalk3.default.bold(String(patternDetectConfig.approx))}`
-        );
-      if (patternDetectConfig.minSharedTokens !== void 0)
-        console.log(
-          `  minSharedTokens: ${import_chalk3.default.bold(String(patternDetectConfig.minSharedTokens))}`
-        );
-      if (patternDetectConfig.maxCandidatesPerBlock !== void 0)
-        console.log(
-          `  maxCandidatesPerBlock: ${import_chalk3.default.bold(String(patternDetectConfig.maxCandidatesPerBlock))}`
-        );
-      if (patternDetectConfig.batchSize !== void 0)
-        console.log(
-          `  batchSize: ${import_chalk3.default.bold(String(patternDetectConfig.batchSize))}`
-        );
-      if (patternDetectConfig.streamResults !== void 0)
-        console.log(
-          `  streamResults: ${import_chalk3.default.bold(String(patternDetectConfig.streamResults))}`
-        );
-      if (patternDetectConfig.severity !== void 0)
-        console.log(
-          `  severity: ${import_chalk3.default.bold(String(patternDetectConfig.severity))}`
-        );
-      if (patternDetectConfig.includeTests !== void 0)
-        console.log(
-          `  includeTests: ${import_chalk3.default.bold(String(patternDetectConfig.includeTests))}`
-        );
-    }
-    if (finalOptions["context-analyzer"] || finalOptions.maxDepth) {
-      const ca = finalOptions["context-analyzer"] || {
-        maxDepth: finalOptions.maxDepth,
-        maxContextBudget: finalOptions.maxContextBudget,
-        minCohesion: finalOptions.minCohesion,
-        maxFragmentation: finalOptions.maxFragmentation,
-        includeNodeModules: finalOptions.includeNodeModules
-      };
-      console.log(import_chalk3.default.white("\nContext-analyzer settings:"));
-      console.log(`  maxDepth: ${import_chalk3.default.bold(ca.maxDepth ?? "default")}`);
-      console.log(
-        `  maxContextBudget: ${import_chalk3.default.bold(ca.maxContextBudget ?? "default")}`
-      );
-      if (ca.minCohesion !== void 0)
-        console.log(`  minCohesion: ${import_chalk3.default.bold(String(ca.minCohesion))}`);
-      if (ca.maxFragmentation !== void 0)
-        console.log(
-          `  maxFragmentation: ${import_chalk3.default.bold(String(ca.maxFragmentation))}`
-        );
-      if (ca.includeNodeModules !== void 0)
-        console.log(
-          `  includeNodeModules: ${import_chalk3.default.bold(String(ca.includeNodeModules))}`
-        );
-    }
-    if (finalOptions.consistency) {
-      const c = finalOptions.consistency;
-      console.log(import_chalk3.default.white("\nConsistency settings:"));
-      console.log(
-        `  checkNaming: ${import_chalk3.default.bold(String(c.checkNaming ?? true))}`
-      );
-      console.log(
-        `  checkPatterns: ${import_chalk3.default.bold(String(c.checkPatterns ?? true))}`
-      );
-      console.log(
-        `  checkArchitecture: ${import_chalk3.default.bold(String(c.checkArchitecture ?? false))}`
-      );
-      if (c.minSeverity)
-        console.log(`  minSeverity: ${import_chalk3.default.bold(c.minSeverity)}`);
-      if (c.acceptedAbbreviations)
-        console.log(
-          `  acceptedAbbreviations: ${import_chalk3.default.bold(truncateArray(c.acceptedAbbreviations, 8))}`
-        );
-      if (c.shortWords)
-        console.log(
-          `  shortWords: ${import_chalk3.default.bold(truncateArray(c.shortWords, 8))}`
-        );
-    }
-    console.log(import_chalk3.default.white("\nStarting analysis..."));
     const progressCallback = (event) => {
       console.log(import_chalk3.default.cyan(`
 --- ${event.tool.toUpperCase()} RESULTS ---`));
-      try {
-        if (event.tool === "patterns") {
-          const pr = event.data;
+      const res = event.data;
+      if (res.summary) {
+        if (res.summary.totalIssues !== void 0)
+          console.log(`  Issues found: ${import_chalk3.default.bold(res.summary.totalIssues)}`);
+        if (res.summary.score !== void 0)
+          console.log(`  Tool Score: ${import_chalk3.default.bold(res.summary.score)}/100`);
+        if (res.summary.totalFiles !== void 0)
           console.log(
-            `  Duplicate patterns: ${import_chalk3.default.bold(String(pr.duplicates?.length || 0))}`
+            `  Files analyzed: ${import_chalk3.default.bold(res.summary.totalFiles)}`
           );
-          console.log(
-            `  Files with pattern issues: ${import_chalk3.default.bold(String(pr.results?.length || 0))}`
-          );
-          if (pr.duplicates && pr.duplicates.length > 0) {
-            pr.duplicates.slice(0, 5).forEach((d, i) => {
-              console.log(
-                `   ${i + 1}. ${d.file1.split("/").pop()} \u2194 ${d.file2.split("/").pop()} (sim=${(d.similarity * 100).toFixed(1)}%)`
-              );
-            });
-          }
-          if (pr.results && pr.results.length > 0) {
-            console.log(`  Top files with pattern issues:`);
-            const sortedByIssues = [...pr.results].sort(
-              (a, b) => (b.issues?.length || 0) - (a.issues?.length || 0)
-            );
-            sortedByIssues.slice(0, 5).forEach((r, i) => {
-              console.log(
-                `   ${i + 1}. ${r.fileName.split("/").pop()} - ${r.issues.length} issue(s)`
-              );
-            });
-          }
-          if (pr.groups && pr.groups.length >= 0) {
-            console.log(
-              `  \u2705 Grouped ${import_chalk3.default.bold(String(pr.duplicates?.length || 0))} duplicates into ${import_chalk3.default.bold(String(pr.groups.length))} file pairs`
-            );
-          }
-          if (pr.clusters && pr.clusters.length >= 0) {
-            console.log(
-              `  \u2705 Created ${import_chalk3.default.bold(String(pr.clusters.length))} refactor clusters`
-            );
-            pr.clusters.slice(0, 3).forEach((cl, idx) => {
-              const files = (cl.files || []).map((f) => f.path.split("/").pop()).join(", ");
-              console.log(
-                `   ${idx + 1}. ${files} (${cl.tokenCost || "n/a"} tokens)`
-              );
-            });
-          }
-        } else if (event.tool === "context") {
-          const cr = event.data;
-          console.log(
-            `  Context issues found: ${import_chalk3.default.bold(String(cr.length || 0))}`
-          );
-          cr.slice(0, 5).forEach((c, i) => {
-            const msg = c.message ? ` - ${c.message}` : "";
-            console.log(
-              `   ${i + 1}. ${c.file} (${c.severity || "n/a"})${msg}`
-            );
-          });
-        } else if (event.tool === "consistency") {
-          const rep = event.data;
-          console.log(
-            `  Consistency totalIssues: ${import_chalk3.default.bold(String(rep.summary?.totalIssues || 0))}`
-          );
-          if (rep.results && rep.results.length > 0) {
-            const fileMap = /* @__PURE__ */ new Map();
-            rep.results.forEach((r) => {
-              (r.issues || []).forEach((issue) => {
-                const file = issue.location?.file || r.file || "unknown";
-                if (!fileMap.has(file)) fileMap.set(file, []);
-                fileMap.get(file).push(issue);
-              });
-            });
-            const files = Array.from(fileMap.entries()).sort(
-              (a, b) => b[1].length - a[1].length
-            );
-            const topFiles = files.slice(0, 10);
-            topFiles.forEach(([file, issues], idx) => {
-              const counts = issues.reduce(
-                (acc, it) => {
-                  const s = (it.severity || import_core3.Severity.Info).toLowerCase();
-                  acc[s] = (acc[s] || 0) + 1;
-                  return acc;
-                },
-                {}
-              );
-              const sample = issues.find(
-                (it) => it.severity === import_core3.Severity.Critical || it.severity === import_core3.Severity.Major
-              ) || issues[0];
-              const sampleMsg = sample ? ` \u2014 ${sample.message}` : "";
-              console.log(
-                `   ${idx + 1}. ${file} \u2014 ${issues.length} issue(s) (critical:${counts[import_core3.Severity.Critical] || 0} major:${counts[import_core3.Severity.Major] || 0} minor:${counts[import_core3.Severity.Minor] || 0} info:${counts[import_core3.Severity.Info] || 0})${sampleMsg}`
-              );
-            });
-            const remaining = files.length - topFiles.length;
-            if (remaining > 0) {
-              console.log(
-                import_chalk3.default.dim(
-                  `   ... and ${remaining} more files with issues (use --output json for full details)`
-                )
-              );
-            }
-          }
-        } else if (event.tool === "doc-drift") {
-          const dr = event.data;
-          console.log(
-            `  Issues found: ${import_chalk3.default.bold(String(dr.issues?.length || 0))}`
-          );
-          if (dr.rawData) {
-            console.log(
-              `  Signature Mismatches: ${import_chalk3.default.bold(dr.rawData.outdatedComments || 0)}`
-            );
-            console.log(
-              `  Undocumented Complexity: ${import_chalk3.default.bold(dr.rawData.undocumentedComplexity || 0)}`
-            );
-          }
-        } else if (event.tool === "deps-health") {
-          const dr = event.data;
-          console.log(
-            `  Packages Analyzed: ${import_chalk3.default.bold(String(dr.summary?.packagesAnalyzed || 0))}`
-          );
-          if (dr.rawData) {
-            console.log(
-              `  Deprecated Packages: ${import_chalk3.default.bold(dr.rawData.deprecatedPackages || 0)}`
-            );
-            console.log(
-              `  AI Cutoff Skew Score: ${import_chalk3.default.bold(dr.rawData.trainingCutoffSkew?.toFixed(1) || 0)}`
-            );
-          }
-        } else if (event.tool === "change-amplification" || event.tool === "changeAmplification") {
-          const dr = event.data;
-          console.log(
-            `  Coupling issues: ${import_chalk3.default.bold(String(dr.issues?.length || 0))}`
-          );
-          if (dr.summary) {
-            console.log(
-              `  Complexity Score: ${import_chalk3.default.bold(dr.summary.score || 0)}/100`
-            );
-          }
-        }
-      } catch (err) {
-        void err;
       }
     };
     const results = await analyzeUnified({
@@ -977,44 +516,14 @@ async function scanAction(directory, options) {
         process.stdout.write(
           `\r\x1B[K   [${processed}/${total}] ${message}...`
         );
-        if (processed === total) {
-          process.stdout.write("\n");
-        }
+        if (processed === total) process.stdout.write("\n");
       },
       suppressToolConfig: true
     });
     console.log(import_chalk3.default.cyan("\n=== AIReady Run Summary ==="));
-    console.log(
-      import_chalk3.default.white("Tools run:"),
-      (finalOptions.tools || ["patterns", "context", "consistency"]).join(", ")
-    );
-    console.log(import_chalk3.default.cyan("\nResults summary:"));
     console.log(
       `  Total issues (all tools): ${import_chalk3.default.bold(String(results.summary.totalIssues || 0))}`
     );
-    if (results[import_core3.ToolName.PatternDetect]) {
-      console.log(
-        `  Duplicate patterns found: ${import_chalk3.default.bold(String(results[import_core3.ToolName.PatternDetect].duplicates?.length || 0))}`
-      );
-      console.log(
-        `  Pattern files with issues: ${import_chalk3.default.bold(String(results[import_core3.ToolName.PatternDetect].results.length || 0))}`
-      );
-    }
-    if (results[import_core3.ToolName.ContextAnalyzer])
-      console.log(
-        `  Context issues: ${import_chalk3.default.bold(String(results[import_core3.ToolName.ContextAnalyzer].results.length || 0))}`
-      );
-    if (results[import_core3.ToolName.NamingConsistency])
-      console.log(
-        `  Consistency issues: ${import_chalk3.default.bold(String(results[import_core3.ToolName.NamingConsistency].summary?.totalIssues || 0))}`
-      );
-    if (results[import_core3.ToolName.ChangeAmplification])
-      console.log(
-        `  Change amplification: ${import_chalk3.default.bold(String(results[import_core3.ToolName.ChangeAmplification].summary?.score || 0))}/100`
-      );
-    console.log(import_chalk3.default.cyan("===========================\n"));
-    const elapsedTime = (0, import_core3.getElapsedTime)(startTime);
-    void elapsedTime;
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
       scoringResult = await scoreUnified(results, finalOptions);
@@ -1022,55 +531,34 @@ async function scanAction(directory, options) {
       console.log(`  ${(0, import_core3.formatScore)(scoringResult)}`);
       if (options.compareTo) {
         try {
-          const prevReportStr = (0, import_fs3.readFileSync)(
-            (0, import_path3.resolve)(process.cwd(), options.compareTo),
-            "utf8"
+          const prevReport = JSON.parse(
+            (0, import_fs3.readFileSync)((0, import_path3.resolve)(process.cwd(), options.compareTo), "utf8")
           );
-          const prevReport = JSON.parse(prevReportStr);
-          const prevScore = prevReport.scoring?.score || prevReport.scoring?.overallScore;
+          const prevScore = prevReport.scoring?.overall || prevReport.scoring?.score;
           if (typeof prevScore === "number") {
             const diff = scoringResult.overall - prevScore;
             const diffStr = diff > 0 ? `+${diff}` : String(diff);
-            console.log();
-            if (diff > 0) {
+            if (diff > 0)
               console.log(
                 import_chalk3.default.green(
                   `  \u{1F4C8} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
-            } else if (diff < 0) {
+            else if (diff < 0)
               console.log(
                 import_chalk3.default.red(
                   `  \u{1F4C9} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
-            } else {
+            else
               console.log(
                 import_chalk3.default.blue(
-                  `  \u2796 Trend: No change compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
+                  `  \u2796 Trend: No change (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
-            }
-            scoringResult.trend = {
-              previousScore: prevScore,
-              difference: diff
-            };
-          } else {
-            console.log(
-              import_chalk3.default.yellow(
-                `
-  \u26A0\uFE0F  Previous report at ${options.compareTo} does not contain an overall score.`
-              )
-            );
           }
         } catch (e) {
           void e;
-          console.log(
-            import_chalk3.default.yellow(
-              `
-  \u26A0\uFE0F  Could not read or parse previous report at ${options.compareTo}.`
-            )
-          );
         }
       }
       const totalWastedDuplication = (scoringResult.breakdown || []).reduce(
@@ -1084,7 +572,8 @@ async function scanAction(directory, options) {
       const totalContext = Math.max(
         ...(scoringResult.breakdown || []).map(
           (s) => s.tokenBudget?.totalContextTokens || 0
-        )
+        ),
+        0
       );
       if (totalContext > 0) {
         const unifiedBudget = (0, import_core3.calculateTokenBudget)({
@@ -1095,35 +584,17 @@ async function scanAction(directory, options) {
             chattiness: 0
           }
         });
-        const targetModel = options.model || "claude-4.6";
-        const modelPreset = (0, import_core3.getModelPreset)(targetModel);
+        const modelPreset = (0, import_core3.getModelPreset)(options.model || "claude-4.6");
         const costEstimate = (0, import_core3.estimateCostFromBudget)(unifiedBudget, modelPreset);
-        const barWidth = 20;
-        const filled = Math.round(unifiedBudget.efficiencyRatio * barWidth);
-        const bar = import_chalk3.default.green("\u2588".repeat(filled)) + import_chalk3.default.dim("\u2591".repeat(barWidth - filled));
-        console.log(import_chalk3.default.bold("\n\u{1F4CA} AI Token Budget Analysis (v0.13)"));
-        console.log(
-          `  Efficiency: [${bar}] ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
-        );
-        console.log(
-          `  Total Context: ${import_chalk3.default.bold(unifiedBudget.totalContextTokens.toLocaleString())} tokens`
-        );
-        console.log(
-          `  Wasted Tokens: ${import_chalk3.default.red(unifiedBudget.wastedTokens.total.toLocaleString())} (${(unifiedBudget.wastedTokens.total / unifiedBudget.totalContextTokens * 100).toFixed(1)}%)`
-        );
-        console.log(`  Waste Breakdown:`);
-        console.log(
-          `    \u2022 Duplication:   ${unifiedBudget.wastedTokens.bySource.duplication.toLocaleString()} tokens`
-        );
+        console.log(import_chalk3.default.bold("\n\u{1F4CA} AI Token Budget Analysis"));
         console.log(
-          `    \u2022 Fragmentation: ${unifiedBudget.wastedTokens.bySource.fragmentation.toLocaleString()} tokens`
+          `  Efficiency: ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
         );
         console.log(
-          `  Potential Savings: ${import_chalk3.default.green(unifiedBudget.potentialRetrievableTokens.toLocaleString())} tokens retrievable`
+          `  Wasted Tokens: ${import_chalk3.default.red(unifiedBudget.wastedTokens.total.toLocaleString())}`
         );
         console.log(
-          `
-  Est. Monthly Cost (${modelPreset.name}): ${import_chalk3.default.bold("$" + costEstimate.total)} [range: $${costEstimate.range[0]}-$${costEstimate.range[1]}]`
+          `  Est. Monthly Cost (${modelPreset.name}): ${import_chalk3.default.bold("$" + costEstimate.total)}`
         );
         scoringResult.tokenBudget = unifiedBudget;
         scoringResult.costEstimate = {
@@ -1131,85 +602,31 @@ async function scanAction(directory, options) {
           ...costEstimate
         };
       }
-      if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+      if (scoringResult.breakdown) {
         console.log(import_chalk3.default.bold("\nTool breakdown:"));
         scoringResult.breakdown.forEach((tool) => {
           const rating = (0, import_core3.getRating)(tool.score);
-          const rd = (0, import_core3.getRatingDisplay)(rating);
-          console.log(
-            `  - ${tool.toolName}: ${tool.score}/100 (${rating}) ${rd.emoji}`
-          );
+          console.log(`  - ${tool.toolName}: ${tool.score}/100 (${rating})`);
         });
-        console.log();
-        if (finalOptions.scoring?.showBreakdown) {
-          console.log(import_chalk3.default.bold("Detailed tool breakdown:"));
-          scoringResult.breakdown.forEach((tool) => {
-            console.log((0, import_core3.formatToolScore)(tool));
-          });
-          console.log();
-        }
       }
     }
     const mapToUnifiedReport = (res, scoring) => {
       const allResults = [];
-      let totalFilesSet = /* @__PURE__ */ new Set();
+      const totalFilesSet = /* @__PURE__ */ new Set();
       let criticalCount = 0;
       let majorCount = 0;
-      const collect = (spokeRes, defaultType = import_core3.IssueType.AiSignalClarity) => {
+      res.summary.toolsRun.forEach((toolId) => {
+        const spokeRes = res[toolId];
         if (!spokeRes || !spokeRes.results) return;
         spokeRes.results.forEach((r) => {
-          const fileName = r.fileName || r.file || "unknown";
-          totalFilesSet.add(fileName);
-          const normalizedResult = {
-            fileName,
-            issues: [],
-            metrics: r.metrics || { tokenCost: r.tokenCost || 0 }
-          };
-          if (r.issues && Array.isArray(r.issues)) {
-            r.issues.forEach((i) => {
-              const normalizedIssue = typeof i === "string" ? {
-                type: defaultType,
-                severity: r.severity || import_core3.Severity.Info,
-                message: i,
-                location: { file: fileName, line: 1 }
-              } : {
-                type: i.type || defaultType,
-                severity: i.severity || r.severity || import_core3.Severity.Info,
-                message: i.message || String(i),
-                location: i.location || { file: fileName, line: 1 },
-                suggestion: i.suggestion
-              };
-              if (normalizedIssue.severity === import_core3.Severity.Critical || normalizedIssue.severity === "critical")
-                criticalCount++;
-              if (normalizedIssue.severity === import_core3.Severity.Major || normalizedIssue.severity === "major")
-                majorCount++;
-              normalizedResult.issues.push(normalizedIssue);
-            });
-          } else if (r.severity) {
-            const normalizedIssue = {
-              type: defaultType,
-              severity: r.severity,
-              message: r.message || "General issue",
-              location: { file: fileName, line: 1 }
-            };
-            if (normalizedIssue.severity === import_core3.Severity.Critical || normalizedIssue.severity === "critical")
-              criticalCount++;
-            if (normalizedIssue.severity === import_core3.Severity.Major || normalizedIssue.severity === "major")
-              majorCount++;
-            normalizedResult.issues.push(normalizedIssue);
-          }
-          allResults.push(normalizedResult);
+          totalFilesSet.add(r.fileName);
+          allResults.push(r);
+          r.issues?.forEach((i) => {
+            if (i.severity === import_core3.Severity.Critical) criticalCount++;
+            if (i.severity === import_core3.Severity.Major) majorCount++;
+          });
         });
-      };
-      collect(res[import_core3.ToolName.PatternDetect], import_core3.IssueType.DuplicatePattern);
-      collect(res[import_core3.ToolName.ContextAnalyzer], import_core3.IssueType.ContextFragmentation);
-      collect(res[import_core3.ToolName.NamingConsistency], import_core3.IssueType.NamingInconsistency);
-      collect(res[import_core3.ToolName.DocDrift], import_core3.IssueType.DocDrift);
-      collect(res[import_core3.ToolName.DependencyHealth], import_core3.IssueType.DependencyHealth);
-      collect(res[import_core3.ToolName.AiSignalClarity], import_core3.IssueType.AiSignalClarity);
-      collect(res[import_core3.ToolName.AgentGrounding], import_core3.IssueType.AgentNavigationFailure);
-      collect(res[import_core3.ToolName.TestabilityIndex], import_core3.IssueType.LowTestability);
-      collect(res[import_core3.ToolName.ChangeAmplification], import_core3.IssueType.ChangeAmplification);
+      });
       return {
         ...res,
         results: allResults,
@@ -1222,199 +639,70 @@ async function scanAction(directory, options) {
         scoring
       };
     };
+    const outputData = {
+      ...mapToUnifiedReport(results, scoringResult),
+      repository: repoMetadata
+    };
     const outputFormat = options.output || finalOptions.output?.format || "console";
-    const userOutputFile = options.outputFile || finalOptions.output?.file;
+    const outputPath = (0, import_core3.resolveOutputPath)(
+      options.outputFile || finalOptions.output?.file,
+      `aiready-report-${getReportTimestamp()}.json`,
+      resolvedDir
+    );
     if (outputFormat === "json") {
-      const timestamp = getReportTimestamp();
-      const defaultFilename = `aiready-report-${timestamp}.json`;
-      const outputPath = (0, import_core3.resolveOutputPath)(
-        userOutputFile,
-        defaultFilename,
-        resolvedDir
-      );
-      const outputData = {
-        ...mapToUnifiedReport(results, scoringResult),
-        repository: repoMetadata
-      };
       (0, import_core3.handleJSONOutput)(
         outputData,
         outputPath,
         `\u2705 Report saved to ${outputPath}`
       );
-      if (options.upload) {
-        console.log(import_chalk3.default.blue("\n\u{1F4E4} Automatic upload triggered..."));
-        await uploadAction(outputPath, {
-          apiKey: options.apiKey,
-          server: options.server
-        });
-      }
-      await warnIfGraphCapExceeded(outputData, resolvedDir);
     } else {
-      const timestamp = getReportTimestamp();
-      const defaultFilename = `aiready-report-${timestamp}.json`;
-      const outputPath = (0, import_core3.resolveOutputPath)(
-        userOutputFile,
-        defaultFilename,
-        resolvedDir
-      );
-      const outputData = {
-        ...mapToUnifiedReport(results, scoringResult),
-        repository: repoMetadata
-      };
       try {
         (0, import_fs3.writeFileSync)(outputPath, JSON.stringify(outputData, null, 2));
         console.log(import_chalk3.default.dim(`\u2705 Report auto-persisted to ${outputPath}`));
-        if (options.upload) {
-          console.log(import_chalk3.default.blue("\n\u{1F4E4} Automatic upload triggered..."));
-          await uploadAction(outputPath, {
-            apiKey: options.apiKey,
-            server: options.server
-          });
-        }
-        await warnIfGraphCapExceeded(outputData, resolvedDir);
       } catch (err) {
         void err;
       }
     }
-    const isCI = options.ci || process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
+    if (options.upload) {
+      await uploadAction(outputPath, {
+        apiKey: options.apiKey,
+        server: options.server
+      });
+    }
+    await warnIfGraphCapExceeded(outputData, resolvedDir);
+    const isCI = options.ci || process.env.CI === "true";
     if (isCI && scoringResult) {
       const threshold = options.threshold ? parseInt(options.threshold) : void 0;
       const failOnLevel = options.failOn || "critical";
-      if (process.env.GITHUB_ACTIONS === "true") {
-        console.log(`
-::group::AI Readiness Score`);
-        console.log(`score=${scoringResult.overall}`);
-        if (scoringResult.breakdown) {
-          scoringResult.breakdown.forEach((tool) => {
-            console.log(`${tool.toolName}=${tool.score}`);
-          });
-        }
-        console.log("::endgroup::");
-        if (threshold && scoringResult.overall < threshold) {
-          console.log(
-            `::error::AI Readiness Score ${scoringResult.overall} is below threshold ${threshold}`
-          );
-        } else if (threshold) {
-          console.log(
-            `::notice::AI Readiness Score: ${scoringResult.overall}/100 (threshold: ${threshold})`
-          );
-        }
-        if (results[import_core3.ToolName.PatternDetect]) {
-          const criticalPatterns = results[import_core3.ToolName.PatternDetect].results.flatMap(
-            (p) => p.issues.filter((i) => i.severity === import_core3.Severity.Critical)
-          );
-          criticalPatterns.slice(0, 10).forEach((issue) => {
-            console.log(
-              `::warning file=${issue.location?.file || "unknown"},line=${issue.location?.line || 1}::${issue.message}`
-            );
-          });
-        }
-      }
       let shouldFail = false;
       let failReason = "";
       if (threshold && scoringResult.overall < threshold) {
         shouldFail = true;
-        failReason = `AI Readiness Score ${scoringResult.overall} is below threshold ${threshold}`;
+        failReason = `Score ${scoringResult.overall} < threshold ${threshold}`;
       }
+      const report = mapToUnifiedReport(results, scoringResult);
       if (failOnLevel !== "none") {
-        const severityLevels = { critical: 4, major: 3, minor: 2, any: 1 };
-        const minSeverity = severityLevels[failOnLevel] || 4;
-        let criticalCount = 0;
-        let majorCount = 0;
-        if (results[import_core3.ToolName.PatternDetect]) {
-          results[import_core3.ToolName.PatternDetect].results.forEach((p) => {
-            p.issues.forEach((i) => {
-              if (i.severity === import_core3.Severity.Critical) criticalCount++;
-              if (i.severity === import_core3.Severity.Major) majorCount++;
-            });
-          });
-        }
-        if (results[import_core3.ToolName.ContextAnalyzer]) {
-          results[import_core3.ToolName.ContextAnalyzer].results.forEach((c) => {
-            if (c.severity === import_core3.Severity.Critical) criticalCount++;
-            if (c.severity === import_core3.Severity.Major) majorCount++;
-          });
-        }
-        if (results[import_core3.ToolName.NamingConsistency]) {
-          results[import_core3.ToolName.NamingConsistency].results.forEach((r) => {
-            r.issues?.forEach((i) => {
-              if (i.severity === import_core3.Severity.Critical) criticalCount++;
-              if (i.severity === import_core3.Severity.Major) majorCount++;
-            });
-          });
-        }
-        if (minSeverity >= 4 && criticalCount > 0) {
+        if (failOnLevel === "critical" && report.summary.criticalIssues > 0) {
           shouldFail = true;
-          failReason = `Found ${criticalCount} critical issues`;
-        } else if (minSeverity >= 3 && criticalCount + majorCount > 0) {
+          failReason = `Found ${report.summary.criticalIssues} critical issues`;
+        } else if (failOnLevel === "major" && report.summary.criticalIssues + report.summary.majorIssues > 0) {
           shouldFail = true;
-          failReason = `Found ${criticalCount} critical and ${majorCount} major issues`;
+          failReason = `Found ${report.summary.criticalIssues} critical and ${report.summary.majorIssues} major issues`;
         }
       }
       if (shouldFail) {
-        console.log(import_chalk3.default.red("\n\u{1F6AB} PR BLOCKED: AI Readiness Check Failed"));
-        console.log(import_chalk3.default.red(`   Reason: ${failReason}`));
-        console.log(import_chalk3.default.dim("\n   Remediation steps:"));
-        console.log(
-          import_chalk3.default.dim("   1. Run `aiready scan` locally to see detailed issues")
-        );
-        console.log(import_chalk3.default.dim("   2. Fix the critical issues before merging"));
-        console.log(
-          import_chalk3.default.dim(
-            "   3. Consider upgrading to Team plan for historical tracking: https://getaiready.dev/pricing"
-          )
-        );
+        console.log(import_chalk3.default.red(`
+\u{1F6AB} PR BLOCKED: ${failReason}`));
         process.exit(1);
       } else {
-        console.log(import_chalk3.default.green("\n\u2705 PR PASSED: AI Readiness Check"));
-        if (threshold) {
-          console.log(
-            import_chalk3.default.green(
-              `   Score: ${scoringResult.overall}/100 (threshold: ${threshold})`
-            )
-          );
-        }
-        console.log(
-          import_chalk3.default.dim(
-            "\n   \u{1F4A1} Track historical trends: https://getaiready.dev \u2014 Team plan $99/mo"
-          )
-        );
+        console.log(import_chalk3.default.green("\n\u2705 PR PASSED"));
       }
     }
   } catch (error) {
     (0, import_core3.handleCLIError)(error, "Analysis");
   }
 }
-var scanHelpText = `
-EXAMPLES:
-  $ aiready scan                                    # Analyze all tools
-  $ aiready scan --tools patterns,context           # Skip consistency
-  $ aiready scan --profile agentic                  # Optimize for AI agent execution
-  $ aiready scan --profile security                 # Optimize for secure coding (testability)
-  $ aiready scan --compare-to prev-report.json      # Compare trends against previous run
-  $ aiready scan --score --threshold 75             # CI/CD with threshold
-  $ aiready scan --ci --threshold 70                # GitHub Actions gatekeeper
-  $ aiready scan --ci --fail-on major               # Fail on major+ issues
-  $ aiready scan --output json --output-file report.json
-  $ aiready scan --upload --api-key ar_...             # Automatic platform upload
-  $ aiready scan --upload --server custom-url.com      # Upload to custom platform
-
-PROFILES:
-  agentic:      aiSignalClarity, grounding, testability
-  cost:         patterns, context
-  security:     consistency, testability
-  onboarding:   context, consistency, grounding
-
-CI/CD INTEGRATION (Gatekeeper Mode):
-  Use --ci for GitHub Actions integration:
-  - Outputs GitHub Actions annotations for PR checks
-  - Fails with exit code 1 if threshold not met
-  - Shows clear "blocked" message with remediation steps
-
-  Example GitHub Actions workflow:
-    - name: AI Readiness Check
-      run: aiready scan --ci --threshold 70
-`;
+var scanHelpText = `...`;
 
 // src/commands/patterns.ts
 var import_chalk4 = __toESM(require("chalk"));
@@ -1457,8 +745,8 @@ async function patternsAction(directory, options) {
       defaults,
       cliOptions
     );
-    const { analyzePatterns: analyzePatterns2, generateSummary, calculatePatternScore } = await import("@aiready/pattern-detect");
-    const { results, duplicates } = await analyzePatterns2(finalOptions);
+    const { analyzePatterns, generateSummary, calculatePatternScore } = await import("@aiready/pattern-detect");
+    const { results, duplicates } = await analyzePatterns(finalOptions);
     const elapsedTime = (0, import_core4.getElapsedTime)(startTime);
     const summary = generateSummary(results);
     let patternScore;
@@ -1603,8 +891,8 @@ async function contextAction(directory, options) {
     );
     console.log(`   Analysis focus: ${finalOptions.focus}`);
     console.log("");
-    const { analyzeContext: analyzeContext2, generateSummary, calculateContextScore } = await import("@aiready/context-analyzer");
-    const results = await analyzeContext2(finalOptions);
+    const { analyzeContext, generateSummary, calculateContextScore } = await import("@aiready/context-analyzer");
+    const results = await analyzeContext(finalOptions);
     const elapsedTime = (0, import_core5.getElapsedTime)(startTime);
     const summary = generateSummary(results);
     let contextScore;
@@ -1788,8 +1076,8 @@ async function consistencyAction(directory, options) {
       include: options.include?.split(","),
       exclude: options.exclude?.split(",")
     });
-    const { analyzeConsistency: analyzeConsistency2, calculateConsistencyScore } = await import("@aiready/consistency");
-    const report = await analyzeConsistency2(finalOptions);
+    const { analyzeConsistency, calculateConsistencyScore } = await import("@aiready/consistency");
+    const report = await analyzeConsistency(finalOptions);
     const elapsedTime = (0, import_core6.getElapsedTime)(startTime);
     let consistencyScore;
     if (options.score) {