workflow-agent-cli 2.4.2 → 2.6.0

package/dist/cli/index.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import {
+  analyzeProject,
+  detectPackageManager,
   generateAuditReport,
   hasUncommittedChanges,
+  isMonorepo,
   runAllChecks,
   runAllSetups,
   stageAllChanges
-} from "../chunk-WXXFUPYO.js";
+} from "../chunk-6NWQLGHI.js";
 import {
   validateBranchName,
   validateCommitMessage,
@@ -15,7 +18,12 @@ import {
   hasConfig,
   loadConfig,
   validateScopeDefinitions
-} from "../chunk-RDVTKGQV.js";
+} from "../chunk-DEAF7P4L.js";
+import {
+  SCRIPT_CATEGORIES,
+  TOTAL_SCRIPTS,
+  WORKFLOW_SCRIPTS
+} from "../chunk-LN5OAWEQ.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -302,10 +310,10 @@ async function initCommand(options) {
     try {
       const presetModule = await import(`@workflow/scopes-${preset}`);
       scopes = presetModule.scopes || presetModule.default.scopes;
-      const spinner6 = p.spinner();
-      spinner6.start(`Loading ${presetModule.default?.name || preset} preset`);
+      const spinner7 = p.spinner();
+      spinner7.start(`Loading ${presetModule.default?.name || preset} preset`);
       await new Promise((resolve2) => setTimeout(resolve2, 500));
-      spinner6.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
+      spinner7.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
     } catch (error) {
       console.log(
         chalk.yellow(
@@ -352,8 +360,8 @@ async function initCommand(options) {
     process.exit(0);
   }
   if (shouldGenerateGuidelines) {
-    const spinner6 = p.spinner();
-    spinner6.start("Generating guidelines...");
+    const spinner7 = p.spinner();
+    spinner7.start("Generating guidelines...");
     try {
       const templatesDir = join(__dirname, "../../templates");
       await validateTemplateDirectory(templatesDir);
@@ -365,9 +373,9 @@ async function initCommand(options) {
         guidelinesDir,
         context
       );
-      spinner6.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
+      spinner7.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
     } catch (error) {
-      spinner6.stop("\u26A0\uFE0F  Could not generate guidelines");
+      spinner7.stop("\u26A0\uFE0F  Could not generate guidelines");
       console.log(
         chalk.yellow(
           `
@@ -590,12 +598,6 @@ import * as p3 from "@clack/prompts";
 import chalk6 from "chalk";
 import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
-var WORKFLOW_SCRIPTS = {
-  "workflow:init": "workflow-agent init",
-  "workflow:validate": "workflow-agent validate",
-  "workflow:suggest": "workflow-agent suggest",
-  "workflow:doctor": "workflow-agent doctor"
-};
 async function setupCommand() {
   p3.intro(chalk6.bgBlue(" workflow-agent setup "));
   const cwd = process.cwd();
@@ -609,48 +611,57 @@ async function setupCommand() {
   if (!packageJson.scripts) {
     packageJson.scripts = {};
   }
-  const existingScripts = [];
-  const scriptsToAdd = {};
+  const addedScripts = [];
+  const updatedScripts = [];
   for (const [scriptName, scriptCommand] of Object.entries(WORKFLOW_SCRIPTS)) {
-    if (packageJson.scripts[scriptName]) {
-      existingScripts.push(scriptName);
-    } else {
-      scriptsToAdd[scriptName] = scriptCommand;
+    if (!packageJson.scripts[scriptName]) {
+      packageJson.scripts[scriptName] = scriptCommand;
+      addedScripts.push(scriptName);
+    } else if (packageJson.scripts[scriptName] !== scriptCommand) {
+      packageJson.scripts[scriptName] = scriptCommand;
+      updatedScripts.push(scriptName);
     }
   }
-  if (Object.keys(scriptsToAdd).length === 0) {
-    p3.outro(chalk6.green("\u2713 All workflow scripts are already configured!"));
+  const totalChanges = addedScripts.length + updatedScripts.length;
+  if (totalChanges === 0) {
+    p3.outro(
+      chalk6.green(
+        `\u2713 All ${TOTAL_SCRIPTS} workflow scripts are already configured!`
+      )
+    );
     return;
   }
-  console.log(chalk6.dim("\nScripts to add:"));
-  for (const [scriptName, scriptCommand] of Object.entries(scriptsToAdd)) {
-    console.log(chalk6.dim(`  ${scriptName}: ${scriptCommand}`));
-  }
-  if (existingScripts.length > 0) {
-    console.log(chalk6.yellow("\nExisting scripts (will be skipped):"));
-    existingScripts.forEach((name) => {
-      console.log(chalk6.yellow(`  ${name}`));
-    });
-  }
-  const shouldAdd = await p3.confirm({
-    message: "Add these scripts to package.json?",
-    initialValue: true
-  });
-  if (p3.isCancel(shouldAdd) || !shouldAdd) {
-    p3.cancel("Setup cancelled");
-    process.exit(0);
-  }
-  for (const [scriptName, scriptCommand] of Object.entries(scriptsToAdd)) {
-    packageJson.scripts[scriptName] = scriptCommand;
-  }
   writeFileSync(
     packageJsonPath,
     JSON.stringify(packageJson, null, 2) + "\n",
     "utf-8"
   );
+  const summaryParts = [];
+  if (addedScripts.length > 0) {
+    summaryParts.push(`${addedScripts.length} new`);
+  }
+  if (updatedScripts.length > 0) {
+    summaryParts.push(`${updatedScripts.length} updated`);
+  }
+  console.log(
+    chalk6.green(
+      `
+\u2713 Workflow scripts configured (${summaryParts.join(", ")}):
+`
+    )
+  );
+  for (const [category, scripts] of Object.entries(SCRIPT_CATEGORIES)) {
+    console.log(chalk6.cyan(`  ${category}:`));
+    for (const script of scripts) {
+      const isNew = addedScripts.includes(script);
+      const isUpdated = updatedScripts.includes(script);
+      const marker = isNew ? chalk6.green(" (new)") : isUpdated ? chalk6.yellow(" (updated)") : "";
+      console.log(chalk6.dim(`    - ${script}`) + marker);
+    }
+  }
   p3.outro(
     chalk6.green(
-      `\u2713 Added ${Object.keys(scriptsToAdd).length} workflow scripts to package.json!`
+      `\u2713 ${TOTAL_SCRIPTS} workflow scripts available in package.json!`
     )
   );
   console.log(chalk6.dim("\nRun them with:"));
@@ -668,8 +679,8 @@ async function scopeCreateCommand(options) {
   console.log(chalk7.bold.cyan("\n\u{1F3A8} Create Custom Scope Package\n"));
   const cwd = process.cwd();
   const isNonInteractive = !!(options.name && options.scopes && options.presetName);
-  const isMonorepo = existsSync3(join3(cwd, "pnpm-workspace.yaml"));
-  if (isMonorepo) {
+  const isMonorepo2 = existsSync3(join3(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo2) {
     console.log(chalk7.dim("\u2713 Detected monorepo workspace\n"));
   }
   const packageNameInput = isNonInteractive ? options.name : await p4.text({
@@ -813,7 +824,7 @@ async function scopeCreateCommand(options) {
   let outputDir;
   if (options.outputDir) {
     outputDir = options.outputDir;
-  } else if (isMonorepo) {
+  } else if (isMonorepo2) {
     outputDir = join3(cwd, "packages", `scopes-${packageName}`);
   } else {
     const customDir = await p4.text({
@@ -837,8 +848,8 @@ async function scopeCreateCommand(options) {
       process.exit(0);
     }
   }
-  const spinner6 = p4.spinner();
-  spinner6.start("Creating package structure...");
+  const spinner7 = p4.spinner();
+  spinner7.start("Creating package structure...");
   try {
     await mkdir2(join3(outputDir, "src"), { recursive: true });
     const packageJson = {
@@ -969,8 +980,8 @@ describe('${presetName} Scope Preset', () => {
         "utf-8"
       );
     }
-    spinner6.stop("\u2713 Package structure created");
-    if (isMonorepo) {
+    spinner7.stop("\u2713 Package structure created");
+    if (isMonorepo2) {
       const workspaceFile = join3(cwd, "pnpm-workspace.yaml");
       const workspaceContent = await readFile(workspaceFile, "utf-8");
       const packagePath = `packages/scopes-${packageName}`;
@@ -1021,7 +1032,7 @@ describe('${presetName} Scope Preset', () => {
       );
     }
   } catch (error) {
-    spinner6.stop("\u2717 Failed to create package");
+    spinner7.stop("\u2717 Failed to create package");
     console.error(chalk7.red("\nError:"), error);
     process.exit(1);
   }
@@ -1076,8 +1087,8 @@ async function scopeMigrateCommand(options) {
     p5.cancel("Migration cancelled");
     process.exit(0);
   }
-  const isMonorepo = existsSync4(join4(cwd, "pnpm-workspace.yaml"));
-  if (isMonorepo) {
+  const isMonorepo2 = existsSync4(join4(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo2) {
     console.log(chalk8.dim("\n\u2713 Detected monorepo workspace\n"));
   }
   const packageNameInput = options.name || await p5.text({
@@ -1125,7 +1136,7 @@ async function scopeMigrateCommand(options) {
   let outputDir;
   if (options.outputDir) {
     outputDir = options.outputDir;
-  } else if (isMonorepo) {
+  } else if (isMonorepo2) {
     outputDir = join4(cwd, "packages", `scopes-${packageName}`);
   } else {
     const customDir = await p5.text({
@@ -1149,8 +1160,8 @@ async function scopeMigrateCommand(options) {
       process.exit(0);
     }
   }
-  const spinner6 = p5.spinner();
-  spinner6.start("Migrating scopes to package...");
+  const spinner7 = p5.spinner();
+  spinner7.start("Migrating scopes to package...");
   try {
     await mkdir3(join4(outputDir, "src"), { recursive: true });
     const packageJson = {
@@ -1278,8 +1289,8 @@ describe('${presetName} Scope Preset (Migrated)', () => {
 });
 `;
     await writeFile3(join4(outputDir, "src", "index.test.ts"), testFile, "utf-8");
-    spinner6.stop("\u2713 Package created from migrated scopes");
-    if (isMonorepo) {
+    spinner7.stop("\u2713 Package created from migrated scopes");
+    if (isMonorepo2) {
       const workspaceFile = join4(cwd, "pnpm-workspace.yaml");
       const workspaceContent = await readFile2(workspaceFile, "utf-8");
       const packagePath = `packages/scopes-${packageName}`;
@@ -1350,7 +1361,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
       )
     );
   } catch (error) {
-    spinner6.stop("\u2717 Migration failed");
+    spinner7.stop("\u2717 Migration failed");
     console.error(chalk8.red("\nError:"), error);
     process.exit(1);
   }
@@ -1379,7 +1390,9 @@ async function verifyCommand(options) {
   console.log(chalk9.dim(`  Max retries: ${maxRetries}`));
   console.log(chalk9.dim(`  Commit on success: ${shouldCommit ? "yes" : "no"}`));
   console.log(chalk9.dim(`  Dry-run: ${dryRun ? "yes" : "no"}`));
-  console.log(chalk9.dim(`  Learn from fixes: ${learnFromFixes ? "yes" : "no"}`));
+  console.log(
+    chalk9.dim(`  Learn from fixes: ${learnFromFixes ? "yes" : "no"}`)
+  );
   const startTime = Date.now();
   const result = await runAllChecks(cwd, {
     maxRetries,
@@ -1489,7 +1502,9 @@ async function recordSuccessfulFixes(cwd, result) {
     } catch {
     }
     if (result.appliedFixes && result.appliedFixes.length > 0) {
-      console.log(chalk9.cyan("\n\u{1F4DA} Recording successful fixes for learning...\n"));
+      console.log(
+        chalk9.cyan("\n\u{1F4DA} Recording successful fixes for learning...\n")
+      );
       for (const fix of result.appliedFixes) {
         const patternName = `Auto-fix: ${fix.displayName}`;
         const patternId = crypto.randomUUID();
@@ -1572,8 +1587,10 @@ async function recordSuccessfulFixes(cwd, result) {
     }
   } catch (error) {
     console.log(
-      chalk9.dim(`
-  Note: Could not record learning patterns: ${error.message}`)
+      chalk9.dim(
+        `
+  Note: Could not record learning patterns: ${error.message}`
+      )
     );
   }
 }
@@ -1584,14 +1601,14 @@ import chalk10 from "chalk";
 async function autoSetupCommand(options) {
   console.log(chalk10.bold.cyan("\n\u{1F527} Workflow Agent Auto-Setup\n"));
   const cwd = process.cwd();
-  const spinner6 = p6.spinner();
-  spinner6.start("Analyzing project...");
+  const spinner7 = p6.spinner();
+  spinner7.start("Analyzing project...");
   let report;
   try {
     report = await generateAuditReport(cwd);
-    spinner6.stop("\u2713 Project analysis complete");
+    spinner7.stop("\u2713 Project analysis complete");
   } catch (error) {
-    spinner6.stop("\u2717 Failed to analyze project");
+    spinner7.stop("\u2717 Failed to analyze project");
     console.error(
       chalk10.red(
         `Error: ${error instanceof Error ? error.message : String(error)}`
@@ -1724,204 +1741,2852 @@ function formatAuditReportColored(report) {
   return lines.join("\n");
 }
 
-// src/cli/commands/learn.ts
-import chalk11 from "chalk";
+// src/cli/commands/advisory.ts
 import * as p7 from "@clack/prompts";
-import {
-  PatternStore as PatternStore2,
-  ContributorManager as ContributorManager2,
-  PatternAnonymizer,
-  TelemetryCollector as TelemetryCollector2
-} from "@hawkinside_out/workflow-improvement-tracker";
-function getWorkspacePath() {
-  return process.cwd();
-}
-function formatDate(isoString) {
-  return new Date(isoString).toLocaleDateString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-  });
-}
-function formatTags(tags) {
-  return tags.map((t) => `${t.category}:${t.name}`).join(", ");
-}
-async function learnRecordCommand(options) {
-  const cwd = getWorkspacePath();
-  const store = new PatternStore2(cwd);
-  console.log(chalk11.cyan("\n\u{1F4DA} Record a Learning Pattern\n"));
-  let patternType = options.type;
-  if (!patternType) {
-    const typeChoice = await p7.select({
-      message: "What type of pattern are you recording?",
-      options: [
-        {
-          value: "fix",
-          label: "\u{1F527} Fix Pattern - A specific solution to a problem"
-        },
-        {
-          value: "blueprint",
-          label: "\u{1F4D0} Blueprint - A project structure template"
-        }
-      ]
-    });
-    if (p7.isCancel(typeChoice)) {
-      p7.cancel("Recording cancelled");
-      process.exit(0);
+import chalk11 from "chalk";
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/utils/advisory-analyzer.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join5 } from "path";
+import fg from "fast-glob";
+var AdvisoryAnalyzer = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Run analysis at specified depth level
+   */
+  async analyze() {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const { depth } = this.options;
+    const project = await this.analyzeProject();
+    if (depth === "executive") {
+      return this.analyzeExecutive(timestamp, project);
     }
-    patternType = typeChoice;
+    const technology = await this.analyzeTechnology();
+    const packages = await this.analyzePackages();
+    const risks = await this.assessRisks(project, technology, packages);
+    const opportunities = await this.assessOpportunities(
+      project,
+      technology,
+      packages
+    );
+    if (depth === "quick") {
+      return {
+        depth,
+        timestamp,
+        project,
+        technology,
+        packages,
+        risks,
+        opportunities
+      };
+    }
+    const architecture = await this.analyzeArchitecture();
+    if (depth === "standard") {
+      const health2 = this.options.includeHealth ? await this.analyzeHealth() : void 0;
+      return {
+        depth,
+        timestamp,
+        project,
+        technology,
+        packages,
+        architecture,
+        risks,
+        opportunities,
+        health: health2
+      };
+    }
+    const codePatterns = await this.analyzeCodePatterns();
+    const health = this.options.includeHealth ? await this.analyzeHealth() : void 0;
+    return {
+      depth,
+      timestamp,
+      project,
+      technology,
+      packages,
+      architecture,
+      codePatterns,
+      risks,
+      opportunities,
+      health
+    };
   }
-  let name = options.name;
-  if (!name) {
-    const nameInput = await p7.text({
-      message: "Pattern name:",
-      placeholder: "e.g., Next.js App Router Migration",
-      validate: (value) => {
-        if (!value || value.length < 3) return "Name must be at least 3 characters";
-        if (value.length > 100) return "Name must be less than 100 characters";
-        return void 0;
-      }
+  /**
+   * Executive depth: High-level business summary only
+   */
+  async analyzeExecutive(timestamp, project) {
+    const packageJson = await this.readPackageJson();
+    const deps = packageJson.dependencies || {};
+    const devDeps = packageJson.devDependencies || {};
+    const techCategories = this.categorizeTechnologies(deps, devDeps);
+    const risks = this.calculateExecutiveRisks(project, techCategories);
+    const opportunities = this.calculateExecutiveOpportunities(
+      project,
+      techCategories
+    );
+    return {
+      depth: "executive",
+      timestamp,
+      project,
+      technology: {
+        language: this.detectLanguage(deps, devDeps),
+        runtime: this.detectRuntime(deps, devDeps),
+        buildTools: this.detectBuildTools(devDeps),
+        platforms: this.detectPlatforms(deps),
+        infrastructure: this.detectInfrastructure(deps, devDeps)
+      },
+      packages: {
+        total: Object.keys(deps).length + Object.keys(devDeps).length,
+        production: [],
+        development: [],
+        categories: techCategories,
+        outdated: [],
+        security: []
+      },
+      risks,
+      opportunities
+    };
+  }
+  /**
+   * Analyze project overview
+   */
+  async analyzeProject() {
+    const packageJson = await this.readPackageJson();
+    const isMonorepoProject = await isMonorepo(this.options.cwd);
+    const fileCount = await this.countFiles();
+    const totalLines = await this.countTotalLines();
+    let workspaceCount;
+    if (isMonorepoProject && packageJson.workspaces) {
+      workspaceCount = Array.isArray(packageJson.workspaces) ? packageJson.workspaces.length : 0;
+    }
+    return {
+      name: packageJson.name || "Unknown Project",
+      version: packageJson.version || "0.0.0",
+      description: packageJson.description,
+      isMonorepo: isMonorepoProject,
+      packageManager: await detectPackageManager(this.options.cwd),
+      workspaceCount,
+      fileCount,
+      totalLines
+    };
+  }
+  /**
+   * Analyze technology stack
+   */
+  async analyzeTechnology() {
+    const packageJson = await this.readPackageJson();
+    const deps = packageJson.dependencies || {};
+    const devDeps = packageJson.devDependencies || {};
+    const projectAnalysis = await analyzeProject(this.options.cwd);
+    return {
+      framework: projectAnalysis.framework,
+      frameworkVersion: deps[projectAnalysis.framework || ""] || devDeps[projectAnalysis.framework || ""],
+      language: this.detectLanguage(deps, devDeps),
+      runtime: this.detectRuntime(deps, devDeps),
+      buildTools: this.detectBuildTools(devDeps),
+      platforms: this.detectPlatforms(deps),
+      infrastructure: this.detectInfrastructure(deps, devDeps)
+    };
+  }
+  /**
+   * Analyze packages in detail
+   */
+  async analyzePackages() {
+    const packageJson = await this.readPackageJson();
+    const deps = packageJson.dependencies || {};
+    const devDeps = packageJson.devDependencies || {};
+    const production = this.analyzeDependencies(deps, "production");
+    const development = this.analyzeDependencies(devDeps, "development");
+    const categories = this.categorizeTechnologies(deps, devDeps);
+    return {
+      total: Object.keys(deps).length + Object.keys(devDeps).length,
+      production,
+      development,
+      categories,
+      outdated: [],
+      // TODO: Implement outdated check
+      security: []
+      // TODO: Implement security audit
+    };
+  }
+  /**
+   * Analyze dependencies and categorize them
+   */
+  analyzeDependencies(deps, _type) {
+    return Object.entries(deps).map(([name, version]) => {
+      const category = this.categorizeDependency(name);
+      const info = this.getDependencyInfo(name, category);
+      return {
+        name,
+        version,
+        category,
+        ...info
+      };
     });
-    if (p7.isCancel(nameInput)) {
-      p7.cancel("Recording cancelled");
-      process.exit(0);
+  }
+  /**
+   * Categorize a dependency
+   */
+  categorizeDependency(name) {
+    if (["react", "vue", "angular", "svelte", "solid-js"].some(
+      (fw) => name.includes(fw)
+    )) {
+      return "UI Framework";
     }
-    name = nameInput;
+    if (["next", "nuxt", "remix", "sveltekit", "astro"].some(
+      (fw) => name.includes(fw)
+    )) {
+      return "Meta-Framework";
+    }
+    if (["redux", "zustand", "jotai", "recoil", "mobx", "pinia"].includes(name)) {
+      return "State Management";
+    }
+    if ([
+      "axios",
+      "fetch",
+      "swr",
+      "react-query",
+      "@tanstack/react-query",
+      "apollo",
+      "urql"
+    ].some((lib) => name.includes(lib))) {
+      return "API/Data Fetching";
+    }
+    if (["react-router", "vue-router", "@tanstack/router"].some(
+      (r) => name.includes(r)
+    )) {
+      return "Routing";
+    }
+    if (["formik", "react-hook-form", "final-form"].some((f) => name.includes(f))) {
+      return "Forms";
+    }
+    if ([
+      "styled-components",
+      "emotion",
+      "tailwind",
+      "sass",
+      "less",
+      "@mui",
+      "antd",
+      "chakra-ui"
+    ].some((s) => name.includes(s))) {
+      return "Styling/UI Components";
+    }
+    if ([
+      "vitest",
+      "jest",
+      "mocha",
+      "chai",
+      "testing-library",
+      "playwright",
+      "cypress"
+    ].some((t) => name.includes(t))) {
+      return "Testing";
+    }
+    if (["vite", "webpack", "rollup", "esbuild", "turbo", "tsup"].includes(name)) {
+      return "Build Tools";
+    }
+    if (["eslint", "prettier", "stylelint"].some((l) => name.includes(l))) {
+      return "Code Quality";
+    }
+    if (["prisma", "drizzle", "mongoose", "sequelize", "typeorm", "knex"].some(
+      (db) => name.includes(db)
+    )) {
+      return "Database ORM";
+    }
+    if (["next-auth", "auth0", "supabase", "clerk"].some((a) => name.includes(a))) {
+      return "Authentication";
+    }
+    if (["vercel", "netlify", "aws-sdk", "@google-cloud"].some(
+      (d) => name.includes(d)
+    )) {
+      return "Infrastructure";
+    }
+    if (["@analytics", "posthog", "mixpanel", "segment"].some(
+      (a) => name.includes(a)
+    )) {
+      return "Analytics";
+    }
+    return "Other";
   }
-  let description = options.description;
-  if (!description) {
-    const descInput = await p7.text({
-      message: "Description:",
-      placeholder: "What does this pattern solve?",
-      validate: (value) => {
-        if (!value || value.length < 10) return "Description must be at least 10 characters";
-        if (value.length > 500) return "Description must be less than 500 characters";
-        return void 0;
+  /**
+   * Get detailed info about a dependency
+   */
+  getDependencyInfo(name, category) {
+    const defaultInfo = {
+      purpose: `${category} library`,
+      businessValue: "Supports application functionality",
+      usagePatterns: ["Used throughout the application"]
+    };
+    const knownPackages = {
+      react: {
+        purpose: "Core UI library for building component-based interfaces",
+        businessValue: "Enables fast, interactive user experiences with reusable components",
+        usagePatterns: [
+          "Component rendering",
+          "State management",
+          "Event handling"
+        ],
+        alternatives: ["Vue", "Svelte", "Solid"]
+      },
+      next: {
+        purpose: "React meta-framework with SSR, routing, and optimization",
+        businessValue: "Improves SEO, performance, and developer productivity",
+        usagePatterns: [
+          "Server-side rendering",
+          "API routes",
+          "File-based routing"
+        ],
+        alternatives: ["Remix", "Gatsby"]
+      },
+      typescript: {
+        purpose: "Static type checking for JavaScript",
+        businessValue: "Reduces bugs, improves code quality, and enhances developer experience",
+        usagePatterns: ["Type definitions", "Compile-time checks"]
+      }
+      // Add more as needed
+    };
+    return knownPackages[name] || defaultInfo;
+  }
+  /**
+   * Categorize technologies at high level
+   */
+  categorizeTechnologies(deps, devDeps) {
+    const allDeps = { ...deps, ...devDeps };
+    const categories = /* @__PURE__ */ new Map();
+    Object.keys(allDeps).forEach((name) => {
+      const category = this.categorizeDependency(name);
+      if (!categories.has(category)) {
+        categories.set(category, []);
       }
+      categories.get(category).push(name);
     });
-    if (p7.isCancel(descInput)) {
-      p7.cancel("Recording cancelled");
-      process.exit(0);
+    return Array.from(categories.entries()).map(([name, packages]) => ({
+      name,
+      count: packages.length,
+      packages,
+      businessImpact: this.getCategoryBusinessImpact(name)
+    }));
+  }
+  /**
+   * Get business impact description for a category
+   */
+  getCategoryBusinessImpact(category) {
+    const impacts = {
+      "UI Framework": "Core user experience - directly impacts customer satisfaction and engagement",
+      "Meta-Framework": "Application performance and SEO - affects discoverability and user retention",
+      "State Management": "Data consistency - ensures reliable application behavior",
+      "API/Data Fetching": "Backend integration - enables core business functionality",
+      Routing: "Navigation - affects user flow and conversion rates",
+      Forms: "Data collection - critical for user onboarding and conversions",
+      "Styling/UI Components": "Visual design - impacts brand perception and usability",
+      Testing: "Quality assurance - reduces production bugs and support costs",
+      "Build Tools": "Development efficiency - affects time-to-market for new features",
+      "Code Quality": "Maintainability - reduces technical debt and long-term costs",
+      "Database ORM": "Data persistence - ensures business data integrity",
+      Authentication: "Security and user management - protects business and customer data",
+      Infrastructure: "Hosting and scalability - affects uptime and operational costs",
+      Analytics: "Business intelligence - enables data-driven decision making"
+    };
+    return impacts[category] || "Supports various application features";
+  }
+  /**
+   * Analyze architecture patterns
+   */
+  async analyzeArchitecture() {
+    const files = await this.getProjectFiles();
+    const entryPoints = this.detectEntryPoints(files);
+    const pattern = this.detectArchitecturePattern(files);
+    const layers = this.detectLayers(files);
+    return {
+      pattern,
+      layers,
+      entryPoints,
+      dataFlow: this.analyzeDataFlow(files),
+      keyDecisions: this.extractKeyDecisions(files)
+    };
+  }
+  /**
+   * Analyze code patterns in detail
+   */
+  async analyzeCodePatterns() {
+    const files = await this.getProjectFiles();
+    return {
+      components: await this.analyzeComponents(files),
+      services: await this.analyzeServices(files),
+      utilities: await this.analyzeUtilities(files),
+      tests: await this.analyzeTests(files),
+      customPatterns: await this.detectCustomPatterns(files)
+    };
+  }
+  /**
+   * Assess risks
+   */
+  async assessRisks(project, technology, packages) {
+    const categories = [];
+    const critical = [];
+    const high = [];
+    const medium = [];
+    const low = [];
+    const depRisk = this.assessDependencyRisk(packages);
+    categories.push(depRisk);
+    this.categorizeRiskItems(depRisk, critical, high, medium, low);
+    const techRisk = this.assessTechnologyRisk(technology);
+    categories.push(techRisk);
+    this.categorizeRiskItems(techRisk, critical, high, medium, low);
+    const complexityRisk = this.assessComplexityRisk(project);
+    categories.push(complexityRisk);
+    this.categorizeRiskItems(complexityRisk, critical, high, medium, low);
+    const overall = categories.reduce((sum, cat) => sum + cat.score, 0) / categories.length;
+    return { overall, categories, critical, high, medium, low };
+  }
+  /**
+   * Assess opportunities
+   */
+  async assessOpportunities(project, technology, packages) {
+    const categories = [];
+    const immediate = [];
+    const shortTerm = [];
+    const longTerm = [];
+    const modernization = this.assessModernizationOpportunities(
+      technology,
+      packages
+    );
+    categories.push(modernization);
+    this.categorizeOpportunityItems(
+      modernization,
+      immediate,
+      shortTerm,
+      longTerm
+    );
+    const optimization = this.assessOptimizationOpportunities(project);
+    categories.push(optimization);
+    this.categorizeOpportunityItems(
+      optimization,
+      immediate,
+      shortTerm,
+      longTerm
+    );
+    const growth = this.assessGrowthOpportunities(technology, packages);
+    categories.push(growth);
+    this.categorizeOpportunityItems(growth, immediate, shortTerm, longTerm);
+    const overall = categories.reduce((sum, cat) => sum + cat.potential, 0) / categories.length;
+    return { overall, categories, immediate, shortTerm, longTerm };
+  }
+  /**
+   * Analyze health metrics
+   */
+  async analyzeHealth() {
+    return {
+      typecheck: false,
+      lint: false,
+      tests: false,
+      build: false,
+      issues: 0
+    };
+  }
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+  async readPackageJson() {
+    const pkgPath = join5(this.options.cwd, "package.json");
+    if (!existsSync5(pkgPath)) {
+      throw new Error("package.json not found");
     }
-    description = descInput;
+    const content = await readFile3(pkgPath, "utf-8");
+    return JSON.parse(content);
   }
-  let framework = options.framework;
-  if (!framework) {
-    const fwInput = await p7.text({
-      message: "Framework:",
-      placeholder: "e.g., next, react, vue, express"
+  async countFiles() {
+    const patterns = ["**/*.{ts,tsx,js,jsx,py,go,rs,java}"];
+    const files = await fg(patterns, {
+      cwd: this.options.cwd,
+      ignore: [
+        "node_modules/**",
+        "dist/**",
+        "build/**",
+        ".next/**",
+        "coverage/**"
+      ]
     });
-    if (p7.isCancel(fwInput)) {
-      p7.cancel("Recording cancelled");
-      process.exit(0);
+    return files.length;
+  }
+  async countTotalLines() {
+    const fileCount = await this.countFiles();
+    return fileCount * 50;
+  }
+  detectLanguage(deps, devDeps) {
+    if (devDeps.typescript || deps.typescript) return "TypeScript";
+    if (Object.keys(deps).some((d) => d.includes("react") || d.includes("vue"))) {
+      return "JavaScript";
     }
-    framework = fwInput;
+    return "JavaScript";
   }
-  let version = options.version;
-  if (!version) {
-    const versionInput = await p7.text({
-      message: "Framework version (semver range):",
-      placeholder: "e.g., >=14.0.0, ^18.0.0",
-      initialValue: ">=1.0.0"
-    });
-    if (p7.isCancel(versionInput)) {
-      p7.cancel("Recording cancelled");
-      process.exit(0);
+  detectRuntime(deps, devDeps) {
+    if (deps.next || devDeps.next) return "Node.js (Next.js)";
+    if (Object.keys(deps).some((d) => d.includes("react"))) {
+      return "Browser + Node.js";
     }
-    version = versionInput;
+    return "Node.js";
   }
-  let category = options.category;
-  if (patternType === "fix" && !category) {
-    const catChoice = await p7.select({
-      message: "Category:",
-      options: [
-        { value: "migration", label: "\u{1F504} Migration" },
-        { value: "security", label: "\u{1F512} Security" },
-        { value: "performance", label: "\u26A1 Performance" },
-        { value: "compatibility", label: "\u{1F517} Compatibility" },
-        { value: "deprecation", label: "\u26A0\uFE0F Deprecation" },
-        { value: "configuration", label: "\u2699\uFE0F Configuration" },
-        { value: "best-practice", label: "\u2728 Best Practice" },
-        { value: "error-handling", label: "\u{1F6A8} Error Handling" },
-        { value: "testing", label: "\u{1F9EA} Testing" },
-        { value: "other", label: "\u{1F4E6} Other" }
-      ]
-    });
-    if (p7.isCancel(catChoice)) {
-      p7.cancel("Recording cancelled");
-      process.exit(0);
+  detectBuildTools(devDeps) {
+    const tools = [];
+    if (devDeps.vite) tools.push("Vite");
+    if (devDeps.webpack) tools.push("Webpack");
+    if (devDeps.rollup) tools.push("Rollup");
+    if (devDeps.esbuild) tools.push("esbuild");
+    if (devDeps.turbo || devDeps.turborepo) tools.push("Turborepo");
+    if (devDeps.tsup) tools.push("tsup");
+    return tools;
+  }
+  detectPlatforms(deps) {
+    const platforms = [];
+    if (deps.react || deps.next) platforms.push("Web");
+    if (deps["react-native"]) platforms.push("Mobile (React Native)");
+    if (deps.electron) platforms.push("Desktop (Electron)");
+    return platforms.length > 0 ? platforms : ["Web"];
+  }
+  detectInfrastructure(deps, devDeps) {
+    const infra = [];
+    const allDeps = { ...deps, ...devDeps };
+    if (allDeps.vercel || allDeps["@vercel/node"]) infra.push("Vercel");
+    if (Object.keys(allDeps).some((d) => d.includes("aws-"))) {
+      infra.push("AWS");
     }
-    category = catChoice;
+    if (Object.keys(allDeps).some((d) => d.includes("@google-cloud"))) {
+      infra.push("Google Cloud");
+    }
+    if (allDeps.netlify) infra.push("Netlify");
+    if (allDeps.supabase || allDeps["@supabase/supabase-js"]) {
+      infra.push("Supabase");
+    }
+    if (allDeps.firebase || allDeps["firebase-admin"]) infra.push("Firebase");
+    return infra;
   }
-  const tags = [];
-  if (options.tags) {
-    const tagPairs = options.tags.split(",").map((t) => t.trim());
-    for (const pair of tagPairs) {
-      const [cat, val] = pair.split(":");
-      if (cat && val) {
-        tags.push({
-          category: cat,
-          name: val
-        });
-      }
+  calculateExecutiveRisks(project, categories) {
+    const risks = [];
+    let overallScore = 0;
+    if (project.fileCount > 1e3) {
+      risks.push(
+        "Large codebase may require significant maintenance resources"
+      );
+      overallScore += 0.3;
+    }
+    if (categories.length > 15) {
+      risks.push(
+        "High number of technology categories indicates potential complexity"
+      );
+      overallScore += 0.2;
     }
+    const totalPackages = categories.reduce((sum, cat) => sum + cat.count, 0);
+    if (totalPackages > 100) {
+      risks.push(
+        "Large dependency footprint increases security and maintenance burden"
+      );
+      overallScore += 0.3;
+    }
+    overallScore = Math.min(overallScore, 1);
+    return {
+      overall: overallScore,
+      categories: [
+        {
+          name: "Technical Complexity",
+          score: overallScore,
+          issues: risks,
+          impact: "May affect development velocity and operational costs"
+        }
+      ],
+      critical: [],
+      high: overallScore > 0.7 ? risks : [],
+      medium: overallScore > 0.4 && overallScore <= 0.7 ? risks : [],
+      low: overallScore <= 0.4 ? risks : []
+    };
   }
-  tags.push({ category: "framework", name: framework });
-  if (patternType === "fix") {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const fixPattern = {
-      id: crypto.randomUUID(),
-      name,
-      description,
-      category,
-      tags,
-      trigger: {
-        errorPattern: ".*",
-        errorMessage: "Generic error pattern",
-        filePattern: "**/*"
-      },
-      solution: {
-        type: "command",
-        steps: [
-          {
-            order: 1,
-            action: "run",
-            target: "npm run fix",
-            description: "Follow the pattern instructions"
-          }
-        ]
-      },
-      compatibility: {
-        framework,
-        frameworkVersion: version,
-        runtime: "node",
-        runtimeVersion: ">=18.0.0",
-        dependencies: []
-      },
-      metrics: {
-        applications: 0,
-        successes: 0,
-        failures: 0,
-        successRate: 0
-      },
-      source: "manual",
-      isPrivate: true,
-      createdAt: now,
-      updatedAt: now
+  calculateExecutiveOpportunities(_project, categories) {
+    const opportunities = [];
+    let overallScore = 0.5;
+    const hasModernFramework = categories.some(
+      (cat) => cat.name.includes("Meta-Framework")
+    );
+    if (hasModernFramework) {
+      opportunities.push(
+        "Modern framework provides foundation for rapid feature development"
+      );
+      overallScore += 0.2;
+    }
+    const hasTestingTools = categories.some((cat) => cat.name === "Testing");
+    if (hasTestingTools) {
+      opportunities.push(
+        "Testing infrastructure enables quality-driven expansion"
+      );
+      overallScore += 0.1;
+    }
+    return {
+      overall: Math.min(overallScore, 1),
+      categories: [
+        {
+          name: "Growth Potential",
+          potential: overallScore,
+          recommendations: opportunities,
+          businessValue: "Strong foundation for scaling features and market reach"
+        }
+      ],
+      immediate: [],
+      shortTerm: opportunities,
+      longTerm: []
     };
-    const result = await store.saveFixPattern(fixPattern);
-    if (result.success) {
-      console.log(chalk11.green("\n\u2705 Fix pattern recorded successfully!\n"));
-      console.log(chalk11.dim(`  ID: ${fixPattern.id}`));
-      console.log(chalk11.dim(`  Name: ${name}`));
-      console.log(chalk11.dim(`  Category: ${category}`));
-      console.log(chalk11.dim(`  Framework: ${framework} ${version}`));
-    } else {
-      console.log(chalk11.red("\n\u274C Failed to record pattern"));
-      console.log(chalk11.dim(`  Error: ${result.error}`));
-      process.exit(1);
+  }
+  assessDependencyRisk(packages) {
+    let score = 0;
+    const issues = [];
+    if (packages.total > 100) {
+      score += 0.3;
+      issues.push(`High dependency count (${packages.total} packages)`);
     }
-  } else {
+    if (packages.outdated.length > 10) {
+      score += 0.3;
+      issues.push(`${packages.outdated.length} outdated packages`);
+    }
+    if (packages.security.length > 0) {
+      score += 0.4;
+      issues.push(`${packages.security.length} security vulnerabilities`);
+    }
+    return {
+      name: "Dependency Management",
+      score: Math.min(score, 1),
+      issues,
+      impact: "Affects security, stability, and maintenance costs"
+    };
+  }
+  assessTechnologyRisk(technology) {
+    let score = 0;
+    const issues = [];
+    const legacyFrameworks = ["angular.js", "backbone", "ember"];
+    if (technology.framework && legacyFrameworks.some((f) => technology.framework?.includes(f))) {
+      score += 0.5;
+      issues.push("Legacy framework may limit future development");
+    }
+    return {
+      name: "Technology Stack",
+      score,
+      issues,
+      impact: "May affect ability to attract talent and adopt new features"
+    };
+  }
+  assessComplexityRisk(project) {
+    let score = 0;
+    const issues = [];
+    if (project.fileCount > 1e3) {
+      score += 0.2;
+      issues.push("Large codebase requires careful management");
+    }
+    if (project.isMonorepo && (project.workspaceCount || 0) > 10) {
+      score += 0.2;
+      issues.push("Complex monorepo structure");
+    }
+    return {
+      name: "Project Complexity",
+      score,
+      issues,
+      impact: "Affects onboarding time and development velocity"
+    };
+  }
+  assessModernizationOpportunities(_technology, packages) {
+    const recommendations = [];
+    let potential = 0.5;
+    if (packages.outdated.length > 0) {
+      recommendations.push(
+        "Upgrade dependencies to access new features and improvements"
+      );
+      potential += 0.2;
+    }
+    return {
+      name: "Modernization",
+      potential: Math.min(potential, 1),
+      recommendations,
+      businessValue: "Improved performance, security, and developer experience"
+    };
+  }
+  assessOptimizationOpportunities(project) {
+    const recommendations = [];
+    if (project.fileCount > 500) {
+      recommendations.push(
+        "Consider code splitting and lazy loading strategies"
+      );
+    }
+    return {
+      name: "Performance Optimization",
+      potential: 0.6,
+      recommendations,
+      businessValue: "Faster load times and better user experience"
+    };
+  }
+  assessGrowthOpportunities(_technology, packages) {
+    const recommendations = [];
+    let potential = 0.5;
+    const hasAnalytics = packages.categories.some(
+      (cat) => cat.name.includes("Analytics")
+    );
+    if (!hasAnalytics) {
+      recommendations.push("Add analytics to enable data-driven decisions");
+      potential += 0.2;
+    }
+    return {
+      name: "Growth & Expansion",
+      potential: Math.min(potential, 1),
+      recommendations,
+      businessValue: "Data-driven growth and improved user insights"
+    };
+  }
+  categorizeRiskItems(risk, critical, high, medium, low) {
+    if (risk.score > 0.7) {
+      critical.push(...risk.issues);
+    } else if (risk.score > 0.5) {
+      high.push(...risk.issues);
+    } else if (risk.score > 0.3) {
+      medium.push(...risk.issues);
+    } else {
+      low.push(...risk.issues);
+    }
+  }
+  categorizeOpportunityItems(opportunity, immediate, shortTerm, longTerm) {
+    if (opportunity.potential > 0.7) {
+      immediate.push(...opportunity.recommendations);
+    } else if (opportunity.potential > 0.5) {
+      shortTerm.push(...opportunity.recommendations);
+    } else {
+      longTerm.push(...opportunity.recommendations);
+    }
+  }
+  async getProjectFiles() {
+    const patterns = ["**/*.{ts,tsx,js,jsx}"];
+    return await fg(patterns, {
+      cwd: this.options.cwd,
+      ignore: this.options.excludePatterns || [
+        "node_modules/**",
+        "dist/**",
+        "build/**",
+        ".next/**",
+        "coverage/**"
+      ]
+    });
+  }
+  detectEntryPoints(files) {
+    const entryPoints = files.filter(
+      (f) => f.includes("index.") || f.includes("main.") || f.includes("app.") || f.includes("_app.") || f.includes("layout.")
+    );
+    return entryPoints.slice(0, 5);
+  }
+  detectArchitecturePattern(files) {
+    const hasComponents = files.some((f) => f.includes("components/"));
+    const hasPages = files.some(
+      (f) => f.includes("pages/") || f.includes("app/")
+    );
+    const hasServices = files.some((f) => f.includes("services/"));
+    if (hasComponents && hasPages && hasServices) {
+      return "Layered Architecture (Pages \u2192 Components \u2192 Services)";
+    }
+    if (hasComponents && hasPages) {
+      return "Component-Based Architecture";
+    }
+    return "Standard Application Structure";
+  }
+  detectLayers(files) {
+    const layers = [];
+    if (files.some((f) => f.includes("pages/") || f.includes("app/"))) {
+      layers.push("Presentation (Pages/Routes)");
+    }
+    if (files.some((f) => f.includes("components/"))) {
+      layers.push("UI Components");
+    }
+    if (files.some((f) => f.includes("services/") || f.includes("api/"))) {
+      layers.push("Business Logic/Services");
+    }
+    if (files.some((f) => f.includes("lib/") || f.includes("utils/"))) {
+      layers.push("Utilities/Helpers");
+    }
+    if (files.some((f) => f.includes("models/") || f.includes("types/"))) {
+      layers.push("Data Models");
+    }
+    return layers;
+  }
+  analyzeDataFlow(files) {
+    const hasStateManagement = files.some(
+      (f) => f.includes("store") || f.includes("context")
+    );
+    const hasApi = files.some(
+      (f) => f.includes("api") || f.includes("services")
+    );
+    if (hasStateManagement && hasApi) {
+      return "API \u2192 Services \u2192 State Management \u2192 Components";
+    }
+    if (hasApi) {
+      return "API \u2192 Components (Direct)";
+    }
+    return "Props-based Component Communication";
+  }
+  extractKeyDecisions(files) {
+    const decisions = [];
+    if (files.some((f) => f.includes(".ts") || f.includes(".tsx"))) {
+      decisions.push("TypeScript for type safety");
+    }
+    if (files.some((f) => f.includes("app/") && !f.includes("pages/"))) {
+      decisions.push("App Router architecture (Next.js)");
+    }
+    if (files.some((f) => f.includes("server") || f.includes("api"))) {
+      decisions.push("API routes for backend functionality");
+    }
+    return decisions;
+  }
+  async analyzeComponents(files) {
+    const components = files.filter((f) => f.includes("components/"));
+    const patterns = [];
+    const ui = components.filter(
+      (f) => f.includes("/ui/") || f.includes("/common/")
+    );
+    const feature = components.filter(
+      (f) => ["features/", "modules/"].some((dir) => f.includes(dir))
+    );
+    if (ui.length > 0) {
+      patterns.push({
+        type: "UI Components",
+        count: ui.length,
+        examples: ui.slice(0, 3),
+        conventions: ["Reusable", "Presentation-focused"]
+      });
+    }
+    if (feature.length > 0) {
+      patterns.push({
+        type: "Feature Components",
+        count: feature.length,
+        examples: feature.slice(0, 3),
+        conventions: ["Business logic", "Domain-specific"]
+      });
+    }
+    return patterns;
+  }
+  async analyzeServices(files) {
+    const services = files.filter(
+      (f) => f.includes("services/") || f.includes("api/")
+    );
+    return services.slice(0, 5).map((file) => ({
+      name: file,
+      purpose: "API integration or business logic",
+      integrations: []
+    }));
+  }
+  async analyzeUtilities(files) {
+    const utils = files.filter(
+      (f) => f.includes("utils/") || f.includes("lib/")
+    );
+    return [
+      {
+        category: "Utilities",
+        count: utils.length,
+        usage: "Helper functions and shared utilities"
+      }
+    ];
+  }
+  async analyzeTests(files) {
+    const tests = files.filter(
+      (f) => f.includes(".test.") || f.includes(".spec.")
+    );
+    const hasVitest = tests.some((f) => f.includes("vitest"));
+    const hasJest = tests.some((f) => f.includes("jest"));
+    return {
+      framework: hasVitest ? "Vitest" : hasJest ? "Jest" : "Unknown",
+      count: tests.length,
+      types: ["Unit tests"]
+    };
+  }
+  async detectCustomPatterns(files) {
+    const patterns = [];
+    if (files.some((f) => f.includes("hooks/"))) {
+      patterns.push("Custom React Hooks");
+    }
+    if (files.some((f) => f.includes("middleware"))) {
+      patterns.push("Middleware Pattern");
+    }
+    if (files.some((f) => f.includes("providers"))) {
+      patterns.push("Context Providers");
+    }
+    return patterns;
+  }
+};
+
+// src/utils/question-generator.ts
+var QuestionGenerator = class {
+  analysis;
+  config;
+  constructor(analysis, config) {
+    this.analysis = analysis;
+    this.config = config;
+  }
+  /**
+   * Generate all advisory board questions
+   */
+  generate() {
+    const questions = [];
+    questions.push(...this.generateTechnologyQuestions());
+    questions.push(...this.generatePackageQuestions());
+    questions.push(...this.generatePlatformQuestions());
+    questions.push(...this.generateBusinessQuestions());
+    questions.push(...this.generateTechnicalDebtQuestions());
+    questions.push(...this.generateGrowthQuestions());
+    if (this.config?.customQuestions) {
+      questions.push(
+        ...this.formatCustomQuestions(this.config.customQuestions)
+      );
+    }
+    const sorted = this.sortByPriority(questions);
+    return {
+      questions: sorted,
+      summary: this.generateSummary(sorted)
+    };
+  }
+  /**
+   * Technology Decisions questions
+   */
+  generateTechnologyQuestions() {
+    const questions = [];
+    const { technology, project } = this.analysis;
+    if (technology.framework) {
+      questions.push({
+        category: "Technology Decisions",
+        question: `Why was ${technology.framework} chosen as the primary framework, and does it still align with our strategic goals?`,
+        context: `Project uses ${technology.framework}${technology.frameworkVersion ? ` v${technology.frameworkVersion}` : ""} as the foundation`,
+        findings: [
+          `Framework: ${technology.framework}`,
+          `Language: ${technology.language}`,
+          `Runtime: ${technology.runtime}`
+        ],
+        recommendations: [
+          "Validate framework continues to meet performance and scalability needs",
+          "Assess community support and long-term viability",
+          "Consider migration costs vs. benefits if alternatives exist"
+        ],
+        priority: "high",
+        businessImpact: "Framework choice affects development velocity, talent acquisition, and long-term maintenance costs"
+      });
+    }
+    if (technology.buildTools && technology.buildTools.length > 0) {
+      questions.push({
+        category: "Technology Decisions",
+        question: `How are our build tools (${technology.buildTools.join(", ")}) optimizing development workflow and deployment efficiency?`,
+        context: `Build pipeline uses ${technology.buildTools.join(", ")}`,
+        findings: technology.buildTools.map(
+          (tool) => `Using ${tool} for build process`
+        ),
+        recommendations: [
+          "Measure build time impacts on CI/CD pipeline",
+          "Evaluate if modern alternatives could improve developer experience",
+          "Consider caching strategies to optimize build performance"
+        ],
+        priority: "medium",
+        businessImpact: "Build efficiency directly impacts time-to-market for new features"
+      });
+    }
+    if (project.isMonorepo) {
+      questions.push({
+        category: "Technology Decisions",
+        question: `Is the monorepo structure providing expected benefits in code sharing and deployment coordination?`,
+        context: `Project uses monorepo with ${project.workspaceCount || "multiple"} workspaces`,
+        findings: [
+          `Monorepo with ${project.workspaceCount} packages`,
+          `Total ${project.fileCount} files managed`
+        ],
+        recommendations: [
+          "Assess if shared code is properly abstracted and reused",
+          "Evaluate build caching and selective deployment strategies",
+          "Consider workspace organization for scaling"
+        ],
+        priority: "medium",
+        businessImpact: "Monorepo architecture affects team collaboration and deployment complexity"
+      });
+    }
+    return questions;
+  }
+  /**
+   * Package Utilization questions
+   */
+  generatePackageQuestions() {
+    const questions = [];
+    const { packages } = this.analysis;
+    if (packages.total > 80) {
+      questions.push({
+        category: "Package Utilization",
+        question: `With ${packages.total} dependencies, are we maintaining optimal balance between functionality and maintenance burden?`,
+        context: `Project has ${packages.production.length} production and ${packages.development.length} development dependencies`,
+        findings: [
+          `Total packages: ${packages.total}`,
+          `Production: ${packages.production.length}`,
+          `Development: ${packages.development.length}`
+        ],
+        recommendations: [
+          "Audit for unused or redundant packages",
+          "Evaluate if critical functionality should be internalized",
+          "Implement dependency update strategy"
+        ],
+        priority: packages.total > 150 ? "high" : "medium",
+        businessImpact: "Dependency count affects security surface area and maintenance costs"
+      });
+    }
+    if (packages.categories.length > 0) {
+      const topCategories = packages.categories.sort((a, b) => b.count - a.count).slice(0, 3);
+      topCategories.forEach((cat) => {
+        if (cat.count > 5) {
+          questions.push({
+            category: "Package Utilization",
+            question: `How are we leveraging our ${cat.count} ${cat.name} packages to deliver business value?`,
+            context: `${cat.name}: ${cat.packages.slice(0, 3).join(", ")}${cat.count > 3 ? `, +${cat.count - 3} more` : ""}`,
+            findings: [
+              `${cat.count} packages in ${cat.name} category`,
+              cat.businessImpact
+            ],
+            recommendations: this.getCategoryRecommendations(cat),
+            priority: this.getCategoryPriority(cat),
+            businessImpact: cat.businessImpact
+          });
+        }
+      });
+    }
+    if (packages.security && packages.security.length > 0) {
+      const criticalCount = packages.security.filter(
+        (s) => s.severity === "critical"
+      ).length;
+      questions.push({
+        category: "Package Utilization",
+        question: `What is our strategy for addressing ${packages.security.length} identified security vulnerabilities${criticalCount > 0 ? ` (${criticalCount} critical)` : ""}?`,
+        context: "Security audit identified vulnerabilities in dependencies",
+        findings: packages.security.map(
+          (s) => `${s.package}: ${s.severity} - ${s.issue}`
+        ),
+        recommendations: packages.security.map((s) => s.recommendation),
+        priority: criticalCount > 0 ? "high" : "medium",
+        businessImpact: "Security vulnerabilities pose risk to customer data and business operations"
+      });
+    }
+    return questions;
+  }
+  /**
+   * Platform Strategy questions
+   */
+  generatePlatformQuestions() {
+    const questions = [];
+    const { technology } = this.analysis;
+    if (technology.platforms && technology.platforms.length > 0) {
+      questions.push({
+        category: "Platform Strategy",
+        question: `Are our platform choices (${technology.platforms.join(", ")}) aligned with target market and growth plans?`,
+        context: `Currently deployed on ${technology.platforms.join(" + ")}`,
+        findings: technology.platforms.map((p10) => `Supports ${p10} platform`),
+        recommendations: [
+          "Validate platform coverage matches user demographics",
+          "Assess cross-platform development efficiency",
+          "Consider platform-specific optimization opportunities"
+        ],
+        priority: "medium",
+        businessImpact: "Platform strategy determines market reach and development costs"
+      });
+    }
+    if (technology.infrastructure && technology.infrastructure.length > 0) {
+      questions.push({
+        category: "Platform Strategy",
+        question: `How is our infrastructure choice (${technology.infrastructure.join(", ")}) supporting scalability and cost efficiency?`,
+        context: `Infrastructure: ${technology.infrastructure.join(", ")}`,
+        findings: technology.infrastructure.map((i) => `Deployed on ${i}`),
+        recommendations: [
+          "Monitor infrastructure costs vs. usage patterns",
+          "Evaluate auto-scaling and redundancy capabilities",
+          "Consider multi-region deployment for global users"
+        ],
+        priority: "high",
+        businessImpact: "Infrastructure directly impacts operational costs, uptime, and scalability"
+      });
+    }
+    return questions;
+  }
+  /**
+   * Business Alignment questions
+   */
+  generateBusinessQuestions() {
+    const questions = [];
+    const { packages } = this.analysis;
+    const hasAnalytics = packages.categories.some(
+      (cat) => cat.name.toLowerCase().includes("analytics")
+    );
+    if (!hasAnalytics) {
+      questions.push({
+        category: "Business Alignment",
+        question: "Why don't we have analytics infrastructure, and how are we making data-driven product decisions?",
+        context: "No analytics packages detected in the project",
+        findings: ["Missing analytics implementation"],
+        recommendations: [
+          "Implement analytics to track user behavior and feature adoption",
+          "Set up conversion funnels and key metric tracking",
+          "Enable A/B testing capabilities for product experiments"
+        ],
+        priority: "high",
+        businessImpact: "Lack of analytics limits ability to measure ROI and optimize user experience"
+      });
+    }
+    const hasAuth = packages.categories.some(
+      (cat) => cat.name.toLowerCase().includes("auth")
+    );
+    if (hasAuth) {
+      const authCat = packages.categories.find(
+        (cat) => cat.name.toLowerCase().includes("auth")
+      );
+      questions.push({
+        category: "Business Alignment",
+        question: `How is our authentication solution (${authCat.packages.join(", ")}) supporting user onboarding and security requirements?`,
+        context: `Using ${authCat.packages.join(" + ")} for authentication`,
+        findings: authCat.packages.map((p10) => `Auth provider: ${p10}`),
+        recommendations: [
+          "Measure authentication success rates and friction points",
+          "Ensure compliance with security standards (SOC2, GDPR, etc.)",
+          "Evaluate social login options to reduce signup friction"
+        ],
+        priority: "high",
+        businessImpact: "Authentication affects conversion rates and security posture"
+      });
+    }
+    const hasTestingtools = packages.categories.some(
+      (cat) => cat.name.toLowerCase().includes("testing")
+    );
+    if (hasTestingtools) {
+      questions.push({
+        category: "Business Alignment",
+        question: "How is our testing strategy contributing to product quality and customer satisfaction?",
+        context: "Testing infrastructure is in place",
+        findings: ["Testing tools available"],
+        recommendations: [
+          "Set coverage targets aligned with quality goals",
+          "Implement testing in CI/CD for every release",
+          "Track bugs-in-production as quality metric"
+        ],
+        priority: "medium",
+        businessImpact: "Quality assurance directly affects customer satisfaction and support costs"
+      });
+    }
+    return questions;
+  }
+  /**
+   * Technical Debt questions
+   */
+  generateTechnicalDebtQuestions() {
+    const questions = [];
+    const { risks, packages } = this.analysis;
+    if (risks.high && risks.high.length > 0) {
+      questions.push({
+        category: "Technical Debt",
+        question: `What is our strategy for addressing ${risks.high.length} high-priority technical risks?`,
+        context: "Analysis identified significant technical risks",
+        findings: risks.high,
+        recommendations: [
+          "Prioritize risks by business impact",
+          "Allocate dedicated time for technical debt in sprints",
+          "Track debt reduction as OKR/KPI"
+        ],
+        priority: "high",
+        businessImpact: "Unaddressed technical debt slows feature velocity and increases costs"
+      });
+    }
+    if (packages.outdated && packages.outdated.length > 10) {
+      const breakingCount = packages.outdated.filter((p10) => p10.breaking).length;
+      questions.push({
+        category: "Technical Debt",
+        question: `How should we prioritize updating ${packages.outdated.length} outdated packages${breakingCount > 0 ? ` (${breakingCount} with breaking changes)` : ""}?`,
+        context: "Dependency audit found outdated packages",
+        findings: packages.outdated.slice(0, 5).map((p10) => `${p10.name}: ${p10.current} \u2192 ${p10.latest}`),
+        recommendations: [
+          "Create update roadmap starting with non-breaking changes",
+          "Test breaking changes in feature branches",
+          "Consider automated dependency updates (Dependabot, Renovate)"
+        ],
+        priority: breakingCount > 5 ? "high" : "medium",
+        businessImpact: "Outdated dependencies miss performance improvements and security patches"
+      });
+    }
+    const complexityRisk = risks.categories.find(
+      (c) => c.name.includes("Complexity")
+    );
+    if (complexityRisk && complexityRisk.score > 0.5) {
+      questions.push({
+        category: "Technical Debt",
+        question: "How are we managing codebase complexity to maintain development velocity?",
+        context: `Complexity score: ${(complexityRisk.score * 100).toFixed(0)}%`,
+        findings: complexityRisk.issues,
+        recommendations: [
+          "Implement code quality metrics and monitoring",
+          "Establish refactoring goals for each sprint",
+          "Consider modularization strategies"
+        ],
+        priority: complexityRisk.score > 0.7 ? "high" : "medium",
+        businessImpact: "High complexity slows new feature development and increases bugs"
+      });
+    }
+    return questions;
+  }
+  /**
+   * Growth Opportunities questions
+   */
+  generateGrowthQuestions() {
+    const questions = [];
+    const { opportunities } = this.analysis;
+    if (opportunities.immediate && opportunities.immediate.length > 0) {
+      questions.push({
+        category: "Growth Opportunities",
+        question: "Which immediate technical opportunities should we prioritize for maximum business impact?",
+        context: `${opportunities.immediate.length} immediate opportunities identified`,
+        findings: opportunities.immediate,
+        recommendations: [
+          "Evaluate ROI and effort for each opportunity",
+          "Align opportunities with business OKRs",
+          "Quick wins can build momentum for larger initiatives"
+        ],
+        priority: "high",
+        businessImpact: "Immediate opportunities can deliver quick ROI with minimal investment"
+      });
+    }
+    opportunities.categories.forEach((cat) => {
+      if (cat.potential > 0.6) {
+        questions.push({
+          category: "Growth Opportunities",
+          question: `How can we capitalize on ${cat.name.toLowerCase()} opportunities to drive business growth?`,
+          context: `Potential score: ${(cat.potential * 100).toFixed(0)}%`,
+          findings: cat.recommendations,
+          recommendations: [
+            "Develop roadmap for implementing recommendations",
+            "Assign owners and timelines",
+            "Define success metrics"
+          ],
+          priority: cat.potential > 0.8 ? "high" : "medium",
+          businessImpact: cat.businessValue
+        });
+      }
+    });
+    return questions;
+  }
+  /**
+   * Format custom questions from config
+   */
+  formatCustomQuestions(customQuestions) {
+    return customQuestions.map((q) => ({
+      category: q.category,
+      question: q.question,
+      context: q.context || "Custom advisory question",
+      findings: [],
+      recommendations: [],
+      priority: q.priority || "medium",
+      businessImpact: "Custom question defined by organization"
+    }));
+  }
+  /**
+   * Sort questions by priority
+   */
+  sortByPriority(questions) {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return questions.sort(
+      (a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]
+    );
+  }
+  /**
+   * Generate summary of questions
+   */
+  generateSummary(questions) {
+    const categories = Array.from(new Set(questions.map((q) => q.category)));
+    return {
+      totalQuestions: questions.length,
+      highPriority: questions.filter((q) => q.priority === "high").length,
+      mediumPriority: questions.filter((q) => q.priority === "medium").length,
+      lowPriority: questions.filter((q) => q.priority === "low").length,
+      categories
+    };
+  }
+  /**
+   * Get recommendations for a package category
+   */
+  getCategoryRecommendations(cat) {
+    const recommendations = [];
+    if (cat.name.includes("UI") || cat.name.includes("Styling")) {
+      recommendations.push(
+        "Ensure design system consistency across components"
+      );
+      recommendations.push("Consider component library optimization");
+    } else if (cat.name.includes("API") || cat.name.includes("Data")) {
+      recommendations.push("Implement proper error handling and retry logic");
+      recommendations.push("Consider caching strategies for performance");
+    } else if (cat.name.includes("Testing")) {
+      recommendations.push("Increase test coverage for critical paths");
+      recommendations.push("Automate testing in CI/CD pipeline");
+    } else if (cat.name.includes("Database") || cat.name.includes("ORM")) {
+      recommendations.push("Optimize queries and indexes");
+      recommendations.push("Implement database migration strategy");
+    }
+    if (recommendations.length === 0) {
+      recommendations.push("Review usage patterns for optimization");
+      recommendations.push("Consider if functionality meets current needs");
+    }
+    return recommendations;
+  }
+  /**
+   * Get priority for a package category
+   */
+  getCategoryPriority(cat) {
+    if (["Authentication", "Database", "Infrastructure", "API"].some(
+      (key) => cat.name.includes(key)
+    )) {
+      return "high";
+    }
+    if (["UI", "Testing", "State Management", "Forms"].some(
+      (key) => cat.name.includes(key)
+    )) {
+      return "medium";
+    }
+    return "low";
+  }
+};
+
+// src/utils/report-comparator.ts
+var ReportComparator = class {
+  baseline;
+  current;
+  constructor(baseline, current) {
+    this.baseline = baseline;
+    this.current = current;
+  }
+  /**
+   * Compare two reports and generate diff
+   */
+  compare() {
+    const baselineSummary = this.extractSummary(this.baseline);
+    const currentSummary = this.extractSummary(this.current);
+    const changes = this.calculateChanges(baselineSummary, currentSummary);
+    const details = this.analyzeDetailedChanges();
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      baseline: baselineSummary,
+      current: currentSummary,
+      changes,
+      details
+    };
+  }
+  /**
+   * Extract summary from analysis
+   */
+  extractSummary(analysis) {
+    return {
+      timestamp: analysis.timestamp,
+      depth: analysis.depth,
+      projectName: analysis.project.name,
+      overallRiskScore: analysis.risks.overall,
+      overallOpportunityScore: analysis.opportunities.overall,
+      packageCount: analysis.packages.total
+    };
+  }
+  /**
+   * Calculate high-level changes
+   */
+  calculateChanges(baseline, current) {
+    const riskScoreChange = current.overallRiskScore - baseline.overallRiskScore;
+    const opportunityScoreChange = current.overallOpportunityScore - baseline.overallOpportunityScore;
+    const packageCountChange = current.packageCount - baseline.packageCount;
+    const baselineHighRisks = new Set(this.baseline.risks.high);
+    const currentHighRisks = new Set(this.current.risks.high);
+    const newHighRisks = Array.from(currentHighRisks).filter(
+      (risk) => !baselineHighRisks.has(risk)
+    ).length;
+    const resolvedHighRisks = Array.from(baselineHighRisks).filter(
+      (risk) => !currentHighRisks.has(risk)
+    ).length;
+    const baselineImmediate = new Set(this.baseline.opportunities.immediate);
+    const currentImmediate = new Set(this.current.opportunities.immediate);
+    const newOpportunities = Array.from(currentImmediate).filter(
+      (opp) => !baselineImmediate.has(opp)
+    ).length;
+    return {
+      riskScoreChange,
+      opportunityScoreChange,
+      packageCountChange,
+      newHighRisks,
+      resolvedHighRisks,
+      newOpportunities
+    };
+  }
+  /**
+   * Analyze detailed changes
+   */
+  analyzeDetailedChanges() {
+    return {
+      risks: this.compareRisks(),
+      opportunities: this.compareOpportunities(),
+      packages: this.comparePackages(),
+      technology: this.compareTechnology()
+    };
+  }
+  /**
+   * Compare risks between reports
+   */
+  compareRisks() {
+    const baselineRisks = /* @__PURE__ */ new Set([
+      ...this.baseline.risks.critical,
+      ...this.baseline.risks.high,
+      ...this.baseline.risks.medium
+    ]);
+    const currentRisks = /* @__PURE__ */ new Set([
+      ...this.current.risks.critical,
+      ...this.current.risks.high,
+      ...this.current.risks.medium
+    ]);
+    const newRisks = Array.from(currentRisks).filter(
+      (risk) => !baselineRisks.has(risk)
+    );
+    const resolved = Array.from(baselineRisks).filter(
+      (risk) => !currentRisks.has(risk)
+    );
+    const changed = [];
+    const baselineCatMap = new Map(
+      this.baseline.risks.categories.map((c) => [c.name, c])
+    );
+    const currentCatMap = new Map(
+      this.current.risks.categories.map((c) => [c.name, c])
+    );
+    for (const [name, current] of currentCatMap) {
+      const baseline = baselineCatMap.get(name);
+      if (baseline && Math.abs(current.score - baseline.score) > 0.05) {
+        changed.push({
+          category: name,
+          before: baseline.score,
+          after: current.score,
+          change: current.score - baseline.score
+        });
+      }
+    }
+    return { new: newRisks, resolved, changed };
+  }
+  /**
+   * Compare opportunities between reports
+   */
+  compareOpportunities() {
+    const baselineOpps = /* @__PURE__ */ new Set([
+      ...this.baseline.opportunities.immediate,
+      ...this.baseline.opportunities.shortTerm
+    ]);
+    const currentOpps = /* @__PURE__ */ new Set([
+      ...this.current.opportunities.immediate,
+      ...this.current.opportunities.shortTerm
+    ]);
+    const newOpps = Array.from(currentOpps).filter(
+      (opp) => !baselineOpps.has(opp)
+    );
+    const completed = Array.from(baselineOpps).filter(
+      (opp) => !currentOpps.has(opp)
+    );
+    const changed = [];
+    const baselineCatMap = new Map(
+      this.baseline.opportunities.categories.map((c) => [c.name, c])
+    );
+    const currentCatMap = new Map(
+      this.current.opportunities.categories.map((c) => [c.name, c])
+    );
+    for (const [name, current] of currentCatMap) {
+      const baseline = baselineCatMap.get(name);
+      if (baseline && Math.abs(current.potential - baseline.potential) > 0.05) {
+        changed.push({
+          category: name,
+          before: baseline.potential,
+          after: current.potential,
+          change: current.potential - baseline.potential
+        });
+      }
+    }
+    return { new: newOpps, completed, changed };
+  }
+  /**
+   * Compare packages between reports
+   */
+  comparePackages() {
+    const baselineProduction = new Map(
+      this.baseline.packages.production.map((p10) => [p10.name, p10])
+    );
+    const currentProduction = new Map(
+      this.current.packages.production.map((p10) => [p10.name, p10])
+    );
+    const added = [];
+    const removed = [];
+    const updated = [];
+    for (const [name, pkg] of currentProduction) {
+      if (!baselineProduction.has(name)) {
+        added.push({
+          name,
+          version: pkg.version,
+          category: pkg.category
+        });
+      }
+    }
+    for (const [name, baselinePkg] of baselineProduction) {
+      const currentPkg = currentProduction.get(name);
+      if (!currentPkg) {
+        removed.push({
+          name,
+          version: baselinePkg.version,
+          category: baselinePkg.category
+        });
+      } else if (baselinePkg.version !== currentPkg.version) {
+        updated.push({
+          name,
+          version: currentPkg.version,
+          previousVersion: baselinePkg.version,
+          category: currentPkg.category
+        });
+      }
+    }
+    const baselineDev = new Map(
+      this.baseline.packages.development.map((p10) => [p10.name, p10])
+    );
+    const currentDev = new Map(
+      this.current.packages.development.map((p10) => [p10.name, p10])
+    );
+    for (const [name, pkg] of currentDev) {
+      if (!baselineDev.has(name)) {
+        added.push({
+          name,
+          version: pkg.version,
+          category: pkg.category
+        });
+      }
+    }
+    for (const [name, baselinePkg] of baselineDev) {
+      const currentPkg = currentDev.get(name);
+      if (!currentPkg) {
+        removed.push({
+          name,
+          version: baselinePkg.version,
+          category: baselinePkg.category
+        });
+      } else if (baselinePkg.version !== currentPkg.version) {
+        updated.push({
+          name,
+          version: currentPkg.version,
+          previousVersion: baselinePkg.version,
+          category: currentPkg.category
+        });
+      }
+    }
+    return { added, removed, updated };
+  }
+  /**
+   * Compare technology stack between reports
+   */
+  compareTechnology() {
+    const baselineTech = this.baseline.technology;
+    const currentTech = this.current.technology;
+    const frameworkChanged = baselineTech.framework !== currentTech.framework || baselineTech.frameworkVersion !== currentTech.frameworkVersion;
+    const baselineTools = new Set(baselineTech.buildTools);
+    const currentTools = new Set(currentTech.buildTools);
+    const newBuildTools = currentTech.buildTools.filter(
+      (tool) => !baselineTools.has(tool)
+    );
+    const removedTools = baselineTech.buildTools.filter(
+      (tool) => !currentTools.has(tool)
+    );
+    const baselineInfra = new Set(baselineTech.infrastructure);
+    const newInfrastructure = currentTech.infrastructure.filter(
+      (infra) => !baselineInfra.has(infra)
+    );
+    return {
+      frameworkChanged,
+      newBuildTools,
+      newInfrastructure,
+      removedTools
+    };
+  }
+  /**
+   * Generate markdown summary of changes
+   */
+  generateMarkdownSummary() {
+    const comparison = this.compare();
+    const { changes, details } = comparison;
+    let md = `# Advisory Report Comparison
+
+`;
+    md += `**Baseline:** ${new Date(comparison.baseline.timestamp).toLocaleDateString()}
+`;
+    md += `**Current:** ${new Date(comparison.current.timestamp).toLocaleDateString()}
+
+`;
+    md += `## Executive Summary
+
+`;
+    const riskChange = changes.riskScoreChange;
+    const riskEmoji = riskChange < 0 ? "\u2705" : riskChange > 0 ? "\u26A0\uFE0F" : "\u2796";
+    md += `${riskEmoji} **Risk Score:** ${(comparison.baseline.overallRiskScore * 100).toFixed(0)}% \u2192 ${(comparison.current.overallRiskScore * 100).toFixed(0)}% `;
+    md += `(${riskChange > 0 ? "+" : ""}${(riskChange * 100).toFixed(0)}%)
+`;
+    const oppChange = changes.opportunityScoreChange;
+    const oppEmoji = oppChange > 0 ? "\u2705" : oppChange < 0 ? "\u26A0\uFE0F" : "\u2796";
+    md += `${oppEmoji} **Opportunity Score:** ${(comparison.baseline.overallOpportunityScore * 100).toFixed(0)}% \u2192 ${(comparison.current.overallOpportunityScore * 100).toFixed(0)}% `;
+    md += `(${oppChange > 0 ? "+" : ""}${(oppChange * 100).toFixed(0)}%)
+`;
+    md += `\u{1F4E6} **Packages:** ${comparison.baseline.packageCount} \u2192 ${comparison.current.packageCount} `;
+    md += `(${changes.packageCountChange > 0 ? "+" : ""}${changes.packageCountChange})
+
+`;
+    md += `## Key Changes
+
+`;
+    if (changes.newHighRisks > 0) {
+      md += `\u26A0\uFE0F **${changes.newHighRisks}** new high-priority risks identified
+`;
+    }
+    if (changes.resolvedHighRisks > 0) {
+      md += `\u2705 **${changes.resolvedHighRisks}** high-priority risks resolved
+`;
+    }
+    if (changes.newOpportunities > 0) {
+      md += `\u{1F31F} **${changes.newOpportunities}** new opportunities identified
+`;
+    }
+    if (details.technology.frameworkChanged) {
+      md += `\u{1F504} Framework changed: ${comparison.baseline.projectName}
+`;
+    }
+    md += `
+---
+
+`;
+    if (details.risks.new.length > 0 || details.risks.resolved.length > 0) {
+      md += `## Risk Changes
+
+`;
+      if (details.risks.new.length > 0) {
+        md += `### New Risks
+
+`;
+        details.risks.new.forEach((risk) => {
+          md += `- ${risk}
+`;
+        });
+        md += `
+`;
+      }
+      if (details.risks.resolved.length > 0) {
+        md += `### Resolved Risks
+
+`;
+        details.risks.resolved.forEach((risk) => {
+          md += `- ~~${risk}~~
+`;
+        });
+        md += `
+`;
+      }
+      if (details.risks.changed.length > 0) {
+        md += `### Risk Score Changes
+
+`;
+        md += `| Category | Before | After | Change |
+`;
+        md += `|----------|--------|-------|--------|
+`;
+        details.risks.changed.forEach((change) => {
+          const changeStr = change.change > 0 ? `+${(change.change * 100).toFixed(0)}%` : `${(change.change * 100).toFixed(0)}%`;
+          md += `| ${change.category} | ${(change.before * 100).toFixed(0)}% | ${(change.after * 100).toFixed(0)}% | ${changeStr} |
+`;
+        });
+        md += `
+`;
+      }
+    }
+    if (details.packages.added.length > 0 || details.packages.removed.length > 0 || details.packages.updated.length > 0) {
+      md += `## Package Changes
+
+`;
+      if (details.packages.added.length > 0) {
+        md += `### Added (${details.packages.added.length})
+
+`;
+        details.packages.added.slice(0, 10).forEach((pkg) => {
+          md += `- **${pkg.name}** \`${pkg.version}\` (${pkg.category})
+`;
+        });
+        if (details.packages.added.length > 10) {
+          md += `
+_...and ${details.packages.added.length - 10} more_
+`;
+        }
+        md += `
+`;
+      }
+      if (details.packages.removed.length > 0) {
+        md += `### Removed (${details.packages.removed.length})
+
+`;
+        details.packages.removed.slice(0, 10).forEach((pkg) => {
+          md += `- ~~${pkg.name}~~ \`${pkg.version}\`
+`;
+        });
+        if (details.packages.removed.length > 10) {
+          md += `
+_...and ${details.packages.removed.length - 10} more_
+`;
+        }
+        md += `
+`;
+      }
+      if (details.packages.updated.length > 0) {
+        md += `### Updated (${details.packages.updated.length})
+
+`;
+        details.packages.updated.slice(0, 10).forEach((pkg) => {
+          md += `- **${pkg.name}** \`${pkg.previousVersion}\` \u2192 \`${pkg.version}\`
+`;
+        });
+        if (details.packages.updated.length > 10) {
+          md += `
+_...and ${details.packages.updated.length - 10} more_
+`;
+        }
+        md += `
+`;
+      }
+    }
+    return md;
+  }
+};
+
+// src/cli/commands/advisory.ts
+async function advisoryCommand(options) {
+  console.log(chalk11.bold.cyan("\n\u{1F3AF} Advisory Board Analysis\n"));
+  const cwd = process.cwd();
+  let config;
+  try {
+    config = await loadConfig(cwd);
+  } catch (error) {
+    config = void 0;
+  }
+  const advisoryConfig = config?.advisory;
+  const isInteractive = options.interactive || !options.depth && !options.ci;
+  let depth = options.depth || advisoryConfig?.defaultDepth || "standard";
+  let outputDir = options.output || advisoryConfig?.outputDir || "docs/advisory";
+  let includeHealth = options.includeHealth ?? advisoryConfig?.includeHealthMetrics ?? false;
+  if (isInteractive && !options.depth) {
+    const depthChoice = await p7.select({
+      message: "Select analysis depth:",
+      options: [
+        {
+          value: "executive",
+          label: "\u{1F4CA} Executive - Business summary for non-technical stakeholders",
+          hint: "High-level overview only"
+        },
+        {
+          value: "quick",
+          label: "\u26A1 Quick - Package scan and framework detection",
+          hint: "~30 seconds"
+        },
+        {
+          value: "standard",
+          label: "\u{1F50D} Standard - Includes architecture analysis",
+          hint: "~1-2 minutes (recommended)"
+        },
+        {
+          value: "comprehensive",
+          label: "\u{1F52C} Comprehensive - Full code-level pattern detection",
+          hint: "~3-5 minutes"
+        }
+      ],
+      initialValue: "standard"
+    });
+    if (p7.isCancel(depthChoice)) {
+      p7.cancel("Analysis cancelled");
+      process.exit(0);
+    }
+    depth = depthChoice;
+  }
+  if (isInteractive && !options.output) {
+    const outputChoice = await p7.text({
+      message: "Output directory:",
+      placeholder: "docs/advisory",
+      defaultValue: outputDir
+    });
+    if (p7.isCancel(outputChoice)) {
+      p7.cancel("Analysis cancelled");
+      process.exit(0);
+    }
+    outputDir = outputChoice;
+  }
+  if (isInteractive && !options.includeHealth) {
+    const healthChoice = await p7.confirm({
+      message: "Include code health metrics?",
+      initialValue: includeHealth
+    });
+    if (p7.isCancel(healthChoice)) {
+      p7.cancel("Analysis cancelled");
+      process.exit(0);
+    }
+    includeHealth = healthChoice;
+  }
+  const analyzer = new AdvisoryAnalyzer({
+    depth,
+    cwd,
+    config,
+    includeHealth,
+    excludePatterns: advisoryConfig?.excludePatterns
+  });
+  const spinner7 = p7.spinner();
+  const depthLabels = {
+    executive: "executive summary",
+    quick: "quick scan",
+    standard: "standard analysis",
+    comprehensive: "comprehensive analysis"
+  };
+  spinner7.start(`Running ${depthLabels[depth]}...`);
+  let analysis;
+  try {
+    analysis = await analyzer.analyze();
+    spinner7.stop(`\u2713 Analysis complete`);
+  } catch (error) {
+    spinner7.stop("\u2717 Analysis failed");
+    console.error(
+      chalk11.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+    process.exit(1);
+  }
+  const questionGenerator = new QuestionGenerator(analysis, advisoryConfig);
+  const questions = questionGenerator.generate();
+  console.log("");
+  displaySummary(analysis, questions);
+  let comparisonReport;
+  let comparator;
+  if (options.compare) {
+    const comparisonPath = options.compare.endsWith(".json") ? join6(cwd, options.compare) : join6(cwd, options.compare, "analysis.json");
+    if (existsSync6(comparisonPath)) {
+      spinner7.start("Comparing with previous report...");
+      try {
+        const previousContent = await readFile4(comparisonPath, "utf-8");
+        const previousAnalysis = JSON.parse(previousContent);
+        comparator = new ReportComparator(previousAnalysis, analysis);
+        comparisonReport = comparator.compare();
+        spinner7.stop("\u2713 Comparison complete");
+        console.log("");
+        displayComparisonSummary(comparisonReport);
+      } catch (error) {
+        spinner7.stop("\u26A0 Comparison failed");
+        console.warn(chalk11.yellow(`Could not compare reports: ${error}`));
+      }
+    } else {
+      console.warn(
+        chalk11.yellow(
+          `
+\u26A0 No previous report found at ${comparisonPath}. Skipping comparison.
+`
+        )
+      );
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk11.dim("\n--dry-run mode: No files written.\n"));
+    return;
+  }
+  const fullOutputDir = join6(cwd, outputDir);
+  await mkdir4(fullOutputDir, { recursive: true });
+  spinner7.start("Generating reports...");
+  try {
+    const timestamp = options.timestamp ? (/* @__PURE__ */ new Date()).toISOString().split("T")[0] : "";
+    if (options.format === "json") {
+      await writeAnalysisJson(fullOutputDir, analysis, questions, timestamp);
+    } else {
+      await writeMarkdownReports(
+        fullOutputDir,
+        analysis,
+        questions,
+        comparator,
+        timestamp
+      );
+    }
+    spinner7.stop("\u2713 Reports generated");
+  } catch (error) {
+    spinner7.stop("\u2717 Failed to write reports");
+    console.error(chalk11.red(`Error: ${error}`));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk11.green("\u{1F4DD} Reports written to:"));
+  const suffix = options.timestamp ? `-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}` : "";
+  if (options.format === "json") {
+    console.log(chalk11.dim(`   ${join6(outputDir, `analysis${suffix}.json`)}`));
+    console.log(chalk11.dim(`   ${join6(outputDir, `questions${suffix}.json`)}`));
+  } else {
+    console.log(
+      chalk11.dim(`   ${join6(outputDir, `EXECUTIVE_SUMMARY${suffix}.md`)}`)
+    );
+    console.log(
+      chalk11.dim(`   ${join6(outputDir, `TECHNOLOGY_AUDIT${suffix}.md`)}`)
+    );
+    console.log(
+      chalk11.dim(`   ${join6(outputDir, `STRATEGIC_ROADMAP${suffix}.md`)}`)
+    );
+    console.log(
+      chalk11.dim(`   ${join6(outputDir, `BOARD_QUESTIONS${suffix}.md`)}`)
+    );
+    if (comparisonReport) {
+      console.log(
+        chalk11.dim(`   ${join6(outputDir, `DIFF_REPORT${suffix}.md`)}`)
+      );
+    }
+  }
+  if (options.ci) {
+    console.log("");
+    const exitCode = checkCIThresholds(analysis, advisoryConfig);
+    if (exitCode !== 0) {
+      console.log(chalk11.red(`
+\u274C CI check failed (exit code ${exitCode})
+`));
+      process.exit(exitCode);
+    } else {
+      console.log(chalk11.green("\n\u2713 CI check passed\n"));
+    }
+  }
+  p7.outro(chalk11.green("\u2713 Advisory analysis complete!"));
+}
+function displaySummary(analysis, questions) {
+  console.log(chalk11.bold("\u{1F4CA} Analysis Summary\n"));
+  console.log(
+    chalk11.dim(`Project: ${analysis.project.name} v${analysis.project.version}`)
+  );
+  console.log(
+    chalk11.dim(
+      `Framework: ${analysis.technology.framework || "N/A"} (${analysis.technology.language})`
+    )
+  );
+  console.log(chalk11.dim(`Total Packages: ${analysis.packages.total}`));
+  console.log(chalk11.dim(`Files Analyzed: ${analysis.project.fileCount}`));
+  console.log("");
+  const riskScore = (analysis.risks.overall * 100).toFixed(0);
+  const riskColor = analysis.risks.overall > 0.7 ? chalk11.red : analysis.risks.overall > 0.4 ? chalk11.yellow : chalk11.green;
+  console.log(riskColor(`\u26A0\uFE0F  Risk Score: ${riskScore}%`));
+  const oppScore = (analysis.opportunities.overall * 100).toFixed(0);
+  const oppColor = analysis.opportunities.overall > 0.7 ? chalk11.green : analysis.opportunities.overall > 0.5 ? chalk11.yellow : chalk11.dim;
+  console.log(oppColor(`\u{1F31F} Opportunity Score: ${oppScore}%`));
+  console.log("");
+  console.log(chalk11.bold("\u2753 Advisory Questions\n"));
+  console.log(
+    chalk11.dim(`Total Questions: ${questions.summary.totalQuestions}`)
+  );
+  console.log(chalk11.red(`   High Priority: ${questions.summary.highPriority}`));
+  console.log(
+    chalk11.yellow(`   Medium Priority: ${questions.summary.mediumPriority}`)
+  );
+  console.log(chalk11.dim(`   Low Priority: ${questions.summary.lowPriority}`));
+  console.log("");
+  const highPriorityQuestions = questions.questions.filter(
+    (q) => q.priority === "high"
+  );
+  if (highPriorityQuestions.length > 0) {
+    console.log(chalk11.bold.yellow("\u{1F525} Top Priority Questions:\n"));
+    highPriorityQuestions.slice(0, 3).forEach((q, i) => {
+      console.log(chalk11.yellow(`${i + 1}. ${q.question}`));
+      console.log(chalk11.dim(`   Category: ${q.category}`));
+      console.log("");
+    });
+  }
+}
+function displayComparisonSummary(comparison) {
+  console.log(chalk11.bold("\u{1F4C8} Changes Since Last Report\n"));
+  const riskChange = comparison.changes.riskScoreChange;
+  const riskEmoji = riskChange < 0 ? "\u2705" : riskChange > 0 ? "\u26A0\uFE0F" : "\u2796";
+  console.log(
+    `${riskEmoji} Risk Score: ${(riskChange * 100).toFixed(0)}% change`
+  );
+  const oppChange = comparison.changes.opportunityScoreChange;
+  const oppEmoji = oppChange > 0 ? "\u2705" : oppChange < 0 ? "\u26A0\uFE0F" : "\u2796";
+  console.log(
+    `${oppEmoji} Opportunity Score: ${(oppChange * 100).toFixed(0)}% change`
+  );
+  console.log(
+    `\u{1F4E6} Packages: ${comparison.changes.packageCountChange > 0 ? "+" : ""}${comparison.changes.packageCountChange}`
+  );
+  if (comparison.changes.newHighRisks > 0) {
+    console.log(
+      chalk11.red(
+        `\u26A0\uFE0F  ${comparison.changes.newHighRisks} new high-priority risks`
+      )
+    );
+  }
+  if (comparison.changes.resolvedHighRisks > 0) {
+    console.log(
+      chalk11.green(
+        `\u2705 ${comparison.changes.resolvedHighRisks} high-priority risks resolved`
+      )
+    );
+  }
+  console.log("");
+}
+async function writeAnalysisJson(outputDir, analysis, questions, timestamp) {
+  const suffix = timestamp ? `-${timestamp}` : "";
+  await writeFile4(
+    join6(outputDir, `analysis${suffix}.json`),
+    JSON.stringify(analysis, null, 2),
+    "utf-8"
+  );
+  await writeFile4(
+    join6(outputDir, `questions${suffix}.json`),
+    JSON.stringify(questions, null, 2),
+    "utf-8"
+  );
+}
+async function writeMarkdownReports(outputDir, analysis, questions, comparator, timestamp) {
+  const suffix = timestamp ? `-${timestamp}` : "";
+  await writeFile4(
+    join6(outputDir, `analysis.json`),
+    JSON.stringify(analysis, null, 2),
+    "utf-8"
+  );
+  await writeFile4(
+    join6(outputDir, `EXECUTIVE_SUMMARY${suffix}.md`),
+    generateExecutiveSummary(analysis, questions),
+    "utf-8"
+  );
+  await writeFile4(
+    join6(outputDir, `TECHNOLOGY_AUDIT${suffix}.md`),
+    generateTechnologyAudit(analysis),
+    "utf-8"
+  );
+  await writeFile4(
+    join6(outputDir, `STRATEGIC_ROADMAP${suffix}.md`),
+    generateStrategicRoadmap(analysis, questions),
+    "utf-8"
+  );
+  await writeFile4(
+    join6(outputDir, `BOARD_QUESTIONS${suffix}.md`),
+    generateBoardQuestions(questions),
+    "utf-8"
+  );
+  if (comparator) {
+    await writeFile4(
+      join6(outputDir, `DIFF_REPORT${suffix}.md`),
+      comparator.generateMarkdownSummary(),
+      "utf-8"
+    );
+  }
+}
+function generateExecutiveSummary(analysis, questions) {
+  let md = `# Executive Summary
+
+`;
+  md += `> **Generated:** ${new Date(analysis.timestamp).toLocaleDateString()}
+
+`;
+  md += `---
+
+`;
+  md += `## Project Overview
+
+`;
+  md += `**${analysis.project.name}** is a ${analysis.technology.framework || "modern"} application `;
+  md += `built with ${analysis.technology.language}. `;
+  if (analysis.project.description) {
+    md += `${analysis.project.description}
+
+`;
+  } else {
+    md += `
+
+`;
+  }
+  md += `### Key Metrics
+
+`;
+  md += `| Metric | Value |
+`;
+  md += `|--------|-------|
+`;
+  md += `| Version | ${analysis.project.version} |
+`;
+  md += `| Dependencies | ${analysis.packages.total} packages |
+`;
+  md += `| Codebase Size | ${analysis.project.fileCount} files (~${(analysis.project.totalLines / 1e3).toFixed(0)}K lines) |
+`;
+  md += `| Architecture | ${analysis.project.isMonorepo ? "Monorepo" : "Single repository"} |
+`;
+  md += `
+`;
+  md += `## Strategic Assessment
+
+`;
+  const riskScore = analysis.risks.overall;
+  const oppScore = analysis.opportunities.overall;
+  md += `### Risk & Opportunity Matrix
+
+`;
+  md += `| Category | Score | Status |
+`;
+  md += `|----------|-------|--------|
+`;
+  md += `| **Technical Risk** | ${(riskScore * 100).toFixed(0)}% | ${getRiskLabel(riskScore)} |
+`;
+  md += `| **Growth Opportunity** | ${(oppScore * 100).toFixed(0)}% | ${getOpportunityLabel(oppScore)} |
+`;
+  md += `
+`;
+  md += `### Technology Foundation
+
+`;
+  md += `**Primary Stack:**
+`;
+  md += `- Framework: ${analysis.technology.framework || "N/A"}
+`;
+  md += `- Language: ${analysis.technology.language}
+`;
+  md += `- Runtime: ${analysis.technology.runtime}
+`;
+  if (analysis.technology.platforms.length > 0) {
+    md += `- Platforms: ${analysis.technology.platforms.join(", ")}
+`;
+  }
+  md += `
+`;
+  if (analysis.technology.infrastructure.length > 0) {
+    md += `**Infrastructure:** ${analysis.technology.infrastructure.join(", ")}
+
+`;
+  }
+  if (analysis.packages.categories.length > 0) {
+    md += `### Technology Categories
+
+`;
+    const topCategories = analysis.packages.categories.sort((a, b) => b.count - a.count).slice(0, 5);
+    topCategories.forEach((cat) => {
+      md += `- **${cat.name}** (${cat.count} packages) - ${cat.businessImpact}
+`;
+    });
+    md += `
+`;
+  }
+  md += `## Key Strategic Questions
+
+`;
+  const highPriorityQuestions = questions.questions.filter(
+    (q) => q.priority === "high"
+  );
+  if (highPriorityQuestions.length > 0) {
+    highPriorityQuestions.slice(0, 5).forEach((q, i) => {
+      md += `### ${i + 1}. ${q.question}
+
+`;
+      md += `**Context:** ${q.context}
+
+`;
+      md += `**Business Impact:** ${q.businessImpact}
+
+`;
+    });
+  }
+  if (analysis.risks.critical && analysis.risks.critical.length > 0) {
+    md += `## Critical Risks
+
+`;
+    analysis.risks.critical.forEach((risk) => {
+      md += `- \u26A0\uFE0F ${risk}
+`;
+    });
+    md += `
+`;
+  }
+  if (analysis.opportunities.immediate && analysis.opportunities.immediate.length > 0) {
+    md += `## Immediate Opportunities
+
+`;
+    analysis.opportunities.immediate.slice(0, 5).forEach((opp) => {
+      md += `- \u{1F31F} ${opp}
+`;
+    });
+    md += `
+`;
+  }
+  md += `---
+
+`;
+  md += `*For detailed technical analysis, see [TECHNOLOGY_AUDIT.md](TECHNOLOGY_AUDIT.md)*
+`;
+  md += `*For strategic recommendations, see [STRATEGIC_ROADMAP.md](STRATEGIC_ROADMAP.md)*
+`;
+  return md;
+}
+function generateTechnologyAudit(analysis) {
+  let md = `# Technology Audit
+
+`;
+  md += `> **Generated:** ${new Date(analysis.timestamp).toLocaleDateString()}
+`;
+  md += `> **Analysis Depth:** ${analysis.depth}
+
+`;
+  md += `---
+
+`;
+  md += `## Project Details
+
+`;
+  md += `| Property | Value |
+`;
+  md += `|----------|-------|
+`;
+  md += `| Name | ${analysis.project.name} |
+`;
+  md += `| Version | ${analysis.project.version} |
+`;
+  md += `| Package Manager | ${analysis.project.packageManager} |
+`;
+  md += `| Repository Type | ${analysis.project.isMonorepo ? "Monorepo" : "Single"} |
+`;
+  if (analysis.project.workspaceCount) {
+    md += `| Workspaces | ${analysis.project.workspaceCount} |
+`;
+  }
+  md += `| Total Files | ${analysis.project.fileCount} |
+`;
+  md += `| Estimated Lines | ${analysis.project.totalLines.toLocaleString()} |
+`;
+  md += `
+`;
+  md += `## Technology Stack
+
+`;
+  md += `### Core Technologies
+
+`;
+  md += `| Component | Technology |
+`;
+  md += `|-----------|------------|
+`;
+  md += `| Framework | ${analysis.technology.framework || "N/A"} ${analysis.technology.frameworkVersion || ""} |
+`;
+  md += `| Language | ${analysis.technology.language} |
+`;
+  md += `| Runtime | ${analysis.technology.runtime} |
+`;
+  md += `| Platforms | ${analysis.technology.platforms.join(", ")} |
+`;
+  md += `
+`;
+  if (analysis.technology.buildTools.length > 0) {
+    md += `### Build Tools
+
+`;
+    analysis.technology.buildTools.forEach((tool) => {
+      md += `- ${tool}
+`;
+    });
+    md += `
+`;
+  }
+  if (analysis.technology.infrastructure.length > 0) {
+    md += `### Infrastructure
+
+`;
+    analysis.technology.infrastructure.forEach((infra) => {
+      md += `- ${infra}
+`;
+    });
+    md += `
+`;
+  }
+  md += `## Dependency Analysis
+
+`;
+  md += `### Overview
+
+`;
+  md += `- **Total Packages:** ${analysis.packages.total}
+`;
+  md += `- **Production:** ${analysis.packages.production.length}
+`;
+  md += `- **Development:** ${analysis.packages.development.length}
+`;
+  md += `
+`;
+  if (analysis.packages.categories.length > 0) {
+    md += `### Package Categories
+
+`;
+    md += `| Category | Count | Business Impact |
+`;
+    md += `|----------|-------|----------------|
+`;
+    analysis.packages.categories.sort((a, b) => b.count - a.count).forEach((cat) => {
+      md += `| ${cat.name} | ${cat.count} | ${cat.businessImpact} |
+`;
+    });
+    md += `
+`;
+  }
+  if (analysis.packages.production.length > 0) {
+    md += `### Key Production Dependencies
+
+`;
+    md += `| Package | Version | Category | Purpose |
+`;
+    md += `|---------|---------|----------|--------|
+`;
+    analysis.packages.production.slice(0, 15).forEach((pkg) => {
+      md += `| ${pkg.name} | \`${pkg.version}\` | ${pkg.category} | ${pkg.purpose} |
+`;
+    });
+    if (analysis.packages.production.length > 15) {
+      md += `
+*...and ${analysis.packages.production.length - 15} more*
+`;
+    }
+    md += `
+`;
+  }
+  if (analysis.architecture) {
+    md += `## Architecture Overview
+
+`;
+    md += `**Pattern:** ${analysis.architecture.pattern}
+
+`;
+    md += `### Layers
+
+`;
+    analysis.architecture.layers.forEach((layer) => {
+      md += `- ${layer}
+`;
+    });
+    md += `
+`;
+    md += `**Data Flow:** ${analysis.architecture.dataFlow}
+
+`;
+    if (analysis.architecture.keyDecisions.length > 0) {
+      md += `### Key Architecture Decisions
+
+`;
+      analysis.architecture.keyDecisions.forEach((decision) => {
+        md += `- ${decision}
+`;
+      });
+      md += `
+`;
+    }
+  }
+  if (analysis.codePatterns) {
+    md += `## Code Patterns
+
+`;
+    if (analysis.codePatterns.components.length > 0) {
+      md += `### Components
+
+`;
+      analysis.codePatterns.components.forEach((comp) => {
+        md += `**${comp.type}** (${comp.count})
+`;
+        md += `- Conventions: ${comp.conventions.join(", ")}
+`;
+        md += `
+`;
+      });
+    }
+    if (analysis.codePatterns.tests) {
+      md += `### Testing
+
+`;
+      md += `- Framework: ${analysis.codePatterns.tests.framework}
+`;
+      md += `- Test Count: ${analysis.codePatterns.tests.count}
+`;
+      md += `- Types: ${analysis.codePatterns.tests.types.join(", ")}
+`;
+      if (analysis.codePatterns.tests.coverage) {
+        md += `- Coverage: ${analysis.codePatterns.tests.coverage}%
+`;
+      }
+      md += `
+`;
+    }
+  }
+  if (analysis.health) {
+    md += `## Code Health
+
+`;
+    md += `| Check | Status |
+`;
+    md += `|-------|--------|
+`;
+    md += `| TypeScript | ${analysis.health.typecheck ? "\u2705 Passing" : "\u274C Failing"} |
+`;
+    md += `| Linting | ${analysis.health.lint ? "\u2705 Passing" : "\u274C Failing"} |
+`;
+    md += `| Tests | ${analysis.health.tests ? "\u2705 Passing" : "\u274C Failing"} |
+`;
+    md += `| Build | ${analysis.health.build ? "\u2705 Passing" : "\u274C Failing"} |
+`;
+    if (analysis.health.coverage) {
+      md += `| Coverage | ${analysis.health.coverage}% |
+`;
+    }
+    md += `
+`;
+  }
+  return md;
+}
+function generateStrategicRoadmap(analysis, questions) {
+  let md = `# Strategic Roadmap
+
+`;
+  md += `> **Generated:** ${new Date(analysis.timestamp).toLocaleDateString()}
+
+`;
+  md += `---
+
+`;
+  md += `## Overview
+
+`;
+  md += `This roadmap outlines strategic recommendations based on the technical analysis of ${analysis.project.name}. `;
+  md += `Recommendations are prioritized by business impact and feasibility.
+
+`;
+  md += `## Risk Management
+
+`;
+  if (analysis.risks.critical.length > 0) {
+    md += `### \u{1F534} Critical Priorities
+
+`;
+    analysis.risks.critical.forEach((risk, i) => {
+      md += `${i + 1}. ${risk}
+`;
+    });
+    md += `
+`;
+  }
+  if (analysis.risks.high.length > 0) {
+    md += `### \u{1F7E1} High Priority
+
+`;
+    analysis.risks.high.forEach((risk, i) => {
+      md += `${i + 1}. ${risk}
+`;
+    });
+    md += `
+`;
+  }
+  md += `## Growth Opportunities
+
+`;
+  if (analysis.opportunities.immediate.length > 0) {
+    md += `### \u26A1 Immediate (0-30 days)
+
+`;
+    analysis.opportunities.immediate.forEach((opp, i) => {
+      md += `${i + 1}. ${opp}
+`;
+    });
+    md += `
+`;
+  }
+  if (analysis.opportunities.shortTerm.length > 0) {
+    md += `### \u{1F4C5} Short-term (1-3 months)
+
+`;
+    analysis.opportunities.shortTerm.forEach((opp, i) => {
+      md += `${i + 1}. ${opp}
+`;
+    });
+    md += `
+`;
+  }
+  if (analysis.opportunities.longTerm.length > 0) {
+    md += `### \u{1F3AF} Long-term (3-12 months)
+
+`;
+    analysis.opportunities.longTerm.forEach((opp, i) => {
+      md += `${i + 1}. ${opp}
+`;
+    });
+    md += `
+`;
+  }
+  md += `## Detailed Recommendations
+
+`;
+  const categoryMap = /* @__PURE__ */ new Map();
+  questions.questions.forEach((q) => {
+    if (!categoryMap.has(q.category)) {
+      categoryMap.set(q.category, []);
+    }
+    categoryMap.get(q.category).push(q);
+  });
+  for (const [category, qs] of categoryMap) {
+    md += `### ${category}
+
+`;
+    qs.forEach((q) => {
+      md += `#### ${q.question}
+
+`;
+      if (q.findings.length > 0) {
+        md += `**Current State:**
+`;
+        q.findings.forEach((f) => {
+          md += `- ${f}
+`;
+        });
+        md += `
+`;
+      }
+      if (q.recommendations.length > 0) {
+        md += `**Recommendations:**
+`;
+        q.recommendations.forEach((r) => {
+          md += `- ${r}
+`;
+        });
+        md += `
+`;
+      }
+      md += `**Business Impact:** ${q.businessImpact}
+
+`;
+      md += `**Priority:** ${q.priority.toUpperCase()}
+
+`;
+      md += `---
+
+`;
+    });
+  }
+  return md;
+}
+function generateBoardQuestions(questions) {
+  let md = `# Advisory Board Questions
+
+`;
+  md += `> **Total Questions:** ${questions.summary.totalQuestions}
+`;
+  md += `> **High Priority:** ${questions.summary.highPriority} | `;
+  md += `**Medium:** ${questions.summary.mediumPriority} | `;
+  md += `**Low:** ${questions.summary.lowPriority}
+
+`;
+  md += `---
+
+`;
+  md += `## Table of Contents
+
+`;
+  questions.summary.categories.forEach((cat) => {
+    const slug = cat.toLowerCase().replace(/\s+/g, "-");
+    md += `- [${cat}](#${slug})
+`;
+  });
+  md += `
+---
+
+`;
+  const categoryMap = /* @__PURE__ */ new Map();
+  questions.questions.forEach((q) => {
+    if (!categoryMap.has(q.category)) {
+      categoryMap.set(q.category, []);
+    }
+    categoryMap.get(q.category).push(q);
+  });
+  for (const [category, qs] of categoryMap) {
+    const slug = category.toLowerCase().replace(/\s+/g, "-");
+    md += `## ${category}
+
+`;
+    md += `<a id="${slug}"></a>
+
+`;
+    qs.forEach((q, i) => {
+      const priorityEmoji = q.priority === "high" ? "\u{1F534}" : q.priority === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      md += `### ${i + 1}. ${priorityEmoji} ${q.question}
+
+`;
+      md += `**Context:** ${q.context}
+
+`;
+      if (q.findings.length > 0) {
+        md += `**Findings:**
+`;
+        q.findings.forEach((f) => {
+          md += `- ${f}
+`;
+        });
+        md += `
+`;
+      }
+      if (q.recommendations.length > 0) {
+        md += `**Recommendations:**
+`;
+        q.recommendations.forEach((r) => {
+          md += `- ${r}
+`;
+        });
+        md += `
+`;
+      }
+      md += `**Business Impact:** ${q.businessImpact}
+
+`;
+      md += `---
+
+`;
+    });
+  }
+  return md;
+}
+function getRiskLabel(score) {
+  if (score > 0.7) return "\u{1F534} High Risk";
+  if (score > 0.4) return "\u{1F7E1} Moderate Risk";
+  return "\u{1F7E2} Low Risk";
+}
+function getOpportunityLabel(score) {
+  if (score > 0.7) return "\u{1F31F} High Potential";
+  if (score > 0.5) return "\u{1F4C8} Moderate Potential";
+  return "\u{1F4A1} Identified";
+}
+function checkCIThresholds(analysis, config) {
+  const thresholds = config?.riskThresholds || {
+    high: 0.7,
+    medium: 0.4
+  };
+  const riskScore = analysis.risks.overall;
+  if (riskScore >= thresholds.high) {
+    console.log(
+      chalk11.red(
+        `High risk threshold exceeded: ${(riskScore * 100).toFixed(0)}%`
+      )
+    );
+    return 1;
+  }
+  if (analysis.packages.security && analysis.packages.security.length > 0) {
+    const criticalCount = analysis.packages.security.filter(
+      (s) => s.severity === "critical"
+    ).length;
+    if (criticalCount > 0) {
+      console.log(
+        chalk11.red(`Critical security vulnerabilities found: ${criticalCount}`)
+      );
+      return 1;
+    }
+  }
+  return 0;
+}
+
+// src/cli/commands/learn.ts
+import chalk12 from "chalk";
+import * as p8 from "@clack/prompts";
+import {
+  PatternStore as PatternStore2,
+  ContributorManager as ContributorManager2,
+  PatternAnonymizer,
+  TelemetryCollector as TelemetryCollector2
+} from "@hawkinside_out/workflow-improvement-tracker";
+function getWorkspacePath() {
+  return process.cwd();
+}
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatTags(tags) {
+  return tags.map((t) => `${t.category}:${t.name}`).join(", ");
+}
+async function learnRecordCommand(options) {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  console.log(chalk12.cyan("\n\u{1F4DA} Record a Learning Pattern\n"));
+  let patternType = options.type;
+  if (!patternType) {
+    const typeChoice = await p8.select({
+      message: "What type of pattern are you recording?",
+      options: [
+        {
+          value: "fix",
+          label: "\u{1F527} Fix Pattern - A specific solution to a problem"
+        },
+        {
+          value: "blueprint",
+          label: "\u{1F4D0} Blueprint - A project structure template"
+        }
+      ]
+    });
+    if (p8.isCancel(typeChoice)) {
+      p8.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    patternType = typeChoice;
+  }
+  let name = options.name;
+  if (!name) {
+    const nameInput = await p8.text({
+      message: "Pattern name:",
+      placeholder: "e.g., Next.js App Router Migration",
+      validate: (value) => {
+        if (!value || value.length < 3)
+          return "Name must be at least 3 characters";
+        if (value.length > 100) return "Name must be less than 100 characters";
+        return void 0;
+      }
+    });
+    if (p8.isCancel(nameInput)) {
+      p8.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    name = nameInput;
+  }
+  let description = options.description;
+  if (!description) {
+    const descInput = await p8.text({
+      message: "Description:",
+      placeholder: "What does this pattern solve?",
+      validate: (value) => {
+        if (!value || value.length < 10)
+          return "Description must be at least 10 characters";
+        if (value.length > 500)
+          return "Description must be less than 500 characters";
+        return void 0;
+      }
+    });
+    if (p8.isCancel(descInput)) {
+      p8.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    description = descInput;
+  }
+  let framework = options.framework;
+  if (!framework) {
+    const fwInput = await p8.text({
+      message: "Framework:",
+      placeholder: "e.g., next, react, vue, express"
+    });
+    if (p8.isCancel(fwInput)) {
+      p8.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    framework = fwInput;
+  }
+  let version = options.version;
+  if (!version) {
+    const versionInput = await p8.text({
+      message: "Framework version (semver range):",
+      placeholder: "e.g., >=14.0.0, ^18.0.0",
+      initialValue: ">=1.0.0"
+    });
+    if (p8.isCancel(versionInput)) {
+      p8.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    version = versionInput;
+  }
+  let category = options.category;
+  if (patternType === "fix" && !category) {
+    const catChoice = await p8.select({
+      message: "Category:",
+      options: [
+        { value: "migration", label: "\u{1F504} Migration" },
+        { value: "security", label: "\u{1F512} Security" },
+        { value: "performance", label: "\u26A1 Performance" },
+        { value: "compatibility", label: "\u{1F517} Compatibility" },
+        { value: "deprecation", label: "\u26A0\uFE0F Deprecation" },
+        { value: "configuration", label: "\u2699\uFE0F Configuration" },
+        { value: "best-practice", label: "\u2728 Best Practice" },
+        { value: "error-handling", label: "\u{1F6A8} Error Handling" },
+        { value: "testing", label: "\u{1F9EA} Testing" },
+        { value: "other", label: "\u{1F4E6} Other" }
+      ]
+    });
+    if (p8.isCancel(catChoice)) {
+      p8.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    category = catChoice;
+  }
+  const tags = [];
+  if (options.tags) {
+    const tagPairs = options.tags.split(",").map((t) => t.trim());
+    for (const pair of tagPairs) {
+      const [cat, val] = pair.split(":");
+      if (cat && val) {
+        tags.push({
+          category: cat,
+          name: val
+        });
+      }
+    }
+  }
+  tags.push({ category: "framework", name: framework });
+  if (patternType === "fix") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fixPattern = {
+      id: crypto.randomUUID(),
+      name,
+      description,
+      category,
+      tags,
+      trigger: {
+        errorPattern: ".*",
+        errorMessage: "Generic error pattern",
+        filePattern: "**/*"
+      },
+      solution: {
+        type: "command",
+        steps: [
+          {
+            order: 1,
+            action: "run",
+            target: "npm run fix",
+            description: "Follow the pattern instructions"
+          }
+        ]
+      },
+      compatibility: {
+        framework,
+        frameworkVersion: version,
+        runtime: "node",
+        runtimeVersion: ">=18.0.0",
+        dependencies: []
+      },
+      metrics: {
+        applications: 0,
+        successes: 0,
+        failures: 0,
+        successRate: 0
+      },
+      source: "manual",
+      isPrivate: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    const result = await store.saveFixPattern(fixPattern);
+    if (result.success) {
+      console.log(chalk12.green("\n\u2705 Fix pattern recorded successfully!\n"));
+      console.log(chalk12.dim(`  ID: ${fixPattern.id}`));
+      console.log(chalk12.dim(`  Name: ${name}`));
+      console.log(chalk12.dim(`  Category: ${category}`));
+      console.log(chalk12.dim(`  Framework: ${framework} ${version}`));
+    } else {
+      console.log(chalk12.red("\n\u274C Failed to record pattern"));
+      console.log(chalk12.dim(`  Error: ${result.error}`));
+      process.exit(1);
+    }
+  } else {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const blueprint = {
       id: crypto.randomUUID(),
@@ -1965,13 +4630,13 @@ async function learnRecordCommand(options) {
     };
     const result = await store.saveBlueprint(blueprint);
     if (result.success) {
-      console.log(chalk11.green("\n\u2705 Blueprint recorded successfully!\n"));
-      console.log(chalk11.dim(`  ID: ${blueprint.id}`));
-      console.log(chalk11.dim(`  Name: ${name}`));
-      console.log(chalk11.dim(`  Framework: ${framework} ${version}`));
+      console.log(chalk12.green("\n\u2705 Blueprint recorded successfully!\n"));
+      console.log(chalk12.dim(`  ID: ${blueprint.id}`));
+      console.log(chalk12.dim(`  Name: ${name}`));
+      console.log(chalk12.dim(`  Framework: ${framework} ${version}`));
     } else {
-      console.log(chalk11.red("\n\u274C Failed to record blueprint"));
-      console.log(chalk11.dim(`  Error: ${result.error}`));
+      console.log(chalk12.red("\n\u274C Failed to record blueprint"));
+      console.log(chalk12.dim(`  Error: ${result.error}`));
       process.exit(1);
     }
   }
@@ -1981,7 +4646,7 @@ async function learnListCommand(options) {
   const store = new PatternStore2(cwd);
   const patternType = options.type ?? "all";
   const showDeprecated = options.deprecated ?? false;
-  console.log(chalk11.cyan("\n\u{1F4DA} Recorded Learning Patterns\n"));
+  console.log(chalk12.cyan("\n\u{1F4DA} Recorded Learning Patterns\n"));
   if (patternType === "all" || patternType === "fix") {
     const fixResult = await store.listFixPatterns({
       tags: options.tag ? [{ category: "framework", name: options.tag }] : void 0,
@@ -1989,27 +4654,29 @@ async function learnListCommand(options) {
       includeDeprecated: showDeprecated
     });
     if (fixResult.success && fixResult.data && fixResult.data.length > 0) {
-      console.log(chalk11.bold.yellow("\u{1F527} Fix Patterns:\n"));
+      console.log(chalk12.bold.yellow("\u{1F527} Fix Patterns:\n"));
       for (const pattern of fixResult.data) {
         const isDeprecated = pattern.deprecatedAt !== void 0;
         const statusIcon = isDeprecated ? "\u26A0\uFE0F" : "\u2713";
-        const nameColor = isDeprecated ? chalk11.dim : chalk11.white;
+        const nameColor = isDeprecated ? chalk12.dim : chalk12.white;
         console.log(`  ${statusIcon} ${nameColor(pattern.name)}`);
-        console.log(chalk11.dim(`     ID: ${pattern.id}`));
-        console.log(chalk11.dim(`     Category: ${pattern.category}`));
-        console.log(chalk11.dim(`     Created: ${formatDate(pattern.createdAt)}`));
+        console.log(chalk12.dim(`     ID: ${pattern.id}`));
+        console.log(chalk12.dim(`     Category: ${pattern.category}`));
+        console.log(
+          chalk12.dim(`     Created: ${formatDate(pattern.createdAt)}`)
+        );
         console.log(
-          chalk11.dim(
+          chalk12.dim(
             `     Success Rate: ${(pattern.metrics.successRate * 100).toFixed(0)}% (${pattern.metrics.successes}/${pattern.metrics.applications})`
           )
         );
         if (pattern.tags.length > 0) {
-          console.log(chalk11.dim(`     Tags: ${formatTags(pattern.tags)}`));
+          console.log(chalk12.dim(`     Tags: ${formatTags(pattern.tags)}`));
         }
         console.log("");
       }
     } else if (patternType === "fix") {
-      console.log(chalk11.dim("  No fix patterns found.\n"));
+      console.log(chalk12.dim("  No fix patterns found.\n"));
     }
   }
   if (patternType === "all" || patternType === "blueprint") {
@@ -2019,44 +4686,46 @@ async function learnListCommand(options) {
       includeDeprecated: showDeprecated
     });
     if (bpResult.success && bpResult.data && bpResult.data.length > 0) {
-      console.log(chalk11.bold.blue("\u{1F4D0} Blueprints:\n"));
+      console.log(chalk12.bold.blue("\u{1F4D0} Blueprints:\n"));
       for (const blueprint of bpResult.data) {
         const isDeprecated = blueprint.deprecatedAt !== void 0;
         const statusIcon = isDeprecated ? "\u26A0\uFE0F" : "\u2713";
-        const nameColor = isDeprecated ? chalk11.dim : chalk11.white;
+        const nameColor = isDeprecated ? chalk12.dim : chalk12.white;
         console.log(`  ${statusIcon} ${nameColor(blueprint.name)}`);
-        console.log(chalk11.dim(`     ID: ${blueprint.id}`));
-        console.log(chalk11.dim(`     Language: ${blueprint.stack.language}`));
-        console.log(chalk11.dim(`     Created: ${formatDate(blueprint.createdAt)}`));
+        console.log(chalk12.dim(`     ID: ${blueprint.id}`));
+        console.log(chalk12.dim(`     Language: ${blueprint.stack.language}`));
         console.log(
-          chalk11.dim(
+          chalk12.dim(`     Created: ${formatDate(blueprint.createdAt)}`)
+        );
+        console.log(
+          chalk12.dim(
             `     Success Rate: ${(blueprint.metrics.successRate * 100).toFixed(0)}% (${blueprint.metrics.successes}/${blueprint.metrics.applications})`
           )
         );
         if (blueprint.tags.length > 0) {
-          console.log(chalk11.dim(`     Tags: ${formatTags(blueprint.tags)}`));
+          console.log(chalk12.dim(`     Tags: ${formatTags(blueprint.tags)}`));
         }
         console.log("");
       }
     } else if (patternType === "blueprint") {
-      console.log(chalk11.dim("  No blueprints found.\n"));
+      console.log(chalk12.dim("  No blueprints found.\n"));
     }
   }
   const stats = await store.getStats();
   const totalPatterns = stats.totalFixes + stats.totalBlueprints;
   const totalDeprecated = stats.deprecatedFixes + stats.deprecatedBlueprints;
-  console.log(chalk11.dim("\u2501".repeat(40)));
-  console.log(chalk11.dim(`Total: ${totalPatterns} patterns`));
-  console.log(chalk11.dim(`  Fix Patterns: ${stats.totalFixes}`));
-  console.log(chalk11.dim(`  Blueprints: ${stats.totalBlueprints}`));
-  console.log(chalk11.dim(`  Deprecated: ${totalDeprecated}`));
+  console.log(chalk12.dim("\u2501".repeat(40)));
+  console.log(chalk12.dim(`Total: ${totalPatterns} patterns`));
+  console.log(chalk12.dim(`  Fix Patterns: ${stats.totalFixes}`));
+  console.log(chalk12.dim(`  Blueprints: ${stats.totalBlueprints}`));
+  console.log(chalk12.dim(`  Deprecated: ${totalDeprecated}`));
   console.log("");
 }
 async function learnApplyCommand(patternId, options) {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
   const telemetry = new TelemetryCollector2(cwd);
-  console.log(chalk11.cyan("\n\u{1F527} Apply Learning Pattern\n"));
+  console.log(chalk12.cyan("\n\u{1F527} Apply Learning Pattern\n"));
   let pattern = await store.getFixPattern(patternId);
   let patternType = "fix";
   if (!pattern.success || !pattern.data) {
@@ -2065,88 +4734,110 @@ async function learnApplyCommand(patternId, options) {
       pattern = bpResult;
       patternType = "blueprint";
     } else {
-      console.log(chalk11.red(`
+      console.log(chalk12.red(`
 \u274C Pattern not found: ${patternId}`));
-      console.log(chalk11.dim("  Use 'workflow learn:list' to see available patterns"));
+      console.log(
+        chalk12.dim("  Use 'workflow learn:list' to see available patterns")
+      );
       process.exit(1);
     }
   }
   const patternData = pattern.data;
-  console.log(chalk11.white(`  Pattern: ${patternData.name}`));
-  console.log(chalk11.dim(`  Type: ${patternType}`));
-  console.log(chalk11.dim(`  Description: ${patternData.description}`));
+  console.log(chalk12.white(`  Pattern: ${patternData.name}`));
+  console.log(chalk12.dim(`  Type: ${patternType}`));
+  console.log(chalk12.dim(`  Description: ${patternData.description}`));
   if (options.dryRun) {
-    console.log(chalk11.yellow("\n\u{1F4CB} DRY-RUN MODE: No changes will be applied\n"));
+    console.log(
+      chalk12.yellow("\n\u{1F4CB} DRY-RUN MODE: No changes will be applied\n")
+    );
   }
   const framework = options.framework ?? patternData.compatibility.frameworks[0]?.name ?? "unknown";
   const version = options.version ?? patternData.compatibility.frameworks[0]?.version ?? "0.0.0";
   await telemetry.recordApplication(patternId, patternType, framework, version);
   if (patternType === "fix") {
     const fixPattern = patternData;
-    console.log(chalk11.cyan("\n\u{1F4CB} Solution Steps:\n"));
+    console.log(chalk12.cyan("\n\u{1F4CB} Solution Steps:\n"));
     if (fixPattern.solution.steps) {
       for (let i = 0; i < fixPattern.solution.steps.length; i++) {
         const step = fixPattern.solution.steps[i];
-        console.log(chalk11.white(`  ${i + 1}. [${step.action}] ${step.description}`));
+        console.log(
+          chalk12.white(`  ${i + 1}. [${step.action}] ${step.description}`)
+        );
         if (step.file) {
-          console.log(chalk11.dim(`     File: ${step.file}`));
+          console.log(chalk12.dim(`     File: ${step.file}`));
         }
       }
     }
   } else {
     const blueprint = patternData;
-    console.log(chalk11.cyan("\n\u{1F4CB} Setup Steps:\n"));
+    console.log(chalk12.cyan("\n\u{1F4CB} Setup Steps:\n"));
     if (blueprint.setup.steps) {
       for (let i = 0; i < blueprint.setup.steps.length; i++) {
         const step = blueprint.setup.steps[i];
-        console.log(chalk11.white(`  ${i + 1}. ${step.description}`));
+        console.log(chalk12.white(`  ${i + 1}. ${step.description}`));
         if (step.command) {
-          console.log(chalk11.dim(`     Command: ${step.command}`));
+          console.log(chalk12.dim(`     Command: ${step.command}`));
         }
       }
     }
   }
   if (!options.dryRun) {
-    const confirmed = await p7.confirm({
+    const confirmed = await p8.confirm({
       message: "Mark this pattern as successfully applied?",
       initialValue: true
     });
-    if (p7.isCancel(confirmed)) {
-      p7.cancel("Application cancelled");
+    if (p8.isCancel(confirmed)) {
+      p8.cancel("Application cancelled");
       process.exit(0);
     }
     if (confirmed) {
       await store.updatePatternMetrics(patternId, patternType, true);
       await telemetry.recordSuccess(patternId, patternType, framework, version);
-      console.log(chalk11.green("\n\u2705 Pattern marked as successfully applied!"));
+      console.log(chalk12.green("\n\u2705 Pattern marked as successfully applied!"));
     } else {
       await store.updatePatternMetrics(patternId, patternType, false);
-      await telemetry.recordFailure(patternId, patternType, framework, version, "unknown");
-      console.log(chalk11.yellow("\n\u26A0\uFE0F Pattern application marked as unsuccessful."));
+      await telemetry.recordFailure(
+        patternId,
+        patternType,
+        framework,
+        version,
+        "unknown"
+      );
+      console.log(
+        chalk12.yellow("\n\u26A0\uFE0F Pattern application marked as unsuccessful.")
+      );
     }
   }
 }
 async function learnSyncCommand(options) {
   const cwd = getWorkspacePath();
   const contributorManager = new ContributorManager2(cwd);
-  console.log(chalk11.cyan("\n\u{1F504} Sync Learning Patterns\n"));
+  console.log(chalk12.cyan("\n\u{1F504} Sync Learning Patterns\n"));
   const config = await contributorManager.getConfig();
   if (!config.success || !config.data?.syncOptIn) {
-    console.log(chalk11.yellow("\u26A0\uFE0F Sync is not enabled.\n"));
-    console.log(chalk11.dim("  To enable sync, run:"));
-    console.log(chalk11.dim("    workflow learn:config --enable-sync\n"));
-    console.log(chalk11.dim("  This allows you to share anonymized patterns with the community."));
+    console.log(chalk12.yellow("\u26A0\uFE0F Sync is not enabled.\n"));
+    console.log(chalk12.dim("  To enable sync, run:"));
+    console.log(chalk12.dim("    workflow learn:config --enable-sync\n"));
+    console.log(
+      chalk12.dim(
+        "  This allows you to share anonymized patterns with the community."
+      )
+    );
     process.exit(0);
   }
   if (options.dryRun) {
-    console.log(chalk11.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be synced\n"));
+    console.log(chalk12.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be synced\n"));
   }
   const store = new PatternStore2(cwd);
   const anonymizer = new PatternAnonymizer();
   const { fixes, blueprints } = await store.getPatternsForSync();
-  console.log(chalk11.dim(`  Patterns ready to sync: ${fixes.length} fixes, ${blueprints.length} blueprints`));
+  console.log(
+    chalk12.dim(
+      `  Patterns ready to sync: ${fixes.length} fixes, ${blueprints.length} blueprints`
+    )
+  );
   if (options.push) {
-    console.log(chalk11.cyan("\n\u{1F4E4} Pushing patterns...\n"));
+    console.log(chalk12.cyan("\n\u{1F4E4} Pushing patterns...\n"));
     let anonymizedFixes = 0;
     let anonymizedBlueprints = 0;
     for (const fix of fixes) {
@@ -2154,7 +4845,7 @@ async function learnSyncCommand(options) {
       if (result.success) {
         anonymizedFixes++;
         if (!options.dryRun) {
-          console.log(chalk11.dim(`  \u2713 Anonymized: ${fix.name}`));
+          console.log(chalk12.dim(`  \u2713 Anonymized: ${fix.name}`));
         }
       }
     }
@@ -2163,102 +4854,126 @@ async function learnSyncCommand(options) {
       if (result.success) {
         anonymizedBlueprints++;
         if (!options.dryRun) {
-          console.log(chalk11.dim(`  \u2713 Anonymized: ${bp.name}`));
+          console.log(chalk12.dim(`  \u2713 Anonymized: ${bp.name}`));
         }
       }
     }
     console.log(
-      chalk11.green(`
-\u2705 Ready to push ${anonymizedFixes} fixes and ${anonymizedBlueprints} blueprints`)
+      chalk12.green(
+        `
+\u2705 Ready to push ${anonymizedFixes} fixes and ${anonymizedBlueprints} blueprints`
+      )
     );
-    console.log(chalk11.dim("  (Registry push not yet implemented)"));
+    console.log(chalk12.dim("  (Registry push not yet implemented)"));
   }
   if (options.pull) {
-    console.log(chalk11.cyan("\n\u{1F4E5} Pulling patterns from registry...\n"));
-    console.log(chalk11.dim("  (Registry pull not yet implemented)"));
+    console.log(chalk12.cyan("\n\u{1F4E5} Pulling patterns from registry...\n"));
+    console.log(chalk12.dim("  (Registry pull not yet implemented)"));
   }
   if (!options.push && !options.pull) {
-    console.log(chalk11.dim("  Specify --push to upload or --pull to download patterns.\n"));
+    console.log(
+      chalk12.dim("  Specify --push to upload or --pull to download patterns.\n")
+    );
   }
 }
 async function learnConfigCommand(options) {
   const cwd = getWorkspacePath();
   const contributorManager = new ContributorManager2(cwd);
-  console.log(chalk11.cyan("\n\u2699\uFE0F Learning Configuration\n"));
+  console.log(chalk12.cyan("\n\u2699\uFE0F Learning Configuration\n"));
   if (options.enableSync) {
     const result = await contributorManager.enableSync();
     if (result.success) {
-      console.log(chalk11.green("\u2705 Sync enabled"));
-      console.log(chalk11.dim("  Your patterns will be anonymized before sharing."));
+      console.log(chalk12.green("\u2705 Sync enabled"));
+      console.log(
+        chalk12.dim("  Your patterns will be anonymized before sharing.")
+      );
     } else {
-      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk12.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.disableSync) {
     const result = await contributorManager.disableSync();
     if (result.success) {
-      console.log(chalk11.green("\u2705 Sync disabled"));
+      console.log(chalk12.green("\u2705 Sync disabled"));
     } else {
-      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk12.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.enableTelemetry) {
     const result = await contributorManager.enableTelemetry();
     if (result.success) {
-      console.log(chalk11.green("\u2705 Telemetry enabled"));
-      console.log(chalk11.dim("  Anonymous usage data helps improve pattern recommendations."));
+      console.log(chalk12.green("\u2705 Telemetry enabled"));
+      console.log(
+        chalk12.dim(
+          "  Anonymous usage data helps improve pattern recommendations."
+        )
+      );
     } else {
-      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk12.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.disableTelemetry) {
     const result = await contributorManager.disableTelemetry();
     if (result.success) {
-      console.log(chalk11.green("\u2705 Telemetry disabled"));
+      console.log(chalk12.green("\u2705 Telemetry disabled"));
     } else {
-      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk12.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.resetId) {
-    const confirmed = await p7.confirm({
+    const confirmed = await p8.confirm({
       message: "Are you sure you want to reset your contributor ID? This cannot be undone.",
       initialValue: false
     });
-    if (p7.isCancel(confirmed) || !confirmed) {
-      p7.cancel("Reset cancelled");
+    if (p8.isCancel(confirmed) || !confirmed) {
+      p8.cancel("Reset cancelled");
       return;
     }
     const result = await contributorManager.resetId();
     if (result.success) {
-      console.log(chalk11.green("\u2705 Contributor ID reset"));
-      console.log(chalk11.dim(`  New ID: ${result.data?.id}`));
+      console.log(chalk12.green("\u2705 Contributor ID reset"));
+      console.log(chalk12.dim(`  New ID: ${result.data?.id}`));
     } else {
-      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk12.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   const config = await contributorManager.getConfig();
   if (config.success && config.data) {
-    console.log(chalk11.white("  Current Settings:\n"));
-    console.log(chalk11.dim(`  Contributor ID: ${config.data.id}`));
-    console.log(chalk11.dim(`  Created: ${formatDate(config.data.createdAt)}`));
-    console.log(chalk11.dim(`  Sync Enabled: ${config.data.syncOptIn ? "Yes" : "No"}`));
-    console.log(chalk11.dim(`  Telemetry Enabled: ${config.data.telemetryEnabled ? "Yes" : "No"}`));
+    console.log(chalk12.white("  Current Settings:\n"));
+    console.log(chalk12.dim(`  Contributor ID: ${config.data.id}`));
+    console.log(chalk12.dim(`  Created: ${formatDate(config.data.createdAt)}`));
+    console.log(
+      chalk12.dim(`  Sync Enabled: ${config.data.syncOptIn ? "Yes" : "No"}`)
+    );
+    console.log(
+      chalk12.dim(
+        `  Telemetry Enabled: ${config.data.telemetryEnabled ? "Yes" : "No"}`
+      )
+    );
     if (config.data.syncEnabledAt) {
-      console.log(chalk11.dim(`  Sync Enabled At: ${formatDate(config.data.syncEnabledAt)}`));
+      console.log(
+        chalk12.dim(
+          `  Sync Enabled At: ${formatDate(config.data.syncEnabledAt)}`
+        )
+      );
     }
   } else {
-    console.log(chalk11.dim("  No configuration found. Settings will be created on first use.\n"));
+    console.log(
+      chalk12.dim(
+        "  No configuration found. Settings will be created on first use.\n"
+      )
+    );
   }
 }
 async function learnDeprecateCommand(patternId, reason) {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
-  console.log(chalk11.cyan("\n\u26A0\uFE0F Deprecate Pattern\n"));
+  console.log(chalk12.cyan("\n\u26A0\uFE0F Deprecate Pattern\n"));
   let patternType = "fix";
   let pattern = await store.getFixPattern(patternId);
   if (!pattern.success || !pattern.data) {
@@ -2267,26 +4982,26 @@ async function learnDeprecateCommand(patternId, reason) {
       pattern = bpResult;
       patternType = "blueprint";
     } else {
-      console.log(chalk11.red(`
+      console.log(chalk12.red(`
 \u274C Pattern not found: ${patternId}`));
       process.exit(1);
     }
   }
-  console.log(chalk11.white(`  Pattern: ${pattern.data.name}`));
-  console.log(chalk11.dim(`  Reason: ${reason}`));
-  const confirmed = await p7.confirm({
+  console.log(chalk12.white(`  Pattern: ${pattern.data.name}`));
+  console.log(chalk12.dim(`  Reason: ${reason}`));
+  const confirmed = await p8.confirm({
     message: "Are you sure you want to deprecate this pattern?",
     initialValue: false
   });
-  if (p7.isCancel(confirmed) || !confirmed) {
-    p7.cancel("Deprecation cancelled");
+  if (p8.isCancel(confirmed) || !confirmed) {
+    p8.cancel("Deprecation cancelled");
     return;
   }
   const result = await store.deprecatePattern(patternId, patternType, reason);
   if (result.success) {
-    console.log(chalk11.green("\n\u2705 Pattern deprecated successfully"));
+    console.log(chalk12.green("\n\u2705 Pattern deprecated successfully"));
   } else {
-    console.log(chalk11.red(`
+    console.log(chalk12.red(`
 \u274C Failed: ${result.error}`));
     process.exit(1);
   }
@@ -2295,28 +5010,32 @@ async function learnStatsCommand() {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
   const telemetry = new TelemetryCollector2(cwd);
-  console.log(chalk11.cyan("\n\u{1F4CA} Learning Statistics\n"));
+  console.log(chalk12.cyan("\n\u{1F4CA} Learning Statistics\n"));
   const storeStats = await store.getStats();
   const totalPatterns = storeStats.totalFixes + storeStats.totalBlueprints;
   const totalDeprecated = storeStats.deprecatedFixes + storeStats.deprecatedBlueprints;
-  console.log(chalk11.bold.white("  Patterns:\n"));
-  console.log(chalk11.dim(`    Total: ${totalPatterns}`));
-  console.log(chalk11.dim(`    Fix Patterns: ${storeStats.totalFixes}`));
-  console.log(chalk11.dim(`    Blueprints: ${storeStats.totalBlueprints}`));
-  console.log(chalk11.dim(`    Deprecated: ${totalDeprecated}`));
+  console.log(chalk12.bold.white("  Patterns:\n"));
+  console.log(chalk12.dim(`    Total: ${totalPatterns}`));
+  console.log(chalk12.dim(`    Fix Patterns: ${storeStats.totalFixes}`));
+  console.log(chalk12.dim(`    Blueprints: ${storeStats.totalBlueprints}`));
+  console.log(chalk12.dim(`    Deprecated: ${totalDeprecated}`));
   const telemetryStats = await telemetry.getStats();
-  console.log(chalk11.bold.white("\n  Telemetry:\n"));
-  console.log(chalk11.dim(`    Pending Events: ${telemetryStats.pendingEvents}`));
-  console.log(chalk11.dim(`    Total Events Sent: ${telemetryStats.totalEventsSent}`));
+  console.log(chalk12.bold.white("\n  Telemetry:\n"));
+  console.log(chalk12.dim(`    Pending Events: ${telemetryStats.pendingEvents}`));
+  console.log(
+    chalk12.dim(`    Total Events Sent: ${telemetryStats.totalEventsSent}`)
+  );
   if (telemetryStats.lastFlushAt) {
-    console.log(chalk11.dim(`    Last Flush: ${formatDate(telemetryStats.lastFlushAt)}`));
+    console.log(
+      chalk12.dim(`    Last Flush: ${formatDate(telemetryStats.lastFlushAt)}`)
+    );
   }
   console.log("");
 }
 
 // src/cli/commands/solution.ts
-import chalk12 from "chalk";
-import * as p8 from "@clack/prompts";
+import chalk13 from "chalk";
+import * as p9 from "@clack/prompts";
 import * as path2 from "path";
 import {
   PatternStore as PatternStore3,
@@ -2358,10 +5077,10 @@ function truncate(str, maxLen) {
 async function solutionCaptureCommand(options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk12.cyan("\n\u{1F4E6} Capture Solution Pattern\n"));
+  console.log(chalk13.cyan("\n\u{1F4E6} Capture Solution Pattern\n"));
   let targetPath = options.path;
   if (!targetPath) {
-    const pathInput = await p8.text({
+    const pathInput = await p9.text({
       message: "Path to the solution directory:",
       placeholder: "./src/auth",
       validate: (val) => {
@@ -2369,8 +5088,8 @@ async function solutionCaptureCommand(options) {
         return void 0;
       }
     });
-    if (p8.isCancel(pathInput)) {
-      p8.cancel("Operation cancelled");
+    if (p9.isCancel(pathInput)) {
+      p9.cancel("Operation cancelled");
       process.exit(0);
     }
     targetPath = pathInput;
@@ -2378,7 +5097,7 @@ async function solutionCaptureCommand(options) {
   const absolutePath = path2.isAbsolute(targetPath) ? targetPath : path2.resolve(cwd, targetPath);
   let name = options.name;
   if (!name) {
-    const nameInput = await p8.text({
+    const nameInput = await p9.text({
       message: "Solution name:",
       placeholder: "JWT Authentication",
       validate: (val) => {
@@ -2386,15 +5105,15 @@ async function solutionCaptureCommand(options) {
         return void 0;
       }
     });
-    if (p8.isCancel(nameInput)) {
-      p8.cancel("Operation cancelled");
+    if (p9.isCancel(nameInput)) {
+      p9.cancel("Operation cancelled");
       process.exit(0);
     }
     name = nameInput;
   }
   let description = options.description;
   if (!description) {
-    const descInput = await p8.text({
+    const descInput = await p9.text({
       message: "Solution description:",
       placeholder: "Complete JWT-based authentication with refresh tokens",
       validate: (val) => {
@@ -2403,15 +5122,15 @@ async function solutionCaptureCommand(options) {
         return void 0;
       }
     });
-    if (p8.isCancel(descInput)) {
-      p8.cancel("Operation cancelled");
+    if (p9.isCancel(descInput)) {
+      p9.cancel("Operation cancelled");
       process.exit(0);
     }
     description = descInput;
   }
   let category = options.category;
   if (!category) {
-    const categoryChoice = await p8.select({
+    const categoryChoice = await p9.select({
       message: "Solution category:",
       options: [
         { value: "auth", label: "\u{1F510} Authentication" },
@@ -2430,8 +5149,8 @@ async function solutionCaptureCommand(options) {
         { value: "other", label: "\u{1F4E6} Other" }
       ]
     });
-    if (p8.isCancel(categoryChoice)) {
-      p8.cancel("Operation cancelled");
+    if (p9.isCancel(categoryChoice)) {
+      p9.cancel("Operation cancelled");
       process.exit(0);
     }
     category = categoryChoice;
@@ -2440,20 +5159,20 @@ async function solutionCaptureCommand(options) {
   if (options.keywords) {
     keywords = options.keywords.split(",").map((k) => k.trim());
   } else {
-    const keywordsInput = await p8.text({
+    const keywordsInput = await p9.text({
       message: "Keywords (comma-separated):",
       placeholder: "jwt, authentication, login, refresh-token"
     });
-    if (p8.isCancel(keywordsInput)) {
-      p8.cancel("Operation cancelled");
+    if (p9.isCancel(keywordsInput)) {
+      p9.cancel("Operation cancelled");
       process.exit(0);
     }
     if (keywordsInput) {
       keywords = keywordsInput.split(",").map((k) => k.trim());
     }
   }
-  const spinner6 = p8.spinner();
-  spinner6.start("Analyzing solution...");
+  const spinner7 = p9.spinner();
+  spinner7.start("Analyzing solution...");
   const analyzer = new CodeAnalyzer({
     anonymize: options.anonymize ?? false
   });
@@ -2465,34 +5184,38 @@ async function solutionCaptureCommand(options) {
       category,
       keywords
     );
-    spinner6.stop("Solution analyzed");
-    console.log(chalk12.green("\n\u2713 Solution captured successfully!\n"));
-    console.log(chalk12.dim("\u2500".repeat(50)));
-    console.log(`${chalk12.bold("Name:")} ${pattern.name}`);
-    console.log(`${chalk12.bold("Category:")} ${formatCategory(pattern.category)}`);
-    console.log(`${chalk12.bold("Files:")} ${pattern.implementation.files.length}`);
+    spinner7.stop("Solution analyzed");
+    console.log(chalk13.green("\n\u2713 Solution captured successfully!\n"));
+    console.log(chalk13.dim("\u2500".repeat(50)));
+    console.log(`${chalk13.bold("Name:")} ${pattern.name}`);
+    console.log(
+      `${chalk13.bold("Category:")} ${formatCategory(pattern.category)}`
+    );
+    console.log(
+      `${chalk13.bold("Files:")} ${pattern.implementation.files.length}`
+    );
     console.log(
-      `${chalk12.bold("Dependencies:")} ${pattern.implementation.dependencies.length}`
+      `${chalk13.bold("Dependencies:")} ${pattern.implementation.dependencies.length}`
     );
     console.log(
-      `${chalk12.bold("Framework:")} ${pattern.compatibility.framework || "generic"}`
+      `${chalk13.bold("Framework:")} ${pattern.compatibility.framework || "generic"}`
     );
-    console.log(chalk12.dim("\u2500".repeat(50)));
-    const confirm8 = await p8.confirm({
+    console.log(chalk13.dim("\u2500".repeat(50)));
+    const confirm8 = await p9.confirm({
       message: "Save this solution pattern?",
       initialValue: true
     });
-    if (p8.isCancel(confirm8) || !confirm8) {
-      p8.cancel("Solution not saved");
+    if (p9.isCancel(confirm8) || !confirm8) {
+      p9.cancel("Solution not saved");
       process.exit(0);
     }
     await store.saveSolution(pattern);
-    console.log(chalk12.green(`
+    console.log(chalk13.green(`
 \u2713 Solution saved with ID: ${pattern.id}
 `));
   } catch (error) {
-    spinner6.stop("Analysis failed");
-    console.error(chalk12.red(`
+    spinner7.stop("Analysis failed");
+    console.error(chalk13.red(`
 \u2717 Error: ${error.message}
 `));
     process.exit(1);
@@ -2501,7 +5224,7 @@ async function solutionCaptureCommand(options) {
 async function solutionSearchCommand(query, options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk12.cyan("\n\u{1F50D} Search Solution Patterns\n"));
+  console.log(chalk13.cyan("\n\u{1F50D} Search Solution Patterns\n"));
   const keywords = query.split(/\s+/).filter((k) => k.length > 0);
   const result = await store.searchSolutions(keywords, {
     category: options.category,
@@ -2509,37 +5232,39 @@ async function solutionSearchCommand(query, options) {
     limit: options.limit ?? 10
   });
   if (!result.success || !result.data) {
-    console.error(chalk12.red(`
+    console.error(chalk13.red(`
 \u2717 Search failed: ${result.error}
 `));
     return;
   }
   const solutions = result.data;
   if (solutions.length === 0) {
-    console.log(chalk12.yellow("No solutions found matching your query.\n"));
-    console.log(chalk12.dim("Try different keywords or fewer filters."));
+    console.log(chalk13.yellow("No solutions found matching your query.\n"));
+    console.log(chalk13.dim("Try different keywords or fewer filters."));
     return;
   }
-  console.log(chalk12.green(`Found ${solutions.length} solution(s):
+  console.log(chalk13.green(`Found ${solutions.length} solution(s):
 `));
-  console.log(chalk12.dim("\u2500".repeat(70)));
+  console.log(chalk13.dim("\u2500".repeat(70)));
   for (const solution of solutions) {
     console.log(
-      `${chalk12.bold(solution.name)} ${chalk12.dim(`(${solution.id.slice(0, 8)})`)}`
+      `${chalk13.bold(solution.name)} ${chalk13.dim(`(${solution.id.slice(0, 8)})`)}`
     );
     console.log(`  ${formatCategory(solution.category)}`);
-    console.log(`  ${chalk12.dim(truncate(solution.description, 60))}`);
+    console.log(`  ${chalk13.dim(truncate(solution.description, 60))}`);
     console.log(
       `  Files: ${solution.implementation.files.length} | Framework: ${solution.compatibility.framework || "generic"} | Uses: ${solution.metrics.applications}`
     );
-    console.log(chalk12.dim("\u2500".repeat(70)));
+    console.log(chalk13.dim("\u2500".repeat(70)));
   }
-  console.log(chalk12.dim("\nUse 'workflow solution:apply <id>' to apply a solution."));
+  console.log(
+    chalk13.dim("\nUse 'workflow solution:apply <id>' to apply a solution.")
+  );
 }
 async function solutionListCommand(options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk12.cyan("\n\u{1F4CB} Solution Patterns\n"));
+  console.log(chalk13.cyan("\n\u{1F4CB} Solution Patterns\n"));
   const result = await store.listSolutions({
     category: options.category,
     framework: options.framework,
@@ -2547,18 +5272,20 @@ async function solutionListCommand(options) {
     limit: options.limit ?? 20
   });
   if (!result.success || !result.data) {
-    console.error(chalk12.red(`
+    console.error(chalk13.red(`
 \u2717 List failed: ${result.error}
 `));
     return;
   }
   const solutions = result.data;
   if (solutions.length === 0) {
-    console.log(chalk12.yellow("No solutions found.\n"));
-    console.log(chalk12.dim("Use 'workflow solution:capture' to capture a solution."));
+    console.log(chalk13.yellow("No solutions found.\n"));
+    console.log(
+      chalk13.dim("Use 'workflow solution:capture' to capture a solution.")
+    );
     return;
   }
-  console.log(chalk12.green(`${solutions.length} solution(s):
+  console.log(chalk13.green(`${solutions.length} solution(s):
 `));
   const byCategory = /* @__PURE__ */ new Map();
   for (const solution of solutions) {
@@ -2567,33 +5294,35 @@ async function solutionListCommand(options) {
     byCategory.set(solution.category, list);
   }
   for (const [category, items] of byCategory) {
-    console.log(chalk12.bold(`
+    console.log(chalk13.bold(`
 ${formatCategory(category)}`));
-    console.log(chalk12.dim("\u2500".repeat(50)));
+    console.log(chalk13.dim("\u2500".repeat(50)));
     for (const solution of items) {
-      const deprecated = solution.deprecatedAt ? chalk12.red(" [DEPRECATED]") : "";
+      const deprecated = solution.deprecatedAt ? chalk13.red(" [DEPRECATED]") : "";
       console.log(
-        `  ${chalk12.cyan(solution.id.slice(0, 8))} ${solution.name}${deprecated}`
+        `  ${chalk13.cyan(solution.id.slice(0, 8))} ${solution.name}${deprecated}`
       );
-      console.log(`    ${chalk12.dim(truncate(solution.description, 50))}`);
+      console.log(`    ${chalk13.dim(truncate(solution.description, 50))}`);
       console.log(
-        chalk12.dim(
+        chalk13.dim(
           `    Created: ${formatDate2(solution.createdAt)} | Files: ${solution.implementation.files.length}`
         )
       );
     }
   }
   console.log(
-    chalk12.dim("\nUse 'workflow solution:search <query>' to find specific solutions.")
+    chalk13.dim(
+      "\nUse 'workflow solution:search <query>' to find specific solutions."
+    )
   );
 }
 async function solutionApplyCommand(solutionId, options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk12.cyan("\n\u{1F680} Apply Solution Pattern\n"));
+  console.log(chalk13.cyan("\n\u{1F680} Apply Solution Pattern\n"));
   const result = await store.getSolution(solutionId);
   if (!result.success || !result.data) {
-    console.error(chalk12.red(`
+    console.error(chalk13.red(`
 \u2717 Solution not found: ${solutionId}
 `));
     process.exit(1);
@@ -2601,58 +5330,60 @@ async function solutionApplyCommand(solutionId, options) {
   const solution = result.data;
   if (solution.deprecatedAt) {
     console.log(
-      chalk12.yellow(
+      chalk13.yellow(
         `\u26A0\uFE0F  This solution is deprecated: ${solution.deprecationReason || "No reason provided"}
 `
       )
     );
-    const proceed = await p8.confirm({
+    const proceed = await p9.confirm({
       message: "Do you want to continue?",
       initialValue: false
     });
-    if (p8.isCancel(proceed) || !proceed) {
-      p8.cancel("Operation cancelled");
+    if (p9.isCancel(proceed) || !proceed) {
+      p9.cancel("Operation cancelled");
       process.exit(0);
     }
   }
-  console.log(chalk12.bold(`Solution: ${solution.name}`));
-  console.log(chalk12.dim(solution.description));
+  console.log(chalk13.bold(`Solution: ${solution.name}`));
+  console.log(chalk13.dim(solution.description));
   console.log();
-  console.log(chalk12.bold("Files to create:"));
-  const filesToApply = options.includeTests ? solution.implementation.files : solution.implementation.files.filter((f) => f.role !== "test");
+  console.log(chalk13.bold("Files to create:"));
+  const filesToApply = options.includeTests ? solution.implementation.files : solution.implementation.files.filter(
+    (f) => f.role !== "test"
+  );
   for (const file of filesToApply) {
-    console.log(chalk12.dim(`  \u2022 ${file.path} (${file.role})`));
+    console.log(chalk13.dim(`  \u2022 ${file.path} (${file.role})`));
   }
   console.log();
   if (solution.implementation.dependencies.length > 0) {
-    console.log(chalk12.bold("Dependencies to install:"));
+    console.log(chalk13.bold("Dependencies to install:"));
     for (const dep of solution.implementation.dependencies) {
-      console.log(chalk12.dim(`  \u2022 ${dep.name}@${dep.version}`));
+      console.log(chalk13.dim(`  \u2022 ${dep.name}@${dep.version}`));
     }
     console.log();
   }
   if (solution.implementation.envVars.length > 0) {
-    console.log(chalk12.bold("Environment variables needed:"));
+    console.log(chalk13.bold("Environment variables needed:"));
     for (const env of solution.implementation.envVars) {
-      const required = env.required ? chalk12.red("*") : "";
-      console.log(chalk12.dim(`  \u2022 ${env.name}${required}`));
+      const required = env.required ? chalk13.red("*") : "";
+      console.log(chalk13.dim(`  \u2022 ${env.name}${required}`));
     }
     console.log();
   }
   if (options.dryRun) {
-    console.log(chalk12.yellow("Dry run mode - no files were created.\n"));
+    console.log(chalk13.yellow("Dry run mode - no files were created.\n"));
     return;
   }
-  const confirm8 = await p8.confirm({
+  const confirm8 = await p9.confirm({
     message: "Apply this solution?",
     initialValue: true
   });
-  if (p8.isCancel(confirm8) || !confirm8) {
-    p8.cancel("Operation cancelled");
+  if (p9.isCancel(confirm8) || !confirm8) {
+    p9.cancel("Operation cancelled");
     process.exit(0);
   }
-  const spinner6 = p8.spinner();
-  spinner6.start("Applying solution...");
+  const spinner7 = p9.spinner();
+  spinner7.start("Applying solution...");
   try {
     const outputDir = options.output || cwd;
     const fs2 = await import("fs");
@@ -2664,22 +5395,20 @@ async function solutionApplyCommand(solutionId, options) {
       await fs2.promises.writeFile(filePath, file.content);
     }
     await store.updateSolutionMetrics(solution.id, true);
-    spinner6.stop("Solution applied");
-    console.log(chalk12.green(`
+    spinner7.stop("Solution applied");
+    console.log(chalk13.green(`
 \u2713 Solution applied successfully!
 `));
-    console.log(chalk12.dim(`Created ${filesToApply.length} file(s).`));
+    console.log(chalk13.dim(`Created ${filesToApply.length} file(s).`));
     if (solution.implementation.dependencies.length > 0) {
-      console.log(
-        chalk12.cyan("\nNext step: Install dependencies with:")
-      );
+      console.log(chalk13.cyan("\nNext step: Install dependencies with:"));
       const deps = solution.implementation.dependencies.map((d) => `${d.name}@${d.version}`).join(" ");
-      console.log(chalk12.dim(`  npm install ${deps}`));
+      console.log(chalk13.dim(`  npm install ${deps}`));
     }
   } catch (error) {
-    spinner6.stop("Application failed");
+    spinner7.stop("Application failed");
     await store.updateSolutionMetrics(solution.id, false);
-    console.error(chalk12.red(`
+    console.error(chalk13.red(`
 \u2717 Error: ${error.message}
 `));
     process.exit(1);
@@ -2688,48 +5417,48 @@ async function solutionApplyCommand(solutionId, options) {
 async function solutionDeprecateCommand(solutionId, reason) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk12.cyan("\n\u26A0\uFE0F  Deprecate Solution Pattern\n"));
+  console.log(chalk13.cyan("\n\u26A0\uFE0F  Deprecate Solution Pattern\n"));
   const result = await store.getSolution(solutionId);
   if (!result.success || !result.data) {
-    console.error(chalk12.red(`
+    console.error(chalk13.red(`
 \u2717 Solution not found: ${solutionId}
 `));
     process.exit(1);
   }
   const solution = result.data;
-  console.log(`Solution: ${chalk12.bold(solution.name)}`);
+  console.log(`Solution: ${chalk13.bold(solution.name)}`);
   console.log(`Reason: ${reason}
 `);
-  const confirm8 = await p8.confirm({
+  const confirm8 = await p9.confirm({
     message: "Deprecate this solution?",
     initialValue: false
   });
-  if (p8.isCancel(confirm8) || !confirm8) {
-    p8.cancel("Operation cancelled");
+  if (p9.isCancel(confirm8) || !confirm8) {
+    p9.cancel("Operation cancelled");
     process.exit(0);
   }
   await store.deprecateSolution(solutionId, reason);
-  console.log(chalk12.green(`
+  console.log(chalk13.green(`
 \u2713 Solution deprecated.
 `));
 }
 async function solutionStatsCommand() {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk12.cyan("\n\u{1F4CA} Solution Pattern Statistics\n"));
+  console.log(chalk13.cyan("\n\u{1F4CA} Solution Pattern Statistics\n"));
   const stats = await store.getStats();
-  console.log(chalk12.dim("\u2500".repeat(40)));
-  console.log(`${chalk12.bold("Solutions:")} ${stats.totalSolutions}`);
+  console.log(chalk13.dim("\u2500".repeat(40)));
+  console.log(`${chalk13.bold("Solutions:")} ${stats.totalSolutions}`);
   console.log(`  Active: ${stats.totalSolutions - stats.deprecatedSolutions}`);
   console.log(`  Deprecated: ${stats.deprecatedSolutions}`);
   console.log(`  Private: ${stats.privateSolutions}`);
   console.log(`  Synced: ${stats.syncedSolutions}`);
-  console.log(chalk12.dim("\u2500".repeat(40)));
-  console.log(`${chalk12.bold("Fixes:")} ${stats.totalFixes}`);
-  console.log(`${chalk12.bold("Blueprints:")} ${stats.totalBlueprints}`);
-  console.log(chalk12.dim("\u2500".repeat(40)));
+  console.log(chalk13.dim("\u2500".repeat(40)));
+  console.log(`${chalk13.bold("Fixes:")} ${stats.totalFixes}`);
+  console.log(`${chalk13.bold("Blueprints:")} ${stats.totalBlueprints}`);
+  console.log(chalk13.dim("\u2500".repeat(40)));
   console.log(`
-${chalk12.bold("By Category:")}`);
+${chalk13.bold("By Category:")}`);
   const listResult = await store.listSolutions({ limit: 1e3 });
   if (listResult.success && listResult.data) {
     const categories = /* @__PURE__ */ new Map();
@@ -2773,14 +5502,27 @@ program.command("scope:create").description("Create a custom scope package").opt
 program.command("scope:migrate").description("Migrate inline scopes to a custom package").option("--name <name>", "Package name for the preset").option("--output-dir <dir>", "Output directory").option("--keep-config", "Keep inline scopes in config after migration").action(scopeMigrateCommand);
 program.command("verify").description("Run all quality checks with fix-and-revalidate pattern").option("--fix", "Enable auto-fix for lint and format issues").option("--max-retries <n>", "Maximum retry cycles (default: 10)", "10").option("--commit", "Commit changes if all checks pass").option("--dry-run", "Preview fixes without applying them").option("--learn", "Record successful fixes as learning patterns").action(verifyCommand);
 program.command("auto-setup").description("Automatically configure linting, formatting, testing, and CI").option("-y, --yes", "Auto-approve all prompts").option("--audit", "Show audit report without applying changes").action(autoSetupCommand);
-program.command("learn:record").description("Record a new pattern from a successful implementation").option("--name <name>", "Pattern name").option("--description <desc>", "Pattern description").option("--category <cat>", "Category (migration, security, performance, etc.)").option("--framework <fw>", "Framework (next, react, vue, etc.)").option("--version <ver>", "Framework version range").option("--tags <tags>", "Comma-separated tags (category:value)").option("--type <type>", "Pattern type (fix, blueprint)").action(learnRecordCommand);
+program.command("advisory").description("Generate advisory board analysis and documentation").option(
+  "--depth <level>",
+  "Analysis depth: executive, quick, standard, comprehensive"
+).option("--output <path>", "Output directory (default: docs/advisory)").option("--interactive", "Enable interactive mode").option("--dry-run", "Preview analysis without writing files").option(
+  "--format <type>",
+  "Output format: markdown, json (default: markdown)"
+).option("--timestamp", "Append timestamp to filenames").option("--include-health", "Include code health metrics from verify/doctor").option("--ci", "CI mode with exit codes on high-risk findings").option("--compare <path>", "Compare with previous report").action(advisoryCommand);
+program.command("learn:record").description("Record a new pattern from a successful implementation").option("--name <name>", "Pattern name").option("--description <desc>", "Pattern description").option(
+  "--category <cat>",
+  "Category (migration, security, performance, etc.)"
+).option("--framework <fw>", "Framework (next, react, vue, etc.)").option("--version <ver>", "Framework version range").option("--tags <tags>", "Comma-separated tags (category:value)").option("--type <type>", "Pattern type (fix, blueprint)").action(learnRecordCommand);
 program.command("learn:list").description("List recorded learning patterns").option("--type <type>", "Filter by type (fix, blueprint, all)").option("--framework <fw>", "Filter by framework").option("--tag <tag>", "Filter by tag").option("--deprecated", "Include deprecated patterns").action(learnListCommand);
 program.command("learn:apply <patternId>").description("Apply a pattern to the current project").argument("<patternId>", "Pattern ID to apply").option("--framework <fw>", "Override framework").option("--version <ver>", "Override version").option("--dry-run", "Preview without applying").action(learnApplyCommand);
 program.command("learn:sync").description("Sync patterns with remote registry").option("--push", "Push local patterns to registry").option("--pull", "Pull patterns from registry").option("--dry-run", "Preview without syncing").action(learnSyncCommand);
 program.command("learn:config").description("Configure learning settings").option("--enable-sync", "Enable pattern sync").option("--disable-sync", "Disable pattern sync").option("--enable-telemetry", "Enable anonymous telemetry").option("--disable-telemetry", "Disable telemetry").option("--reset-id", "Reset contributor ID").option("--show", "Show current configuration").action(learnConfigCommand);
 program.command("learn:deprecate <patternId> <reason>").description("Deprecate an outdated pattern").argument("<patternId>", "Pattern ID to deprecate").argument("<reason>", "Reason for deprecation").action(learnDeprecateCommand);
 program.command("learn:stats").description("Show learning statistics").action(learnStatsCommand);
-program.command("solution:capture").description("Capture a solution pattern from working code").option("--name <name>", "Solution name").option("--description <desc>", "Solution description").option("--category <cat>", "Category (auth, api, database, ui, testing, deployment, integration, performance, security, other)").option("--keywords <kw>", "Comma-separated keywords").option("--path <path>", "Path to the solution directory").option("--anonymize", "Anonymize sensitive data in code").action(solutionCaptureCommand);
+program.command("solution:capture").description("Capture a solution pattern from working code").option("--name <name>", "Solution name").option("--description <desc>", "Solution description").option(
+  "--category <cat>",
+  "Category (auth, api, database, ui, testing, deployment, integration, performance, security, other)"
+).option("--keywords <kw>", "Comma-separated keywords").option("--path <path>", "Path to the solution directory").option("--anonymize", "Anonymize sensitive data in code").action(solutionCaptureCommand);
 program.command("solution:search <query>").description("Search for solution patterns").argument("<query>", "Search query (keywords, problem description)").option("--category <cat>", "Filter by category").option("--framework <fw>", "Filter by framework").option("--limit <n>", "Maximum results", "10").action(solutionSearchCommand);
 program.command("solution:list").description("List all solution patterns").option("--category <cat>", "Filter by category").option("--framework <fw>", "Filter by framework").option("--deprecated", "Include deprecated solutions").option("--limit <n>", "Maximum results", "20").action(solutionListCommand);
 program.command("solution:apply <solutionId>").description("Apply a solution pattern to the current project").argument("<solutionId>", "Solution ID to apply").option("--output <dir>", "Output directory").option("--dry-run", "Preview without applying").option("--include-tests", "Include test files").action(solutionApplyCommand);