lynxprompt 0.3.0 → 0.4.0

package/dist/index.js

@@ -200,12 +200,7 @@ async function loginCommand() {
           pollSpinner.succeed("Authentication successful!");
           setToken(result.token);
           setUser(result.user);
-          console.log();
-          console.log(chalk.green(`\u2705 Logged in as ${chalk.bold(result.user.email)}`));
-          console.log(chalk.gray(`   Plan: ${result.user.plan}`));
-          console.log(chalk.gray(`   Token stored securely in config`));
-          console.log();
-          console.log(chalk.cyan("You're ready to use LynxPrompt CLI!"));
+          displayWelcome(result.user);
           return;
         }
         if (result.status === "expired") {
@@ -259,6 +254,53 @@ async function tryOpenBrowser(url) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function displayWelcome(user) {
+  const plan = user.plan?.toUpperCase() || "FREE";
+  const name = user.name || user.email.split("@")[0];
+  const planConfig = {
+    FREE: { color: chalk.gray, emoji: "\u{1F193}", badge: "Free" },
+    PRO: { color: chalk.cyan, emoji: "\u26A1", badge: "Pro" },
+    MAX: { color: chalk.magenta, emoji: "\u{1F680}", badge: "Max" },
+    TEAMS: { color: chalk.yellow, emoji: "\u{1F465}", badge: "Teams" }
+  };
+  const config2 = planConfig[plan] || planConfig.FREE;
+  console.log();
+  console.log(chalk.bold("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk.bold("\u2502") + "                                                     " + chalk.bold("\u2502"));
+  console.log(chalk.bold("\u2502") + chalk.green.bold(`   ${config2.emoji} Welcome to LynxPrompt CLI!`) + "                   " + chalk.bold("\u2502"));
+  console.log(chalk.bold("\u2502") + "                                                     " + chalk.bold("\u2502"));
+  console.log(chalk.bold("\u2502") + `   ${chalk.white("User:")} ${chalk.bold(name.padEnd(38))}` + chalk.bold("\u2502"));
+  console.log(chalk.bold("\u2502") + `   ${chalk.white("Plan:")} ${config2.color(config2.badge.padEnd(38))}` + chalk.bold("\u2502"));
+  console.log(chalk.bold("\u2502") + "                                                     " + chalk.bold("\u2502"));
+  console.log(chalk.bold("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  console.log();
+  console.log(chalk.bold("\u{1F4CB} Your CLI Capabilities:"));
+  console.log();
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt init") + chalk.gray(" - Generate config files"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt wizard") + chalk.gray(" - Interactive wizard"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt list") + chalk.gray(" - List your blueprints"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt pull <id>") + chalk.gray(" - Download blueprints"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt push") + chalk.gray(" - Upload blueprints to marketplace"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt link") + chalk.gray(" - Link project to blueprint"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt sync") + chalk.gray(" - Sync linked blueprints"));
+  console.log(chalk.green("  \u2713") + " " + chalk.white("lynxprompt diff") + chalk.gray(" - Compare local vs remote"));
+  if (plan === "PRO" || plan === "MAX" || plan === "TEAMS") {
+    console.log();
+    console.log(chalk.cyan("  \u26A1") + " " + chalk.white("Advanced wizards") + chalk.gray(" - More customization options"));
+    console.log(chalk.cyan("  \u26A1") + " " + chalk.white("Sell blueprints") + chalk.gray(" - Monetize your configurations"));
+  }
+  if (plan === "MAX" || plan === "TEAMS") {
+    console.log(chalk.magenta("  \u{1F680}") + " " + chalk.white("All paid blueprints") + chalk.gray(" - Access premium content"));
+    console.log(chalk.magenta("  \u{1F680}") + " " + chalk.white("Priority support") + chalk.gray(" - Get help faster"));
+  }
+  if (plan === "TEAMS") {
+    console.log(chalk.yellow("  \u{1F465}") + " " + chalk.white("Team blueprints") + chalk.gray(" - Share with your team"));
+    console.log(chalk.yellow("  \u{1F465}") + " " + chalk.white("SSO integration") + chalk.gray(" - Enterprise authentication"));
+  }
+  console.log();
+  console.log(chalk.gray("Token stored securely. Run ") + chalk.cyan("lynxprompt --help") + chalk.gray(" to see all commands."));
+  console.log();
+}
 
 // src/commands/logout.ts
 import chalk2 from "chalk";
@@ -1370,7 +1412,7 @@ function formatDetectionResults(result) {
 }
 
 // src/utils/detect.ts
-import { readFile as readFile3, access as access3 } from "fs/promises";
+import { readFile as readFile3, access as access2 } from "fs/promises";
 import { join as join4 } from "path";
 var JS_FRAMEWORK_PATTERNS = {
   nextjs: ["next"],
@@ -1593,7 +1635,7 @@ async function detectProject(cwd) {
 }
 async function fileExists(path2) {
   try {
-    await access3(path2);
+    await access2(path2);
     return true;
   } catch {
     return false;
@@ -1964,7 +2006,7 @@ async function initCommand(options) {
 import chalk8 from "chalk";
 import prompts4 from "prompts";
 import ora7 from "ora";
-import { writeFile as writeFile4, mkdir as mkdir4, access as access5 } from "fs/promises";
+import { writeFile as writeFile4, mkdir as mkdir4, access as access3 } from "fs/promises";
 import { join as join6, dirname as dirname4 } from "path";
 
 // src/utils/generator.ts
@@ -1974,7 +2016,17 @@ var PLATFORM_FILES = {
   claude: "CLAUDE.md",
   copilot: ".github/copilot-instructions.md",
   windsurf: ".windsurfrules",
-  zed: ".zed/instructions.md"
+  zed: ".zed/instructions.md",
+  aider: ".aider.conf.yml",
+  cline: ".clinerules",
+  continue: ".continue/rules.md",
+  cody: ".cody/rules.md",
+  amazonq: ".amazonq/rules/project.md",
+  tabnine: ".tabnine.yaml",
+  supermaven: ".supermaven/rules.md",
+  codegpt: ".codegpt/rules.md",
+  void: ".void/rules.md",
+  goose: ".goosehints"
 };
 var PERSONA_DESCRIPTIONS = {
   backend: "a senior backend developer specializing in APIs, databases, and microservices architecture",
@@ -1995,6 +2047,8 @@ var STACK_NAMES = {
   ruby: "Ruby",
   php: "PHP",
   swift: "Swift",
+  kotlin: "Kotlin",
+  cpp: "C/C++",
   react: "React",
   nextjs: "Next.js",
   vue: "Vue.js",
@@ -2007,10 +2061,44 @@ var STACK_NAMES = {
   spring: "Spring Boot",
   rails: "Ruby on Rails",
   laravel: "Laravel",
+  nestjs: "NestJS",
+  vite: "Vite",
+  "react-native": "React Native",
+  postgresql: "PostgreSQL",
+  mysql: "MySQL",
+  mongodb: "MongoDB",
+  redis: "Redis",
+  sqlite: "SQLite",
+  supabase: "Supabase",
+  firebase: "Firebase",
   prisma: "Prisma",
   tailwind: "Tailwind CSS",
   fastify: "Fastify"
 };
+var NAMING_DESCRIPTIONS = {
+  language_default: "follow idiomatic conventions for the primary language",
+  camelCase: "use camelCase for variables and functions",
+  snake_case: "use snake_case for variables and functions",
+  PascalCase: "use PascalCase for classes and types",
+  "kebab-case": "use kebab-case for file names and CSS classes"
+};
+var AI_BEHAVIOR_DESCRIPTIONS = {
+  explain_changes: "Always explain what changes you're making and why before implementing them",
+  preserve_style: "Preserve and follow the existing code style in the project",
+  minimal_changes: "Make minimal, focused changes - avoid unnecessary refactoring",
+  no_comments: "Avoid adding unnecessary comments; code should be self-documenting",
+  prefer_simple: "Prefer simpler solutions over clever ones",
+  test_first: "Write tests before implementing new functionality (TDD)",
+  no_console: "Remove console.log/print statements before committing",
+  type_strict: "Be strict with types - avoid any/Any/Object types"
+};
+var IMPORTANT_FILES_PATHS = {
+  readme: "README.md",
+  package: "package.json or pyproject.toml",
+  tsconfig: "tsconfig.json or similar config",
+  architecture: "ARCHITECTURE.md",
+  contributing: "CONTRIBUTING.md"
+};
 var BOUNDARIES = {
   conservative: {
     always: ["Read any file in the project", "Run lint and format commands"],
@@ -2069,6 +2157,12 @@ var BOUNDARIES = {
     ]
   }
 };
+var TEST_LEVEL_DESCRIPTIONS = {
+  smoke: "Quick sanity checks for critical paths",
+  unit: "Unit tests for individual functions and components",
+  integration: "Integration tests for component interactions",
+  e2e: "End-to-end tests for full user flows"
+};
 function generateConfig(options) {
   const files = {};
   for (const platform of options.platforms) {
@@ -2082,8 +2176,12 @@ function generateConfig(options) {
 function generateFileContent(options, platform) {
   const sections = [];
   const isMdc = platform === "cursor";
-  const isPlainText = platform === "windsurf";
-  const isMarkdown = !isMdc && !isPlainText;
+  const isYaml = platform === "aider" || platform === "tabnine";
+  const isPlainText = platform === "windsurf" || platform === "cline" || platform === "goose";
+  const isMarkdown = !isMdc && !isYaml && !isPlainText;
+  if (isYaml) {
+    return generateYamlConfig(options, platform);
+  }
   if (isMdc) {
     sections.push("---");
     sections.push(`description: "${options.name} - AI coding rules"`);
@@ -2098,6 +2196,23 @@ function generateFileContent(options, platform) {
     sections.push(`# ${options.name} - AI Assistant Configuration`);
     sections.push("");
   }
+  if (options.projectType) {
+    const typeContexts = {
+      work: "This is a professional/enterprise project. Follow strict procedures and maintain high code quality.",
+      leisure: "This is a personal/hobby project. Feel free to be more experimental and creative.",
+      opensource: "This is an open-source project. Consider community guidelines and contribution standards.",
+      learning: "This is an educational project. Explain concepts and be patient with learning-focused approaches."
+    };
+    if (typeContexts[options.projectType]) {
+      if (isMarkdown || isMdc) {
+        sections.push(`> **Project Context:** ${typeContexts[options.projectType]}`);
+        sections.push("");
+      } else {
+        sections.push(`Project Context: ${typeContexts[options.projectType]}`);
+        sections.push("");
+      }
+    }
+  }
   const personaDesc = PERSONA_DESCRIPTIONS[options.persona] || options.persona;
   if (isMarkdown || isMdc) {
     sections.push("## Persona");
@@ -2128,7 +2243,25 @@ function generateFileContent(options, platform) {
     }
     sections.push("");
   }
-  const hasCommands = Object.values(options.commands).some(Boolean);
+  if (options.repoHost || options.license || options.conventionalCommits) {
+    if (isMarkdown || isMdc) {
+      sections.push("## Repository");
+      sections.push("");
+      if (options.repoHost) {
+        sections.push(`- **Host:** ${options.repoHost.charAt(0).toUpperCase() + options.repoHost.slice(1)}`);
+      }
+      if (options.license && options.license !== "none") {
+        sections.push(`- **License:** ${options.license.toUpperCase()}`);
+      }
+      if (options.conventionalCommits) {
+        sections.push("- **Commits:** Follow [Conventional Commits](https://conventionalcommits.org) format");
+      }
+      sections.push("");
+    }
+  }
+  const hasCommands = options.commands && Object.values(options.commands).some(
+    (v) => Array.isArray(v) ? v.length > 0 : Boolean(v)
+  );
   if (hasCommands) {
     if (isMarkdown || isMdc) {
       sections.push("## Commands");
@@ -2139,24 +2272,68 @@ function generateFileContent(options, platform) {
     } else {
       sections.push("Commands:");
     }
-    if (options.commands.build) {
-      sections.push(isMarkdown || isMdc ? `# Build: ${options.commands.build}` : `- Build: ${options.commands.build}`);
+    const cmdCategories = ["build", "test", "lint", "dev", "custom"];
+    for (const cat of cmdCategories) {
+      const cmd = options.commands[cat];
+      if (cmd) {
+        const cmds = Array.isArray(cmd) ? cmd : [cmd];
+        for (const c of cmds) {
+          if (c) {
+            const label = cat.charAt(0).toUpperCase() + cat.slice(1);
+            sections.push(isMarkdown || isMdc ? `# ${label}: ${c}` : `- ${label}: ${c}`);
+          }
+        }
+      }
     }
-    if (options.commands.test) {
-      sections.push(isMarkdown || isMdc ? `# Test: ${options.commands.test}` : `- Test: ${options.commands.test}`);
+    if (isMarkdown || isMdc) {
+      sections.push("```");
     }
-    if (options.commands.lint) {
-      sections.push(isMarkdown || isMdc ? `# Lint: ${options.commands.lint}` : `- Lint: ${options.commands.lint}`);
+    sections.push("");
+  }
+  if (options.aiBehavior && options.aiBehavior.length > 0) {
+    if (isMarkdown || isMdc) {
+      sections.push("## AI Behavior Rules");
+      sections.push("");
+      for (const rule of options.aiBehavior) {
+        const desc = AI_BEHAVIOR_DESCRIPTIONS[rule];
+        if (desc) {
+          sections.push(`- ${desc}`);
+        }
+      }
+      sections.push("");
     }
-    if (options.commands.dev) {
-      sections.push(isMarkdown || isMdc ? `# Dev: ${options.commands.dev}` : `- Dev: ${options.commands.dev}`);
+  }
+  if (options.importantFiles && options.importantFiles.length > 0) {
+    if (isMarkdown || isMdc) {
+      sections.push("## Important Files to Read");
+      sections.push("");
+      sections.push("Always read these files first to understand the project context:");
+      sections.push("");
+      for (const file of options.importantFiles) {
+        const path2 = IMPORTANT_FILES_PATHS[file];
+        if (path2) {
+          sections.push(`- \`${path2}\``);
+        }
+      }
+      sections.push("");
     }
+  }
+  if (options.selfImprove) {
     if (isMarkdown || isMdc) {
-      sections.push("```");
+      sections.push("## Self-Improving Blueprint");
+      sections.push("");
+      sections.push("> **Auto-update enabled:** As you work on this project, track patterns and update this configuration file to better reflect the project's conventions and preferences.");
+      sections.push("");
     }
-    sections.push("");
   }
-  const boundaries = BOUNDARIES[options.boundaries];
+  let boundaries = BOUNDARIES[options.boundaries];
+  if (options.boundaryNever?.length || options.boundaryAsk?.length) {
+    boundaries = {
+      ...boundaries,
+      never: options.boundaryNever?.length ? options.boundaryNever : boundaries.never,
+      askFirst: options.boundaryAsk?.length ? options.boundaryAsk : boundaries.askFirst
+    };
+  }
   if (boundaries) {
     if (isMarkdown || isMdc) {
       sections.push("## Boundaries");
@@ -2201,6 +2378,27 @@ function generateFileContent(options, platform) {
   if (isMarkdown || isMdc) {
     sections.push("## Code Style");
     sections.push("");
+    if (options.namingConvention) {
+      const namingDesc = NAMING_DESCRIPTIONS[options.namingConvention];
+      if (namingDesc) {
+        sections.push(`- **Naming:** ${namingDesc}`);
+      }
+    }
+    if (options.errorHandling) {
+      const errorStyles = {
+        try_catch: "Use try/catch blocks for error handling",
+        result_types: "Use Result/Either types for error handling",
+        error_codes: "Use error codes with proper documentation",
+        exceptions: "Use custom exception classes"
+      };
+      if (errorStyles[options.errorHandling]) {
+        sections.push(`- **Errors:** ${errorStyles[options.errorHandling]}`);
+      }
+    }
+    if (options.styleNotes) {
+      sections.push(`- **Notes:** ${options.styleNotes}`);
+    }
+    sections.push("");
     sections.push("Follow these conventions:");
     sections.push("");
     if (options.stack.includes("typescript") || options.stack.includes("javascript")) {
@@ -2234,6 +2432,49 @@ function generateFileContent(options, platform) {
     sections.push("- Keep functions focused and testable");
     sections.push("");
   }
+  if (options.testLevels?.length || options.testFrameworks?.length || options.coverageTarget) {
+    if (isMarkdown || isMdc) {
+      sections.push("## Testing Strategy");
+      sections.push("");
+      if (options.testLevels?.length) {
+        sections.push("### Test Levels");
+        sections.push("");
+        for (const level of options.testLevels) {
+          const desc = TEST_LEVEL_DESCRIPTIONS[level];
+          if (desc) {
+            sections.push(`- **${level.charAt(0).toUpperCase() + level.slice(1)}:** ${desc}`);
+          }
+        }
+        sections.push("");
+      }
+      if (options.testFrameworks?.length) {
+        sections.push("### Frameworks");
+        sections.push("");
+        sections.push(`Use: ${options.testFrameworks.join(", ")}`);
+        sections.push("");
+      }
+      if (options.coverageTarget) {
+        sections.push(`### Coverage Target: ${options.coverageTarget}%`);
+        sections.push("");
+      }
+      if (options.testNotes) {
+        sections.push(`**Notes:** ${options.testNotes}`);
+        sections.push("");
+      }
+    }
+  }
+  if (options.extraNotes) {
+    if (isMarkdown || isMdc) {
+      sections.push("## Additional Notes");
+      sections.push("");
+      sections.push(options.extraNotes);
+      sections.push("");
+    } else {
+      sections.push("Additional Notes:");
+      sections.push(options.extraNotes);
+      sections.push("");
+    }
+  }
   if (isMarkdown || isMdc) {
     sections.push("---");
     sections.push("");
@@ -2241,105 +2482,446 @@ function generateFileContent(options, platform) {
   }
   return sections.join("\n");
 }
+function generateYamlConfig(options, platform) {
+  const lines = [];
+  if (platform === "aider") {
+    lines.push("# Aider configuration");
+    lines.push(`# Project: ${options.name}`);
+    lines.push("");
+    lines.push("# Model settings");
+    lines.push("model: gpt-4");
+    lines.push("");
+    lines.push("# Code style");
+    if (options.stack.includes("typescript") || options.stack.includes("javascript")) {
+      lines.push("auto-lint: true");
+    }
+    lines.push("");
+    lines.push("# Custom instructions");
+    lines.push("read:");
+    lines.push("  - README.md");
+    if (options.importantFiles?.includes("architecture")) {
+      lines.push("  - ARCHITECTURE.md");
+    }
+  } else if (platform === "tabnine") {
+    lines.push("# Tabnine configuration");
+    lines.push(`# Project: ${options.name}`);
+    lines.push("");
+    lines.push("version: 1.0.0");
+    lines.push("");
+    lines.push("project:");
+    lines.push(`  name: ${options.name}`);
+    if (options.description) {
+      lines.push(`  description: "${options.description}"`);
+    }
+    lines.push("");
+    lines.push("context:");
+    lines.push("  include:");
+    lines.push('    - "**/*.ts"');
+    lines.push('    - "**/*.js"');
+    lines.push('    - "**/*.py"');
+  }
+  lines.push("");
+  lines.push(`# Generated by LynxPrompt CLI`);
+  return lines.join("\n");
+}
 
 // src/commands/wizard.ts
+var WIZARD_STEPS = [
+  { id: "format", title: "Output Format", icon: "\u{1F4E4}", tier: "basic" },
+  { id: "project", title: "Project Basics", icon: "\u2728", tier: "basic" },
+  { id: "tech", title: "Tech Stack", icon: "\u{1F4BB}", tier: "basic" },
+  { id: "repo", title: "Repository Setup", icon: "\u{1F500}", tier: "basic" },
+  { id: "commands", title: "Commands", icon: "\u{1F4CB}", tier: "intermediate" },
+  { id: "code_style", title: "Code Style", icon: "\u{1FA84}", tier: "intermediate" },
+  { id: "ai", title: "AI Behavior", icon: "\u{1F9E0}", tier: "basic" },
+  { id: "boundaries", title: "Boundaries", icon: "\u{1F6E1}\uFE0F", tier: "advanced" },
+  { id: "testing", title: "Testing Strategy", icon: "\u{1F9EA}", tier: "advanced" },
+  { id: "static", title: "Static Files", icon: "\u{1F4C4}", tier: "advanced" },
+  { id: "extra", title: "Final Details", icon: "\u{1F4AC}", tier: "basic" }
+];
+var ALL_PLATFORMS = [
+  { id: "agents", name: "Universal (AGENTS.md)", file: "AGENTS.md", icon: "\u{1F310}", note: "Works with all AI-enabled IDEs" },
+  { id: "cursor", name: "Cursor", file: ".cursor/rules/", icon: "\u26A1", note: "Native project rules format" },
+  { id: "claude", name: "Claude Code", file: "CLAUDE.md", icon: "\u{1F9E0}", note: "Also works with Cursor" },
+  { id: "copilot", name: "GitHub Copilot", file: ".github/copilot-instructions.md", icon: "\u{1F419}", note: "VS Code & JetBrains" },
+  { id: "windsurf", name: "Windsurf", file: ".windsurfrules", icon: "\u{1F3C4}", note: "Codeium IDE" },
+  { id: "zed", name: "Zed", file: ".zed/instructions.md", icon: "\u26A1", note: "Zed editor" },
+  { id: "aider", name: "Aider", file: ".aider.conf.yml", icon: "\u{1F916}", note: "CLI AI pair programming" },
+  { id: "cline", name: "Cline", file: ".clinerules", icon: "\u{1F527}", note: "VS Code extension" },
+  { id: "continue", name: "Continue", file: ".continue/config.json", icon: "\u27A1\uFE0F", note: "Open-source autopilot" },
+  { id: "cody", name: "Sourcegraph Cody", file: ".cody/config.json", icon: "\u{1F50D}", note: "Context-aware AI" },
+  { id: "amazonq", name: "Amazon Q", file: ".amazonq/rules/", icon: "\u{1F4E6}", note: "AWS AI assistant" },
+  { id: "tabnine", name: "Tabnine", file: ".tabnine.yaml", icon: "\u{1F4DD}", note: "AI code completion" },
+  { id: "supermaven", name: "Supermaven", file: ".supermaven/config.json", icon: "\u{1F9B8}", note: "Fast AI completions" },
+  { id: "codegpt", name: "CodeGPT", file: ".codegpt/config.json", icon: "\u{1F4AC}", note: "VS Code AI assistant" },
+  { id: "void", name: "Void", file: ".void/config.json", icon: "\u{1F573}\uFE0F", note: "Open-source Cursor alt" },
+  { id: "goose", name: "Goose", file: ".goosehints", icon: "\u{1FABF}", note: "Block AI agent" }
+];
 var OUTPUT_FORMATS = [
-  {
-    title: "AGENTS.md (Universal)",
-    value: "agents",
-    description: "Works with Claude Code, GitHub Copilot, Aider, and most AI editors",
-    recommended: true
-  },
-  {
-    title: "Cursor (.cursor/rules/)",
-    value: "cursor",
-    description: "Cursor IDE with MDC format"
-  },
-  {
-    title: "Multiple formats",
-    value: "multiple",
-    description: "Select multiple AI editors to generate for"
-  }
+  { title: "\u{1F310} AGENTS.md (Universal)", value: "agents", description: "Works with Claude, Copilot, Aider, Devin & more", recommended: true },
+  { title: "\u26A1 Cursor", value: "cursor", description: ".cursor/rules/ native format" },
+  { title: "\u{1F9E0} Claude Code", value: "claude", description: "CLAUDE.md format" },
+  { title: "\u{1F419} GitHub Copilot", value: "copilot", description: ".github/copilot-instructions.md" },
+  { title: "\u{1F3C4} Windsurf", value: "windsurf", description: ".windsurfrules configuration" },
+  { title: "\u{1F4E6} Multiple platforms...", value: "multiple", description: "Select from 16+ supported AI editors" }
 ];
-var TECH_STACKS = [
-  { title: "TypeScript", value: "typescript" },
-  { title: "JavaScript", value: "javascript" },
-  { title: "Python", value: "python" },
-  { title: "Go", value: "go" },
-  { title: "Rust", value: "rust" },
-  { title: "Java", value: "java" },
-  { title: "C#/.NET", value: "csharp" },
-  { title: "Ruby", value: "ruby" },
-  { title: "PHP", value: "php" },
-  { title: "Swift", value: "swift" }
+var LANGUAGES = [
+  { title: "\u{1F537} TypeScript", value: "typescript" },
+  { title: "\u{1F7E1} JavaScript", value: "javascript" },
+  { title: "\u{1F40D} Python", value: "python" },
+  { title: "\u{1F535} Go", value: "go" },
+  { title: "\u{1F980} Rust", value: "rust" },
+  { title: "\u2615 Java", value: "java" },
+  { title: "\u{1F49C} C#/.NET", value: "csharp" },
+  { title: "\u{1F48E} Ruby", value: "ruby" },
+  { title: "\u{1F418} PHP", value: "php" },
+  { title: "\u{1F34E} Swift", value: "swift" },
+  { title: "\u{1F536} Kotlin", value: "kotlin" },
+  { title: "\u2B1B C/C++", value: "cpp" }
 ];
 var FRAMEWORKS = [
-  { title: "React", value: "react" },
-  { title: "Next.js", value: "nextjs" },
-  { title: "Vue.js", value: "vue" },
-  { title: "Angular", value: "angular" },
-  { title: "Svelte", value: "svelte" },
-  { title: "Express", value: "express" },
-  { title: "FastAPI", value: "fastapi" },
-  { title: "Django", value: "django" },
-  { title: "Flask", value: "flask" },
-  { title: "Spring Boot", value: "spring" },
-  { title: "Rails", value: "rails" },
-  { title: "Laravel", value: "laravel" }
+  { title: "\u269B\uFE0F  React", value: "react" },
+  { title: "\u25B2  Next.js", value: "nextjs" },
+  { title: "\u{1F49A} Vue.js", value: "vue" },
+  { title: "\u{1F170}\uFE0F  Angular", value: "angular" },
+  { title: "\u{1F525} Svelte", value: "svelte" },
+  { title: "\u{1F682} Express", value: "express" },
+  { title: "\u26A1 FastAPI", value: "fastapi" },
+  { title: "\u{1F3B8} Django", value: "django" },
+  { title: "\u{1F9EA} Flask", value: "flask" },
+  { title: "\u{1F343} Spring", value: "spring" },
+  { title: "\u{1F48E} Rails", value: "rails" },
+  { title: "\u{1F534} Laravel", value: "laravel" },
+  { title: "\u{1F3D7}\uFE0F  NestJS", value: "nestjs" },
+  { title: "\u26A1 Vite", value: "vite" },
+  { title: "\u{1F4F1} React Native", value: "react-native" }
+];
+var DATABASES = [
+  { title: "\u{1F418} PostgreSQL", value: "postgresql" },
+  { title: "\u{1F42C} MySQL", value: "mysql" },
+  { title: "\u{1F343} MongoDB", value: "mongodb" },
+  { title: "\u{1F534} Redis", value: "redis" },
+  { title: "\u{1F4CA} SQLite", value: "sqlite" },
+  { title: "\u2601\uFE0F  Supabase", value: "supabase" },
+  { title: "\u{1F525} Firebase", value: "firebase" },
+  { title: "\u{1F4C2} Prisma", value: "prisma" }
 ];
-var PLATFORMS = [
-  { title: "AGENTS.md (Universal)", value: "agents", filename: "AGENTS.md" },
-  { title: "Cursor (.cursor/rules/)", value: "cursor", filename: ".cursor/rules/project.mdc" },
-  { title: "Claude Code (CLAUDE.md)", value: "claude", filename: "CLAUDE.md" },
-  { title: "GitHub Copilot", value: "copilot", filename: ".github/copilot-instructions.md" },
-  { title: "Windsurf (.windsurfrules)", value: "windsurf", filename: ".windsurfrules" },
-  { title: "Zed", value: "zed", filename: ".zed/instructions.md" }
+var REPO_HOSTS = [
+  { id: "github", label: "GitHub", icon: "\u{1F419}" },
+  { id: "gitlab", label: "GitLab", icon: "\u{1F98A}" },
+  { id: "bitbucket", label: "Bitbucket", icon: "\u{1FAA3}" },
+  { id: "gitea", label: "Gitea", icon: "\u{1F375}" },
+  { id: "azure", label: "Azure DevOps", icon: "\u2601\uFE0F" },
+  { id: "other", label: "Other", icon: "\u{1F4E6}" }
+];
+var LICENSES = [
+  { id: "mit", label: "MIT" },
+  { id: "apache-2.0", label: "Apache 2.0" },
+  { id: "gpl-3.0", label: "GPL 3.0" },
+  { id: "lgpl-3.0", label: "LGPL 3.0" },
+  { id: "agpl-3.0", label: "AGPL 3.0" },
+  { id: "bsd-3", label: "BSD 3-Clause" },
+  { id: "mpl-2.0", label: "MPL 2.0" },
+  { id: "unlicense", label: "Unlicense" },
+  { id: "none", label: "None / Proprietary" }
+];
+var COMMON_COMMANDS = {
+  build: [
+    "npm run build",
+    "pnpm build",
+    "yarn build",
+    "bun run build",
+    "next build",
+    "vite build",
+    "tsc",
+    "tsc --noEmit",
+    "go build",
+    "cargo build",
+    "cargo build --release",
+    "mvn package",
+    "gradle build",
+    "dotnet build",
+    "docker build -t app .",
+    "docker compose build"
+  ],
+  test: [
+    "npm test",
+    "pnpm test",
+    "yarn test",
+    "bun test",
+    "vitest",
+    "vitest run",
+    "jest",
+    "jest --coverage",
+    "pytest",
+    "pytest --cov",
+    "go test ./...",
+    "cargo test",
+    "mvn test",
+    "gradle test",
+    "playwright test",
+    "cypress run"
+  ],
+  lint: [
+    "npm run lint",
+    "pnpm lint",
+    "eslint .",
+    "eslint . --fix",
+    "prettier --check .",
+    "prettier --write .",
+    "ruff check",
+    "ruff format",
+    "black .",
+    "flake8",
+    "golangci-lint run",
+    "cargo clippy",
+    "rubocop"
+  ],
+  dev: [
+    "npm run dev",
+    "pnpm dev",
+    "yarn dev",
+    "bun run dev",
+    "next dev",
+    "vite",
+    "vite dev",
+    "uvicorn main:app --reload",
+    "flask run",
+    "rails server",
+    "go run .",
+    "cargo run",
+    "dotnet run"
+  ]
+};
+var NAMING_CONVENTIONS = [
+  { id: "language_default", label: "Follow language conventions", desc: "Use idiomatic style" },
+  { id: "camelCase", label: "camelCase", desc: "JavaScript, TypeScript, Java" },
+  { id: "snake_case", label: "snake_case", desc: "Python, Ruby, Rust, Go" },
+  { id: "PascalCase", label: "PascalCase", desc: "C#, .NET classes" },
+  { id: "kebab-case", label: "kebab-case", desc: "CSS, HTML, URLs" }
 ];
-var PERSONAS = [
-  { title: "Full-Stack Developer - Complete application setups", value: "fullstack" },
-  { title: "Backend Developer - APIs, databases, microservices", value: "backend" },
-  { title: "Frontend Developer - UI, components, styling", value: "frontend" },
-  { title: "DevOps Engineer - Infrastructure, CI/CD, containers", value: "devops" },
-  { title: "Data Engineer - Pipelines, ETL, databases", value: "data" },
-  { title: "Security Engineer - Secure code, vulnerabilities", value: "security" },
-  { title: "Custom...", value: "custom" }
+var ERROR_PATTERNS = [
+  { id: "try_catch", label: "try/catch blocks" },
+  { id: "result_types", label: "Result/Either types" },
+  { id: "error_codes", label: "Error codes" },
+  { id: "exceptions", label: "Custom exceptions" },
+  { id: "other", label: "Other" }
+];
+var AI_BEHAVIOR_RULES = [
+  { id: "explain_changes", label: "Explain changes before making them", recommended: true },
+  { id: "preserve_style", label: "Preserve existing code style", recommended: true },
+  { id: "minimal_changes", label: "Make minimal, focused changes", recommended: true },
+  { id: "no_comments", label: "Avoid adding unnecessary comments", recommended: false },
+  { id: "prefer_simple", label: "Prefer simpler solutions", recommended: true },
+  { id: "test_first", label: "Write tests before implementation", recommended: false },
+  { id: "no_console", label: "Remove console.log/print before committing", recommended: false },
+  { id: "type_strict", label: "Be strict with types (no any/Any)", recommended: false }
+];
+var IMPORTANT_FILES = [
+  { id: "readme", label: "README.md", icon: "\u{1F4D6}" },
+  { id: "package", label: "package.json / pyproject.toml", icon: "\u{1F4E6}" },
+  { id: "tsconfig", label: "tsconfig.json / config files", icon: "\u2699\uFE0F" },
+  { id: "architecture", label: "ARCHITECTURE.md", icon: "\u{1F3D7}\uFE0F" },
+  { id: "contributing", label: "CONTRIBUTING.md", icon: "\u{1F91D}" }
 ];
 var BOUNDARY_PRESETS = [
   {
-    title: "Standard - Balance of freedom and safety (recommended)",
+    title: "\u{1F7E2} Standard",
     value: "standard",
+    description: "Balanced freedom & safety",
     always: ["Read any file", "Modify files in src/", "Run build/test/lint", "Create test files"],
     askFirst: ["Add new dependencies", "Modify config files", "Create new modules"],
     never: ["Delete production data", "Modify .env secrets", "Force push"]
   },
   {
-    title: "Conservative - Ask before most changes",
+    title: "\u{1F7E1} Conservative",
     value: "conservative",
+    description: "Ask before most changes",
     always: ["Read any file", "Run lint/format commands"],
     askFirst: ["Modify any file", "Add dependencies", "Create files", "Run tests"],
     never: ["Delete files", "Modify .env", "Push to git"]
   },
   {
-    title: "Permissive - AI can modify freely within src/",
+    title: "\u{1F7E0} Permissive",
     value: "permissive",
+    description: "AI can modify freely",
     always: ["Modify any file in src/", "Run any script", "Add dependencies", "Create files"],
     askFirst: ["Modify root configs", "Delete directories"],
     never: ["Modify .env", "Access external APIs without confirmation"]
   }
 ];
+var BOUNDARY_OPTIONS = [
+  "Delete files",
+  "Create new files",
+  "Rename/move files",
+  "Rewrite large sections",
+  "Refactor architecture",
+  "Change dependencies",
+  "Modify database schema",
+  "Update API contracts",
+  "Touch CI pipelines",
+  "Modify Docker config",
+  "Change environment vars",
+  "Update docs automatically",
+  "Edit README",
+  "Handle secrets/credentials",
+  "Modify auth logic",
+  "Delete failing tests",
+  "Skip tests temporarily"
+];
+var TEST_FRAMEWORKS = [
+  "jest",
+  "vitest",
+  "mocha",
+  "ava",
+  "tap",
+  "pytest",
+  "unittest",
+  "nose2",
+  "go test",
+  "testify",
+  "cargo test",
+  "rstest",
+  "junit",
+  "testng",
+  "spock",
+  "rspec",
+  "minitest",
+  "phpunit",
+  "pest",
+  "playwright",
+  "cypress",
+  "puppeteer",
+  "selenium"
+];
+var TEST_LEVELS = [
+  { id: "smoke", label: "Smoke", desc: "Quick sanity checks" },
+  { id: "unit", label: "Unit", desc: "Individual functions/components" },
+  { id: "integration", label: "Integration", desc: "Component interactions" },
+  { id: "e2e", label: "E2E", desc: "Full user flows" }
+];
+var PROJECT_TYPES = [
+  { id: "work", label: "Work", icon: "\u{1F4BC}", description: "Professional/enterprise project" },
+  { id: "leisure", label: "Leisure", icon: "\u{1F3AE}", description: "Personal/hobby project" },
+  { id: "opensource", label: "Open Source", icon: "\u{1F30D}", description: "Community-driven project" },
+  { id: "learning", label: "Learning", icon: "\u{1F4DA}", description: "Educational/experimental" }
+];
+function canAccessTier(userTier, requiredTier) {
+  const tierLevels = { free: 0, pro: 1, max: 2, teams: 2 };
+  const requiredLevels = { basic: 0, intermediate: 1, advanced: 2 };
+  return tierLevels[userTier] >= requiredLevels[requiredTier];
+}
+function getTierBadge(tier) {
+  switch (tier) {
+    case "intermediate":
+      return { label: "PRO", color: chalk8.cyan };
+    case "advanced":
+      return { label: "MAX", color: chalk8.magenta };
+    default:
+      return null;
+  }
+}
+function getAvailableSteps(userTier) {
+  return WIZARD_STEPS.filter((step) => canAccessTier(userTier, step.tier));
+}
+function printBox(lines, color = chalk8.gray) {
+  const maxLen = Math.max(...lines.map((l) => l.replace(/\x1b\[[0-9;]*m/g, "").length));
+  const top = "\u250C" + "\u2500".repeat(maxLen + 2) + "\u2510";
+  const bottom = "\u2514" + "\u2500".repeat(maxLen + 2) + "\u2518";
+  console.log(color(top));
+  for (const line of lines) {
+    const stripped = line.replace(/\x1b\[[0-9;]*m/g, "");
+    const padding = " ".repeat(maxLen - stripped.length);
+    console.log(color("\u2502 ") + line + padding + color(" \u2502"));
+  }
+  console.log(color(bottom));
+}
+function showStep(current, step, userTier) {
+  const availableSteps = getAvailableSteps(userTier);
+  const total = availableSteps.length;
+  const progress = "\u25CF".repeat(current) + "\u25CB".repeat(total - current);
+  const badge = getTierBadge(step.tier);
+  console.log();
+  let stepLine = chalk8.cyan(`  ${progress}  Step ${current}/${total}: ${step.icon} ${step.title}`);
+  if (badge) {
+    stepLine += " " + badge.color(`[${badge.label}]`);
+  }
+  console.log(stepLine);
+  console.log();
+}
+function showWizardOverview(userTier) {
+  console.log(chalk8.bold("  \u{1F4CB} Wizard Steps Overview:"));
+  console.log();
+  let stepNum = 1;
+  for (const step of WIZARD_STEPS) {
+    const canAccess = canAccessTier(userTier, step.tier);
+    const badge = getTierBadge(step.tier);
+    if (canAccess) {
+      let line = chalk8.green(`    ${stepNum.toString().padStart(2)}. \u2713 ${step.icon} ${step.title}`);
+      if (badge) {
+        line += " " + badge.color(`[${badge.label}]`);
+      }
+      console.log(line);
+      stepNum++;
+    } else {
+      let line = chalk8.gray(`     \u2500  \u{1F512} ${step.icon} ${step.title}`);
+      if (badge) {
+        line += " " + badge.color.dim(`[${badge.label}]`);
+      }
+      console.log(line);
+    }
+  }
+  console.log();
+}
+var promptConfig = {
+  onCancel: () => {
+    console.log(chalk8.yellow("\n  Cancelled. Run 'lynxp wizard' anytime to restart.\n"));
+    process.exit(0);
+  }
+};
 async function wizardCommand(options) {
   console.log();
-  console.log(chalk8.cyan("\u{1F431} LynxPrompt Wizard"));
-  console.log(chalk8.gray("Generate AI IDE configuration in seconds"));
+  console.log(chalk8.cyan.bold("  \u{1F431} LynxPrompt Wizard"));
+  console.log(chalk8.gray("     Generate AI IDE configuration in seconds"));
   console.log();
+  const authenticated = isAuthenticated();
+  const user = getUser();
+  const userPlanRaw = user?.plan?.toLowerCase() || "free";
+  const userTier = ["pro", "max", "teams"].includes(userPlanRaw) ? userPlanRaw : "free";
+  const userPlanDisplay = user?.plan?.toUpperCase() || "FREE";
+  if (!authenticated) {
+    console.log(chalk8.yellow("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+    console.log(chalk8.yellow("\u2502") + chalk8.white(" \u{1F4A1} ") + chalk8.gray("Log in for full wizard features:") + "                        " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + "                                                             " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + chalk8.gray("   \u2022 ") + chalk8.white("Commands & Code Style") + chalk8.cyan(" [PRO]") + "                          " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + chalk8.gray("   \u2022 ") + chalk8.white("Boundaries, Testing, Static Files") + chalk8.magenta(" [MAX]") + "             " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + chalk8.gray("   \u2022 ") + chalk8.white("Push configs to cloud") + chalk8.gray(" (lynxp push)") + "                    " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + chalk8.gray("   \u2022 ") + chalk8.white("Sync across devices") + chalk8.gray(" (lynxp sync)") + "                      " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + "                                                             " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2502") + chalk8.cyan("   Run: lynxp login") + "                                          " + chalk8.yellow("\u2502"));
+    console.log(chalk8.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+    console.log();
+  } else {
+    const planEmoji = userTier === "teams" ? "\u{1F465}" : userTier === "max" ? "\u{1F680}" : userTier === "pro" ? "\u26A1" : "\u{1F193}";
+    console.log(chalk8.green(`  \u2713 Logged in as ${chalk8.bold(user?.name || user?.email)} ${planEmoji} ${chalk8.gray(userPlanDisplay)}`));
+    console.log();
+  }
+  showWizardOverview(userTier);
+  const accessibleSteps = getAvailableSteps(userTier);
+  const lockedSteps = WIZARD_STEPS.length - accessibleSteps.length;
+  if (lockedSteps > 0) {
+    console.log(chalk8.gray(`  ${lockedSteps} step${lockedSteps > 1 ? "s" : ""} locked. Upgrade at ${chalk8.cyan("https://lynxprompt.com/pricing")}`));
+    console.log();
+  }
   const detected = await detectProject(process.cwd());
   if (detected) {
-    console.log(chalk8.green("\u2713 Detected project:"));
-    if (detected.name) console.log(chalk8.gray(`  Name: ${detected.name}`));
-    if (detected.stack.length > 0) console.log(chalk8.gray(`  Stack: ${detected.stack.join(", ")}`));
-    if (detected.packageManager) console.log(chalk8.gray(`  Package manager: ${detected.packageManager}`));
-    if (detected.commands.build) console.log(chalk8.gray(`  Build: ${detected.commands.build}`));
-    if (detected.commands.test) console.log(chalk8.gray(`  Test: ${detected.commands.test}`));
+    const detectedInfo = [
+      chalk8.green("\u2713 Project detected")
+    ];
+    if (detected.name) detectedInfo.push(chalk8.gray(`  Name: ${detected.name}`));
+    if (detected.stack.length > 0) detectedInfo.push(chalk8.gray(`  Stack: ${detected.stack.join(", ")}`));
+    if (detected.packageManager) detectedInfo.push(chalk8.gray(`  Package manager: ${detected.packageManager}`));
+    printBox(detectedInfo, chalk8.gray);
     console.log();
   }
   let config2;
@@ -2362,19 +2944,20 @@ async function wizardCommand(options) {
       commands: detected?.commands || {}
     };
   } else {
-    config2 = await runInteractiveWizard(options, detected);
+    config2 = await runInteractiveWizard(options, detected, userTier);
   }
   const spinner = ora7("Generating configuration...").start();
   try {
     const files = generateConfig(config2);
     spinner.stop();
     console.log();
-    console.log(chalk8.green("\u2705 Generated:"));
+    console.log(chalk8.green.bold("  \u2705 Generated:"));
+    console.log();
     for (const [filename, content] of Object.entries(files)) {
       const outputPath = join6(process.cwd(), filename);
       let exists = false;
       try {
-        await access5(outputPath);
+        await access3(outputPath);
         exists = true;
       } catch {
       }
@@ -2386,7 +2969,7 @@ async function wizardCommand(options) {
           initial: false
         });
         if (!response.overwrite) {
-          console.log(chalk8.yellow(`   Skipped: ${filename}`));
+          console.log(chalk8.yellow(`     \u23ED\uFE0F  Skipped: ${filename}`));
           continue;
         }
       }
@@ -2395,15 +2978,24 @@ async function wizardCommand(options) {
         await mkdir4(dir, { recursive: true });
       }
       await writeFile4(outputPath, content, "utf-8");
-      console.log(`   ${chalk8.cyan(filename)}`);
+      console.log(`     ${chalk8.cyan("\u2192")} ${chalk8.bold(filename)}`);
     }
     console.log();
-    console.log(chalk8.gray("Your AI assistant will now follow these instructions."));
-    console.log();
-    console.log(chalk8.gray("Tips:"));
-    console.log(chalk8.gray("  \u2022 Edit the generated file anytime to customize rules"));
-    console.log(chalk8.gray("  \u2022 Run 'lynxp wizard' again to regenerate"));
-    console.log(chalk8.gray("  \u2022 Run 'lynxp check' to validate your configuration"));
+    const nextStepsLines = [
+      chalk8.gray("Your AI assistant will now follow these instructions."),
+      "",
+      chalk8.gray("Next steps:"),
+      chalk8.cyan("  lynxp check    ") + chalk8.gray("Validate configuration")
+    ];
+    if (authenticated) {
+      nextStepsLines.push(chalk8.cyan("  lynxp push     ") + chalk8.gray("Upload to cloud"));
+      nextStepsLines.push(chalk8.cyan("  lynxp link     ") + chalk8.gray("Link to a blueprint"));
+      nextStepsLines.push(chalk8.cyan("  lynxp sync     ") + chalk8.gray("Sync with linked blueprint"));
+    } else {
+      nextStepsLines.push(chalk8.gray("  lynxp login    ") + chalk8.yellow("Log in to push & sync"));
+    }
+    nextStepsLines.push(chalk8.cyan("  lynxp status   ") + chalk8.gray("View current setup"));
+    printBox(nextStepsLines, chalk8.gray);
     console.log();
   } catch (error) {
     spinner.fail("Failed to generate files");
@@ -2415,121 +3007,476 @@ async function wizardCommand(options) {
     process.exit(1);
   }
 }
-async function runInteractiveWizard(options, detected) {
+async function runInteractiveWizard(options, detected, userTier) {
   const answers = {};
+  const availableSteps = getAvailableSteps(userTier);
+  let currentStepNum = 0;
+  const getCurrentStep = (stepId) => {
+    const step = availableSteps.find((s) => s.id === stepId);
+    if (step) {
+      currentStepNum++;
+      return step;
+    }
+    return null;
+  };
+  const formatStep = getCurrentStep("format");
+  showStep(currentStepNum, formatStep, userTier);
   let platforms;
   if (options.format) {
     platforms = options.format.split(",").map((f) => f.trim());
+    console.log(chalk8.gray(`  Using format from flag: ${platforms.join(", ")}`));
   } else {
     const formatResponse = await prompts4({
       type: "select",
       name: "format",
-      message: "Select output format:",
+      message: chalk8.white("Where will you use this?"),
       choices: OUTPUT_FORMATS.map((f) => ({
-        title: f.recommended ? `${f.title} ${chalk8.green("(recommended)")}` : f.title,
+        title: f.recommended ? `${f.title} ${chalk8.green.bold("\u2605 recommended")}` : f.title,
         value: f.value,
-        description: f.description
+        description: chalk8.gray(f.description)
       })),
-      initial: 0
-      // AGENTS.md is default
-    });
+      initial: 0,
+      hint: chalk8.gray("\u2191\u2193 navigate \u2022 enter select")
+    }, promptConfig);
     if (formatResponse.format === "multiple") {
+      console.log();
+      console.log(chalk8.gray("  Select the AI editors you want to generate config for:"));
+      console.log();
       const platformResponse = await prompts4({
         type: "multiselect",
         name: "platforms",
-        message: "Select AI editors:",
-        choices: PLATFORMS.map((p) => ({ title: p.title, value: p.value })),
-        hint: "- Space to select, Enter to confirm",
-        min: 1
-      });
+        message: chalk8.white("Select AI editors (16 supported):"),
+        choices: ALL_PLATFORMS.map((p) => ({
+          title: `${p.icon} ${p.name}`,
+          value: p.id,
+          description: chalk8.gray(p.note)
+        })),
+        hint: chalk8.gray("space select \u2022 a toggle all \u2022 enter confirm"),
+        min: 1,
+        instructions: false
+      }, promptConfig);
       platforms = platformResponse.platforms || ["agents"];
+      console.log(chalk8.green(`  \u2713 Selected ${platforms.length} platform${platforms.length === 1 ? "" : "s"}`));
     } else {
       platforms = [formatResponse.format || "agents"];
     }
   }
   answers.platforms = platforms;
+  const projectStep = getCurrentStep("project");
+  showStep(currentStepNum, projectStep, userTier);
   const nameResponse = await prompts4({
     type: "text",
     name: "name",
-    message: "Project name:",
-    initial: options.name || detected?.name || "my-project"
-  });
+    message: chalk8.white("Project name:"),
+    initial: options.name || detected?.name || "my-project",
+    hint: chalk8.gray("Used in the generated config header")
+  }, promptConfig);
   answers.name = nameResponse.name || "my-project";
   const descResponse = await prompts4({
     type: "text",
     name: "description",
-    message: "Brief description (optional):",
-    initial: options.description || ""
-  });
+    message: chalk8.white("Brief description:"),
+    initial: options.description || "",
+    hint: chalk8.gray("optional - helps AI understand context")
+  }, promptConfig);
   answers.description = descResponse.description || "";
-  const allStackOptions = [...TECH_STACKS, ...FRAMEWORKS];
+  const typeResponse = await prompts4({
+    type: "select",
+    name: "projectType",
+    message: chalk8.white("Project type:"),
+    choices: PROJECT_TYPES.map((t) => ({
+      title: `${t.icon} ${t.label}`,
+      value: t.id,
+      description: chalk8.gray(t.description)
+    })),
+    initial: 0
+  }, promptConfig);
+  answers.projectType = typeResponse.projectType || "work";
+  const techStep = getCurrentStep("tech");
+  showStep(currentStepNum, techStep, userTier);
+  const allStackOptions = [...LANGUAGES, ...FRAMEWORKS, ...DATABASES];
   const detectedStackSet = new Set(detected?.stack || []);
+  if (detectedStackSet.size > 0) {
+    console.log(chalk8.gray(`  Auto-selected: ${detected?.stack?.join(", ")}`));
+    console.log();
+  }
   const stackResponse = await prompts4({
     type: "multiselect",
     name: "stack",
-    message: "Tech stack:",
+    message: chalk8.white("Languages, frameworks & databases:"),
     choices: allStackOptions.map((s) => ({
       title: s.title,
       value: s.value,
       selected: detectedStackSet.has(s.value)
     })),
-    hint: "- Space to select, Enter to confirm"
-  });
+    hint: chalk8.gray("space select \u2022 a toggle all \u2022 enter confirm"),
+    instructions: false
+  }, promptConfig);
   answers.stack = stackResponse.stack || [];
+  const repoStep = getCurrentStep("repo");
+  showStep(currentStepNum, repoStep, userTier);
+  const repoHostResponse = await prompts4({
+    type: "select",
+    name: "repoHost",
+    message: chalk8.white("Repository host:"),
+    choices: REPO_HOSTS.map((h) => ({
+      title: `${h.icon} ${h.label}`,
+      value: h.id
+    })),
+    initial: 0
+  }, promptConfig);
+  answers.repoHost = repoHostResponse.repoHost || "github";
+  const visibilityResponse = await prompts4({
+    type: "toggle",
+    name: "isPublic",
+    message: chalk8.white("Public repository?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.isPublic = visibilityResponse.isPublic || false;
+  const licenseResponse = await prompts4({
+    type: "select",
+    name: "license",
+    message: chalk8.white("License:"),
+    choices: LICENSES.map((l) => ({
+      title: l.label,
+      value: l.id
+    })),
+    initial: 0
+  }, promptConfig);
+  answers.license = licenseResponse.license || "mit";
+  const conventionalResponse = await prompts4({
+    type: "toggle",
+    name: "conventionalCommits",
+    message: chalk8.white("Use Conventional Commits?"),
+    initial: true,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.conventionalCommits = conventionalResponse.conventionalCommits ?? true;
+  if (canAccessTier(userTier, "intermediate")) {
+    const commandsStep = getCurrentStep("commands");
+    showStep(currentStepNum, commandsStep, userTier);
+    console.log(chalk8.gray("  Select common commands for your project:"));
+    console.log();
+    const buildResponse = await prompts4({
+      type: "multiselect",
+      name: "build",
+      message: chalk8.white("Build commands:"),
+      choices: COMMON_COMMANDS.build.slice(0, 12).map((c) => ({
+        title: chalk8.cyan(c),
+        value: c,
+        selected: detected?.commands?.build === c
+      })),
+      hint: chalk8.gray("space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    const testResponse = await prompts4({
+      type: "multiselect",
+      name: "test",
+      message: chalk8.white("Test commands:"),
+      choices: COMMON_COMMANDS.test.slice(0, 12).map((c) => ({
+        title: chalk8.yellow(c),
+        value: c,
+        selected: detected?.commands?.test === c
+      })),
+      hint: chalk8.gray("space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    const lintResponse = await prompts4({
+      type: "multiselect",
+      name: "lint",
+      message: chalk8.white("Lint/format commands:"),
+      choices: COMMON_COMMANDS.lint.slice(0, 12).map((c) => ({
+        title: chalk8.green(c),
+        value: c,
+        selected: detected?.commands?.lint === c
+      })),
+      hint: chalk8.gray("space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    const devResponse = await prompts4({
+      type: "multiselect",
+      name: "dev",
+      message: chalk8.white("Dev server commands:"),
+      choices: COMMON_COMMANDS.dev.slice(0, 12).map((c) => ({
+        title: chalk8.magenta(c),
+        value: c,
+        selected: detected?.commands?.dev === c
+      })),
+      hint: chalk8.gray("space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    answers.commands = {
+      build: buildResponse.build || [],
+      test: testResponse.test || [],
+      lint: lintResponse.lint || [],
+      dev: devResponse.dev || []
+    };
+    const customCmdResponse = await prompts4({
+      type: "text",
+      name: "custom",
+      message: chalk8.white("Additional custom command (optional):"),
+      hint: chalk8.gray("e.g., npm run migrate, make deploy")
+    }, promptConfig);
+    if (customCmdResponse.custom) {
+      answers.commands.custom = customCmdResponse.custom;
+    }
+  } else {
+    answers.commands = detected?.commands || {};
+  }
+  if (canAccessTier(userTier, "intermediate")) {
+    const styleStep = getCurrentStep("code_style");
+    showStep(currentStepNum, styleStep, userTier);
+    const namingResponse = await prompts4({
+      type: "select",
+      name: "naming",
+      message: chalk8.white("Naming convention:"),
+      choices: NAMING_CONVENTIONS.map((n) => ({
+        title: n.label,
+        value: n.id,
+        description: chalk8.gray(n.desc)
+      })),
+      initial: 0
+    }, promptConfig);
+    answers.namingConvention = namingResponse.naming || "language_default";
+    const errorResponse = await prompts4({
+      type: "select",
+      name: "errorHandling",
+      message: chalk8.white("Error handling pattern:"),
+      choices: ERROR_PATTERNS.map((e) => ({
+        title: e.label,
+        value: e.id
+      })),
+      initial: 0
+    }, promptConfig);
+    answers.errorHandling = errorResponse.errorHandling || "try_catch";
+    const styleNotesResponse = await prompts4({
+      type: "text",
+      name: "styleNotes",
+      message: chalk8.white("Additional style notes (optional):"),
+      hint: chalk8.gray("e.g., prefer named exports, max line length 100")
+    }, promptConfig);
+    answers.styleNotes = styleNotesResponse.styleNotes || "";
+  }
+  const aiStep = getCurrentStep("ai");
+  showStep(currentStepNum, aiStep, userTier);
+  const aiBehaviorResponse = await prompts4({
+    type: "multiselect",
+    name: "aiBehavior",
+    message: chalk8.white("AI behavior rules:"),
+    choices: AI_BEHAVIOR_RULES.map((r) => ({
+      title: r.recommended ? `${r.label} ${chalk8.green("\u2605")}` : r.label,
+      value: r.id,
+      selected: r.recommended
+    })),
+    hint: chalk8.gray("space select \u2022 enter confirm"),
+    instructions: false
+  }, promptConfig);
+  answers.aiBehavior = aiBehaviorResponse.aiBehavior || [];
+  const importantFilesResponse = await prompts4({
+    type: "multiselect",
+    name: "importantFiles",
+    message: chalk8.white("Important files AI should read:"),
+    choices: IMPORTANT_FILES.map((f) => ({
+      title: `${f.icon} ${f.label}`,
+      value: f.id,
+      selected: f.id === "readme" || f.id === "package"
+    })),
+    hint: chalk8.gray("space select \u2022 enter confirm"),
+    instructions: false
+  }, promptConfig);
+  answers.importantFiles = importantFilesResponse.importantFiles || [];
+  const selfImproveResponse = await prompts4({
+    type: "toggle",
+    name: "selfImprove",
+    message: chalk8.white("Enable self-improving blueprint?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.selfImprove = selfImproveResponse.selfImprove || false;
+  if (canAccessTier(userTier, "advanced")) {
+    const boundariesStep = getCurrentStep("boundaries");
+    showStep(currentStepNum, boundariesStep, userTier);
+    const presetResponse = await prompts4({
+      type: "select",
+      name: "boundaryPreset",
+      message: chalk8.white("Boundary preset:"),
+      choices: BOUNDARY_PRESETS.map((b) => ({
+        title: b.title,
+        value: b.value,
+        description: chalk8.gray(b.description)
+      })),
+      initial: 0
+    }, promptConfig);
+    answers.boundaries = presetResponse.boundaryPreset || "standard";
+    const selectedPreset = BOUNDARY_PRESETS.find((b) => b.value === answers.boundaries);
+    if (selectedPreset) {
+      console.log();
+      console.log(chalk8.gray("  Preset details:"));
+      console.log(chalk8.green(`    \u2713 Always: ${selectedPreset.always.slice(0, 3).join(", ")}`));
+      console.log(chalk8.yellow(`    ? Ask: ${selectedPreset.askFirst.slice(0, 2).join(", ")}`));
+      console.log(chalk8.red(`    \u2717 Never: ${selectedPreset.never.slice(0, 2).join(", ")}`));
+    }
+    const customizeResponse = await prompts4({
+      type: "toggle",
+      name: "customize",
+      message: chalk8.white("Customize specific boundaries?"),
+      initial: false,
+      active: "Yes",
+      inactive: "No"
+    }, promptConfig);
+    if (customizeResponse.customize) {
+      console.log();
+      console.log(chalk8.gray("  Select actions AI should NEVER do:"));
+      const neverResponse = await prompts4({
+        type: "multiselect",
+        name: "never",
+        message: chalk8.white("Never allow:"),
+        choices: BOUNDARY_OPTIONS.map((o) => ({
+          title: chalk8.red(o),
+          value: o,
+          selected: selectedPreset?.never.includes(o)
+        })),
+        instructions: false
+      }, promptConfig);
+      answers.boundaryNever = neverResponse.never || [];
+      console.log(chalk8.gray("  Select actions AI should ASK before doing:"));
+      const askResponse = await prompts4({
+        type: "multiselect",
+        name: "ask",
+        message: chalk8.white("Ask first:"),
+        choices: BOUNDARY_OPTIONS.filter((o) => !answers.boundaryNever?.includes(o)).map((o) => ({
+          title: chalk8.yellow(o),
+          value: o,
+          selected: selectedPreset?.askFirst.includes(o)
+        })),
+        instructions: false
+      }, promptConfig);
+      answers.boundaryAsk = askResponse.ask || [];
+    }
+  } else {
+    answers.boundaries = options.boundaries || "standard";
+  }
+  if (canAccessTier(userTier, "advanced")) {
+    const testingStep = getCurrentStep("testing");
+    showStep(currentStepNum, testingStep, userTier);
+    const testLevelsResponse = await prompts4({
+      type: "multiselect",
+      name: "testLevels",
+      message: chalk8.white("Test levels:"),
+      choices: TEST_LEVELS.map((l) => ({
+        title: `${l.label} - ${chalk8.gray(l.desc)}`,
+        value: l.id,
+        selected: l.id === "unit" || l.id === "integration"
+      })),
+      instructions: false
+    }, promptConfig);
+    answers.testLevels = testLevelsResponse.testLevels || [];
+    const detectedFrameworks = answers.stack?.includes("typescript") || answers.stack?.includes("javascript") ? ["jest", "vitest"] : answers.stack?.includes("python") ? ["pytest"] : [];
+    const testFrameworkResponse = await prompts4({
+      type: "multiselect",
+      name: "testFrameworks",
+      message: chalk8.white("Testing frameworks:"),
+      choices: TEST_FRAMEWORKS.slice(0, 16).map((f) => ({
+        title: f,
+        value: f,
+        selected: detectedFrameworks.includes(f)
+      })),
+      hint: chalk8.gray("space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    answers.testFrameworks = testFrameworkResponse.testFrameworks || [];
+    const coverageResponse = await prompts4({
+      type: "number",
+      name: "coverage",
+      message: chalk8.white("Target code coverage (%):"),
+      initial: 80,
+      min: 0,
+      max: 100
+    }, promptConfig);
+    answers.coverageTarget = coverageResponse.coverage ?? 80;
+    const testNotesResponse = await prompts4({
+      type: "text",
+      name: "testNotes",
+      message: chalk8.white("Testing notes (optional):"),
+      hint: chalk8.gray("e.g., run e2e on main only, use msw for mocking")
+    }, promptConfig);
+    answers.testNotes = testNotesResponse.testNotes || "";
+  }
+  if (canAccessTier(userTier, "advanced")) {
+    const staticStep = getCurrentStep("static");
+    showStep(currentStepNum, staticStep, userTier);
+    console.log(chalk8.gray("  Generate additional project files:"));
+    console.log();
+    const staticFilesResponse = await prompts4({
+      type: "multiselect",
+      name: "staticFiles",
+      message: chalk8.white("Include static files:"),
+      choices: [
+        { title: "\u{1F4DD} .editorconfig", value: "editorconfig", description: chalk8.gray("Consistent code formatting") },
+        { title: "\u{1F91D} CONTRIBUTING.md", value: "contributing", description: chalk8.gray("Contributor guidelines") },
+        { title: "\u{1F4DC} CODE_OF_CONDUCT.md", value: "codeOfConduct", description: chalk8.gray("Community standards") },
+        { title: "\u{1F512} SECURITY.md", value: "security", description: chalk8.gray("Vulnerability reporting") },
+        { title: "\u{1F5FA}\uFE0F  ROADMAP.md", value: "roadmap", description: chalk8.gray("Project roadmap") },
+        { title: "\u{1F4CB} .gitignore", value: "gitignore", description: chalk8.gray("Git ignore patterns"), selected: true }
+      ],
+      hint: chalk8.gray("space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    answers.staticFiles = staticFilesResponse.staticFiles || [];
+    if (answers.repoHost === "github" && answers.isPublic) {
+      const fundingResponse = await prompts4({
+        type: "toggle",
+        name: "funding",
+        message: chalk8.white("Generate FUNDING.yml for GitHub Sponsors?"),
+        initial: false,
+        active: "Yes",
+        inactive: "No"
+      }, promptConfig);
+      answers.includeFunding = fundingResponse.funding || false;
+    }
+  }
+  const extraStep = getCurrentStep("extra");
+  showStep(currentStepNum, extraStep, userTier);
   const personaResponse = await prompts4({
     type: "select",
     name: "persona",
-    message: "AI persona:",
-    choices: PERSONAS,
+    message: chalk8.white("AI assistant persona:"),
+    choices: [
+      { title: "\u{1F9D1}\u200D\u{1F4BB} Full-Stack Developer", value: "fullstack", description: chalk8.gray("Complete application development") },
+      { title: "\u2699\uFE0F  Backend Developer", value: "backend", description: chalk8.gray("APIs, databases, services") },
+      { title: "\u{1F3A8} Frontend Developer", value: "frontend", description: chalk8.gray("UI, components, styling") },
+      { title: "\u{1F680} DevOps Engineer", value: "devops", description: chalk8.gray("Infrastructure, CI/CD") },
+      { title: "\u{1F4CA} Data Engineer", value: "data", description: chalk8.gray("Pipelines, ETL, analytics") },
+      { title: "\u{1F512} Security Engineer", value: "security", description: chalk8.gray("Secure code, auditing") },
+      { title: "\u270F\uFE0F  Custom...", value: "custom", description: chalk8.gray("Define your own") }
+    ],
     initial: 0
-    // Full-stack by default
-  });
+  }, promptConfig);
   if (personaResponse.persona === "custom") {
     const customPersona = await prompts4({
       type: "text",
       name: "value",
-      message: "Describe the custom persona:"
-    });
+      message: chalk8.white("Describe the custom persona:"),
+      hint: chalk8.gray("e.g., 'ML engineer focused on PyTorch'")
+    }, promptConfig);
     answers.persona = customPersona.value || "fullstack";
   } else {
     answers.persona = personaResponse.persona || "fullstack";
   }
-  const boundaryResponse = await prompts4({
-    type: "select",
-    name: "boundaries",
-    message: "AI boundaries:",
-    choices: BOUNDARY_PRESETS.map((b) => ({ title: b.title, value: b.value })),
-    initial: 0
-    // Standard by default
-  });
-  answers.boundaries = boundaryResponse.boundaries || "standard";
-  if (detected?.commands && Object.keys(detected.commands).length > 0) {
-    console.log();
-    console.log(chalk8.gray("Auto-detected commands:"));
-    if (detected.commands.build) console.log(chalk8.gray(`  Build: ${detected.commands.build}`));
-    if (detected.commands.test) console.log(chalk8.gray(`  Test: ${detected.commands.test}`));
-    if (detected.commands.lint) console.log(chalk8.gray(`  Lint: ${detected.commands.lint}`));
-    if (detected.commands.dev) console.log(chalk8.gray(`  Dev: ${detected.commands.dev}`));
-    const editCommands = await prompts4({
-      type: "confirm",
-      name: "edit",
-      message: "Edit commands?",
-      initial: false
-    });
-    if (editCommands.edit) {
-      const commandsResponse = await prompts4([
-        { type: "text", name: "build", message: "Build:", initial: detected.commands.build },
-        { type: "text", name: "test", message: "Test:", initial: detected.commands.test },
-        { type: "text", name: "lint", message: "Lint:", initial: detected.commands.lint },
-        { type: "text", name: "dev", message: "Dev:", initial: detected.commands.dev }
-      ]);
-      answers.commands = commandsResponse;
-    } else {
-      answers.commands = detected.commands;
-    }
-  } else {
-    answers.commands = {};
-  }
+  const extraNotesResponse = await prompts4({
+    type: "text",
+    name: "extraNotes",
+    message: chalk8.white("Anything else AI should know? (optional):"),
+    hint: chalk8.gray("Special requirements, gotchas, team conventions...")
+  }, promptConfig);
+  answers.extraNotes = extraNotesResponse.extraNotes || "";
+  console.log();
+  console.log(chalk8.green("  \u2705 All steps completed!"));
+  console.log();
   return {
     name: answers.name,
     description: answers.description,
@@ -2537,7 +3484,28 @@ async function runInteractiveWizard(options, detected) {
     platforms: answers.platforms,
     persona: answers.persona,
     boundaries: answers.boundaries,
-    commands: answers.commands
+    commands: typeof answers.commands === "object" ? answers.commands : detected?.commands || {},
+    // Extended config for Pro/Max users
+    projectType: answers.projectType,
+    repoHost: answers.repoHost,
+    isPublic: answers.isPublic,
+    license: answers.license,
+    conventionalCommits: answers.conventionalCommits,
+    namingConvention: answers.namingConvention,
+    errorHandling: answers.errorHandling,
+    styleNotes: answers.styleNotes,
+    aiBehavior: answers.aiBehavior,
+    importantFiles: answers.importantFiles,
+    selfImprove: answers.selfImprove,
+    boundaryNever: answers.boundaryNever,
+    boundaryAsk: answers.boundaryAsk,
+    testLevels: answers.testLevels,
+    testFrameworks: answers.testFrameworks,
+    coverageTarget: answers.coverageTarget,
+    testNotes: answers.testNotes,
+    staticFiles: answers.staticFiles,
+    includeFunding: answers.includeFunding,
+    extraNotes: answers.extraNotes
   };
 }
 
@@ -2604,7 +3572,7 @@ function handleApiError3(error) {
 
 // src/commands/status.ts
 import chalk10 from "chalk";
-import { access as access6, readFile as readFile6, readdir as readdir3 } from "fs/promises";
+import { readFile as readFile5, readdir, access as access4 } from "fs/promises";
 import { join as join7 } from "path";
 import { existsSync as existsSync4 } from "fs";
 var CONFIG_FILES = [
@@ -2634,7 +3602,7 @@ async function statusCommand() {
     const configPath = join7(cwd, ".lynxprompt/conf.yml");
     if (existsSync4(configPath)) {
       try {
-        const content = await readFile6(configPath, "utf-8");
+        const content = await readFile5(configPath, "utf-8");
         const { parse: parse5 } = await import("yaml");
         const config2 = parse5(content);
         if (config2?.exporters?.length > 0) {
@@ -2677,8 +3645,8 @@ async function statusCommand() {
   for (const config2 of CONFIG_FILES) {
     const filePath = join7(cwd, config2.path);
     try {
-      await access6(filePath);
-      const content = await readFile6(filePath, "utf-8");
+      await access4(filePath);
+      const content = await readFile5(filePath, "utf-8");
       const lines = content.split("\n").length;
       const size = formatBytes(content.length);
       foundAny = true;
@@ -2699,7 +3667,7 @@ async function statusCommand() {
     const dirPath = join7(cwd, config2.path);
     if (existsSync4(dirPath)) {
       try {
-        const files = await readdir3(dirPath);
+        const files = await readdir(dirPath);
         const ruleFiles = files.filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
         if (ruleFiles.length > 0) {
           foundAny = true;
@@ -2757,7 +3725,7 @@ function formatBytes(bytes) {
 import chalk11 from "chalk";
 import ora9 from "ora";
 import prompts5 from "prompts";
-import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir5, readdir as readdir4 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5, readdir as readdir2 } from "fs/promises";
 import { join as join8, dirname as dirname5 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import * as yaml3 from "yaml";
@@ -2778,7 +3746,7 @@ async function syncCommand(options = {}) {
   const spinner = ora9("Loading configuration...").start();
   let config2;
   try {
-    const configContent = await readFile7(configPath, "utf-8");
+    const configContent = await readFile6(configPath, "utf-8");
     config2 = yaml3.parse(configContent);
     spinner.succeed("Configuration loaded");
   } catch (error) {
@@ -2875,12 +3843,12 @@ async function syncCommand(options = {}) {
 async function loadRules(rulesPath) {
   const files = [];
   try {
-    const entries = await readdir4(rulesPath, { withFileTypes: true });
+    const entries = await readdir2(rulesPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".md")) continue;
       const filePath = join8(rulesPath, entry.name);
-      const content = await readFile7(filePath, "utf-8");
+      const content = await readFile6(filePath, "utf-8");
       if (content.trim()) {
         files.push({ name: entry.name, content: content.trim() });
       }
@@ -2930,7 +3898,7 @@ function formatForAgent(agent, content) {
       return content;
   }
 }
-function formatAsMdc(content, agent) {
+function formatAsMdc(content, _agent) {
   const frontmatter = yaml3.stringify({
     description: "LynxPrompt rules - AI coding guidelines",
     globs: ["**/*"],
@@ -2941,7 +3909,7 @@ ${frontmatter}---
 
 ${content}`;
 }
-function formatAsMarkdown(content, agent) {
+function formatAsMarkdown(content, _agent) {
   const header = `# AI Coding Rules
 
 > Generated by [LynxPrompt](https://lynxprompt.com)
@@ -2949,7 +3917,7 @@ function formatAsMarkdown(content, agent) {
 `;
   return header + content;
 }
-function formatAsJson(content, agent) {
+function formatAsJson(content, _agent) {
   return JSON.stringify(
     {
       $schema: "https://lynxprompt.com/schemas/rules.json",
@@ -2968,7 +3936,7 @@ function formatAsJson(content, agent) {
 // src/commands/agents.ts
 import chalk12 from "chalk";
 import prompts6 from "prompts";
-import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
 import { join as join9 } from "path";
 import { existsSync as existsSync6 } from "fs";
 import * as yaml4 from "yaml";
@@ -3170,7 +4138,7 @@ async function loadConfig() {
     return null;
   }
   try {
-    const content = await readFile8(configPath, "utf-8");
+    const content = await readFile7(configPath, "utf-8");
     return yaml4.parse(content);
   } catch {
     return null;
@@ -3186,7 +4154,7 @@ async function saveConfig(config2) {
 // src/commands/check.ts
 import chalk13 from "chalk";
 import ora10 from "ora";
-import { readFile as readFile9, readdir as readdir5, stat as stat2 } from "fs/promises";
+import { readFile as readFile8, readdir as readdir3, stat } from "fs/promises";
 import { join as join10 } from "path";
 import { existsSync as existsSync7 } from "fs";
 import * as yaml5 from "yaml";
@@ -3252,7 +4220,7 @@ async function validateLynxPromptConfig(cwd) {
     return { errors, warnings };
   }
   try {
-    const content = await readFile9(configPath, "utf-8");
+    const content = await readFile8(configPath, "utf-8");
     const config2 = yaml5.parse(content);
     if (!config2.version) {
       warnings.push(".lynxprompt/conf.yml: Missing 'version' field");
@@ -3325,7 +4293,7 @@ async function checkCommand(options = {}) {
     if (existsSync7(filePath)) {
       result.files.push(file.path);
       try {
-        const content = await readFile9(filePath, "utf-8");
+        const content = await readFile8(filePath, "utf-8");
         const validation = validateMarkdown(content, file.path);
         result.errors.push(...validation.errors);
         result.warnings.push(...validation.warnings);
@@ -3338,13 +4306,13 @@ async function checkCommand(options = {}) {
     const dirPath = join10(cwd, dir.path);
     if (existsSync7(dirPath)) {
       try {
-        const files = await readdir5(dirPath);
+        const files = await readdir3(dirPath);
         for (const file of files) {
           const filePath = join10(dirPath, file);
-          const fileStat = await stat2(filePath);
+          const fileStat = await stat(filePath);
           if (fileStat.isFile()) {
             result.files.push(`${dir.path}/${file}`);
-            const content = await readFile9(filePath, "utf-8");
+            const content = await readFile8(filePath, "utf-8");
             if (file.endsWith(".mdc")) {
               const validation = validateMdc(content, `${dir.path}/${file}`);
               result.errors.push(...validation.errors);
@@ -3420,7 +4388,7 @@ async function checkCommand(options = {}) {
 // src/commands/diff.ts
 import chalk14 from "chalk";
 import ora11 from "ora";
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { join as join11 } from "path";
 import { existsSync as existsSync8 } from "fs";
 function computeDiff(oldText, newText) {
@@ -3484,7 +4452,6 @@ function longestCommonSubsequence(a, b) {
 function formatDiff(diff, contextLines = 3) {
   const output = [];
   let lastPrintedIndex = -1;
-  let inHunk = false;
   const changeIndices = diff.map((d, i) => d.type !== "same" ? i : -1).filter((i) => i !== -1);
   if (changeIndices.length === 0) {
     return chalk14.gray("  (no changes)");
@@ -3515,7 +4482,7 @@ function getDiffStats(diff) {
     unchanged: diff.filter((d) => d.type === "same").length
   };
 }
-async function diffCommand(blueprintId, options = {}) {
+async function diffCommand(fileOrId, options = {}) {
   console.log();
   console.log(chalk14.cyan("\u{1F431} LynxPrompt Diff"));
   console.log();
@@ -3524,14 +4491,90 @@ async function diffCommand(blueprintId, options = {}) {
     await diffLocal(cwd);
     return;
   }
-  if (!blueprintId) {
-    console.log(chalk14.red("\u2717 Please provide a blueprint ID to compare with."));
+  const trackedFiles = await checkSyncStatus(cwd);
+  if (fileOrId) {
+    const tracked = await findBlueprintByFile(cwd, fileOrId);
+    if (tracked) {
+      await diffFileWithBlueprint(cwd, fileOrId, tracked.id);
+      return;
+    }
+    await diffWithBlueprintId(cwd, fileOrId);
+    return;
+  }
+  if (trackedFiles.length === 0) {
+    console.log(chalk14.yellow("No tracked blueprints found."));
+    console.log();
+    console.log(chalk14.gray("To track a blueprint and compare changes:"));
+    console.log(chalk14.gray("  1. Pull a blueprint: lynxp pull <blueprint-id>"));
+    console.log(chalk14.gray("  2. Or link an existing file: lynxp link"));
     console.log();
-    console.log(chalk14.gray("Usage:"));
-    console.log(chalk14.gray("  lynxp diff <blueprint-id>    Compare local with remote blueprint"));
-    console.log(chalk14.gray("  lynxp diff --local           Compare .lynxprompt/rules/ with exports"));
+    console.log(chalk14.gray("Other options:"));
+    console.log(chalk14.gray("  lynxp diff --local    Compare .lynxprompt/rules/ with exported files"));
     return;
   }
+  let hasChanges = false;
+  for (const { blueprint, localModified, fileExists: fileExists2 } of trackedFiles) {
+    if (!fileExists2) {
+      console.log(chalk14.red(`\u2717 ${blueprint.file} - file not found`));
+      continue;
+    }
+    console.log(chalk14.cyan(`\u{1F4C4} ${blueprint.file}`));
+    console.log(chalk14.gray(`   Linked to: ${blueprint.name} (${blueprint.id})`));
+    if (localModified) {
+      hasChanges = true;
+      await diffFileWithBlueprint(cwd, blueprint.file, blueprint.id, true);
+    } else {
+      console.log(chalk14.green("   \u2713 In sync with cloud"));
+    }
+    console.log();
+  }
+  if (!hasChanges) {
+    console.log(chalk14.green("\u2713 All tracked files are in sync with their cloud blueprints!"));
+  } else {
+    console.log(chalk14.gray("To push local changes: lynxp push"));
+    console.log(chalk14.gray("To pull cloud changes: lynxp pull <id>"));
+  }
+  console.log();
+}
+async function diffFileWithBlueprint(cwd, file, blueprintId, compact = false) {
+  const filePath = join11(cwd, file);
+  if (!existsSync8(filePath)) {
+    console.log(chalk14.red(`\u2717 File not found: ${file}`));
+    return;
+  }
+  const spinner = compact ? null : ora11("Fetching blueprint...").start();
+  try {
+    const { blueprint } = await api.getBlueprint(blueprintId);
+    spinner?.stop();
+    if (!blueprint || !blueprint.content) {
+      console.log(chalk14.red(`\u2717 Blueprint has no content`));
+      return;
+    }
+    const localContent = await readFile9(filePath, "utf-8");
+    const diff = computeDiff(blueprint.content, localContent);
+    const stats = getDiffStats(diff);
+    if (stats.added === 0 && stats.removed === 0) {
+      if (!compact) {
+        console.log(chalk14.green("\u2713 Files are identical!"));
+      }
+    } else {
+      if (!compact) {
+        console.log(chalk14.gray("Changes (cloud \u2192 local):"));
+        console.log();
+      }
+      console.log(formatDiff(diff));
+      console.log(chalk14.gray(`   ${chalk14.green(`+${stats.added}`)} ${chalk14.red(`-${stats.removed}`)} lines`));
+    }
+  } catch (error) {
+    spinner?.stop();
+    if (error instanceof ApiRequestError) {
+      console.log(chalk14.red(`\u2717 Could not fetch blueprint: ${error.message}`));
+    } else {
+      console.log(chalk14.red("\u2717 Failed to compare"));
+    }
+  }
+}
+async function diffWithBlueprintId(cwd, blueprintId) {
   if (!isAuthenticated()) {
     console.log(chalk14.yellow("\u26A0 Not logged in. Some blueprints may not be accessible."));
     console.log(chalk14.gray("Run 'lynxp login' to authenticate."));
@@ -3563,7 +4606,7 @@ async function diffCommand(blueprintId, options = {}) {
       const fullPath = join11(cwd, path2);
       if (existsSync8(fullPath)) {
         try {
-          localContent = await readFile10(fullPath, "utf-8");
+          localContent = await readFile9(fullPath, "utf-8");
           localPath = path2;
           break;
         } catch {
@@ -3625,7 +4668,7 @@ async function diffLocal(cwd) {
   }
   let rulesContent;
   try {
-    rulesContent = await readFile10(rulesPath, "utf-8");
+    rulesContent = await readFile9(rulesPath, "utf-8");
   } catch {
     console.log(chalk14.red("\u2717 Could not read .lynxprompt/rules/agents.md"));
     return;
@@ -3639,7 +4682,7 @@ async function diffLocal(cwd) {
     const filePath = join11(cwd, file.path);
     if (existsSync8(filePath)) {
       try {
-        const exportedContent = await readFile10(filePath, "utf-8");
+        const exportedContent = await readFile9(filePath, "utf-8");
         let compareContent = exportedContent;
         if (file.path.endsWith(".mdc")) {
           const frontmatterEnd = exportedContent.indexOf("---", 3);
@@ -3691,33 +4734,53 @@ function getSourceFromVisibility2(visibility) {
       return "marketplace";
   }
 }
-async function linkCommand(file, blueprintId, options = {}) {
+async function linkCommand(fileArg, blueprintIdArg, options = {}) {
   const cwd = process.cwd();
   if (options.list) {
     await listTrackedBlueprints(cwd);
     return;
   }
-  if (!file) {
-    console.log(chalk15.red("\u2717 Please provide a file path to link."));
-    console.log();
-    console.log(chalk15.gray("Usage:"));
-    console.log(chalk15.gray("  lynxp link <file> <blueprint-id>   Link a local file to a cloud blueprint"));
-    console.log(chalk15.gray("  lynxp link --list                  List all tracked blueprints"));
-    console.log();
-    console.log(chalk15.gray("Example:"));
-    console.log(chalk15.gray("  lynxp link AGENTS.md bp_abc123"));
-    return;
-  }
-  if (!blueprintId) {
-    console.log(chalk15.red("\u2717 Please provide a blueprint ID to link to."));
-    console.log();
-    console.log(chalk15.gray("Usage: lynxp link <file> <blueprint-id>"));
-    console.log(chalk15.gray("Example: lynxp link AGENTS.md bp_abc123"));
-    console.log();
-    console.log(chalk15.gray("To find blueprint IDs:"));
-    console.log(chalk15.gray("  lynxp list      - Show your blueprints"));
-    console.log(chalk15.gray("  lynxp search <query>  - Search marketplace"));
-    return;
+  console.log();
+  console.log(chalk15.cyan("\u{1F431} Link File to Blueprint"));
+  console.log();
+  let file;
+  let blueprintId = blueprintIdArg;
+  if (!fileArg) {
+    const configFiles = [
+      "AGENTS.md",
+      "CLAUDE.md",
+      ".cursor/rules/project.mdc",
+      ".github/copilot-instructions.md",
+      ".windsurfrules",
+      ".zed/instructions.md",
+      ".clinerules"
+    ];
+    const foundFiles = configFiles.filter((f) => existsSync9(join12(cwd, f)));
+    if (foundFiles.length === 0) {
+      console.log(chalk15.yellow("No AI configuration files found in this directory."));
+      console.log();
+      console.log(chalk15.gray("Create one first:"));
+      console.log(chalk15.gray("  lynxp wizard    Generate a new config file"));
+      console.log(chalk15.gray("  lynxp pull <id> Download from marketplace"));
+      return;
+    }
+    const { selectedFile } = await prompts7({
+      type: "select",
+      name: "selectedFile",
+      message: "Which file do you want to link to a cloud blueprint?",
+      choices: foundFiles.map((f) => ({
+        title: f,
+        value: f,
+        description: "Local file exists"
+      }))
+    });
+    if (!selectedFile) {
+      console.log(chalk15.gray("Cancelled."));
+      return;
+    }
+    file = selectedFile;
+  } else {
+    file = fileArg;
   }
   const filePath = join12(cwd, file);
   if (!existsSync9(filePath)) {
@@ -3726,7 +4789,9 @@ async function linkCommand(file, blueprintId, options = {}) {
   }
   const existing = await findBlueprintByFile(cwd, file);
   if (existing) {
-    console.log(chalk15.yellow(`\u26A0 This file is already linked to: ${existing.id}`));
+    console.log(chalk15.yellow(`This file is already linked to: ${existing.name}`));
+    console.log(chalk15.gray(`   ID: ${existing.id}`));
+    console.log();
     const { proceed } = await prompts7({
       type: "confirm",
       name: "proceed",
@@ -3738,11 +4803,120 @@ async function linkCommand(file, blueprintId, options = {}) {
       return;
     }
   }
-  if (!isAuthenticated()) {
-    console.log(
-      chalk15.yellow("Not logged in. Run 'lynxp login' to authenticate.")
-    );
-    process.exit(1);
+  if (!blueprintId) {
+    if (!isAuthenticated()) {
+      console.log(chalk15.yellow("You need to login to access your blueprints."));
+      const { doLogin } = await prompts7({
+        type: "confirm",
+        name: "doLogin",
+        message: "Login now?",
+        initial: true
+      });
+      if (doLogin) {
+        console.log(chalk15.gray("Run 'lynxp login' in another terminal, then come back here."));
+        return;
+      }
+      console.log(chalk15.gray("Cancelled."));
+      return;
+    }
+    const { searchMethod } = await prompts7({
+      type: "select",
+      name: "searchMethod",
+      message: "How do you want to find the blueprint?",
+      choices: [
+        { title: "\u{1F4CB} From my blueprints", value: "list" },
+        { title: "\u{1F50D} Search marketplace", value: "search" },
+        { title: "\u{1F522} Enter ID directly", value: "manual" }
+      ]
+    });
+    if (!searchMethod) {
+      console.log(chalk15.gray("Cancelled."));
+      return;
+    }
+    if (searchMethod === "list") {
+      const spinner2 = ora12("Fetching your blueprints...").start();
+      try {
+        const { blueprints } = await api.listBlueprints();
+        spinner2.stop();
+        if (!blueprints || blueprints.length === 0) {
+          console.log(chalk15.yellow("You don't have any blueprints yet."));
+          console.log(chalk15.gray("Create one with 'lynxp push' or search the marketplace."));
+          return;
+        }
+        const { selected } = await prompts7({
+          type: "select",
+          name: "selected",
+          message: "Select a blueprint:",
+          choices: blueprints.map((b) => ({
+            title: b.name,
+            value: b.id,
+            description: b.description?.substring(0, 50) || ""
+          }))
+        });
+        if (!selected) {
+          console.log(chalk15.gray("Cancelled."));
+          return;
+        }
+        blueprintId = selected;
+      } catch {
+        spinner2.stop();
+        console.log(chalk15.red("\u2717 Could not fetch blueprints"));
+        return;
+      }
+    } else if (searchMethod === "search") {
+      const { query } = await prompts7({
+        type: "text",
+        name: "query",
+        message: "Search for:"
+      });
+      if (!query) {
+        console.log(chalk15.gray("Cancelled."));
+        return;
+      }
+      const spinner2 = ora12(`Searching for "${query}"...`).start();
+      try {
+        const results = await api.searchBlueprints(query, 10);
+        spinner2.stop();
+        if (!results.templates || results.templates.length === 0) {
+          console.log(chalk15.yellow(`No blueprints found for "${query}"`));
+          return;
+        }
+        const { selected } = await prompts7({
+          type: "select",
+          name: "selected",
+          message: "Select a blueprint:",
+          choices: results.templates.map((b) => ({
+            title: `${b.name} (\u2605 ${b.likes})`,
+            value: b.id,
+            description: b.author ? `by ${b.author}` : ""
+          }))
+        });
+        if (!selected) {
+          console.log(chalk15.gray("Cancelled."));
+          return;
+        }
+        blueprintId = selected;
+      } catch {
+        spinner2.stop();
+        console.log(chalk15.red("\u2717 Search failed"));
+        return;
+      }
+    } else {
+      const { manualId } = await prompts7({
+        type: "text",
+        name: "manualId",
+        message: "Enter blueprint ID:"
+      });
+      if (!manualId) {
+        console.log(chalk15.gray("Cancelled."));
+        return;
+      }
+      blueprintId = manualId;
+    }
+  }
+  if (!blueprintId) {
+    console.log(chalk15.red("\u2717 No blueprint ID provided."));
+    return;
   }
   const spinner = ora12(`Fetching blueprint ${chalk15.cyan(blueprintId)}...`).start();
   try {
@@ -3778,11 +4952,10 @@ async function linkCommand(file, blueprintId, options = {}) {
     console.log(chalk15.green(`\u2705 Linked: ${file} \u2192 ${blueprint.id}`));
     console.log();
     console.log(chalk15.gray("Next steps:"));
-    console.log(chalk15.gray(`  \u2022 Run 'lynxp pull ${blueprintId}' to update local file from cloud`));
-    console.log(chalk15.gray(`  \u2022 Run 'lynxp diff ${blueprintId}' to see differences`));
+    console.log(chalk15.gray(`  \u2022 Run 'lynxp diff' to see differences`));
     console.log(chalk15.gray(`  \u2022 Run 'lynxp status' to see all tracked blueprints`));
     if (!isMarketplace) {
-      console.log(chalk15.gray(`  \u2022 Run 'lynxp push ${file}' to push local changes to cloud`));
+      console.log(chalk15.gray(`  \u2022 Run 'lynxp push' to push local changes to cloud`));
     }
     console.log();
   } catch (error) {
@@ -3801,23 +4974,43 @@ async function linkCommand(file, blueprintId, options = {}) {
     }
   }
 }
-async function unlinkCommand(file) {
+async function unlinkCommand(fileArg) {
   const cwd = process.cwd();
-  if (!file) {
-    console.log(chalk15.red("\u2717 Please provide a file path to unlink."));
-    console.log();
-    console.log(chalk15.gray("Usage: lynxp unlink <file>"));
-    console.log(chalk15.gray("Example: lynxp unlink AGENTS.md"));
-    return;
+  console.log();
+  console.log(chalk15.cyan("\u{1F431} Unlink File from Blueprint"));
+  console.log();
+  let file;
+  if (!fileArg) {
+    const status = await checkSyncStatus(cwd);
+    if (status.length === 0) {
+      console.log(chalk15.yellow("No files are currently linked to blueprints."));
+      return;
+    }
+    const { selectedFile } = await prompts7({
+      type: "select",
+      name: "selectedFile",
+      message: "Which file do you want to unlink?",
+      choices: status.map(({ blueprint }) => ({
+        title: blueprint.file,
+        value: blueprint.file,
+        description: `${blueprint.name} (${blueprint.source})`
+      }))
+    });
+    if (!selectedFile) {
+      console.log(chalk15.gray("Cancelled."));
+      return;
+    }
+    file = selectedFile;
+  } else {
+    file = fileArg;
   }
   const tracked = await findBlueprintByFile(cwd, file);
   if (!tracked) {
-    console.log(chalk15.yellow(`\u26A0 File is not linked to any blueprint: ${file}`));
+    console.log(chalk15.yellow(`File is not linked to any blueprint: ${file}`));
     return;
   }
-  console.log();
-  console.log(chalk15.cyan(`Currently linked to: ${tracked.id}`));
-  console.log(chalk15.gray(`   Name: ${tracked.name}`));
+  console.log(chalk15.gray(`Currently linked to: ${tracked.name}`));
+  console.log(chalk15.gray(`   ID: ${tracked.id}`));
   console.log(chalk15.gray(`   Source: ${tracked.source}`));
   console.log();
   const { confirm } = await prompts7({
@@ -3834,8 +5027,7 @@ async function unlinkCommand(file) {
   if (success) {
     console.log();
     console.log(chalk15.green(`\u2705 Unlinked: ${file}`));
-    console.log(chalk15.gray("  The file is now a standalone local file."));
-    console.log(chalk15.gray("  It will no longer receive updates from the cloud blueprint."));
+    console.log(chalk15.gray("  The file is now standalone. Changes won't sync with the cloud."));
     console.log();
   } else {
     console.log(chalk15.red("\u2717 Failed to unlink file."));
@@ -3851,7 +5043,7 @@ async function listTrackedBlueprints(cwd) {
     console.log();
     console.log(chalk15.gray("To track a blueprint:"));
     console.log(chalk15.gray("  lynxp pull <blueprint-id>     Download and track a blueprint"));
-    console.log(chalk15.gray("  lynxp link <file> <id>        Link an existing file to a blueprint"));
+    console.log(chalk15.gray("  lynxp link                    Link an existing file to a blueprint"));
     return;
   }
   for (const { blueprint, localModified, fileExists: fileExists2 } of status) {
@@ -3888,8 +5080,8 @@ program.command("search <query>").description("Search public blueprints in the m
 program.command("list").description("List your blueprints").option("-l, --limit <number>", "Number of results", "20").option("-v, --visibility <visibility>", "Filter: PRIVATE, TEAM, PUBLIC, or all").action(listCommand);
 program.command("push [file]").description("Push local file to LynxPrompt cloud as a blueprint").option("-n, --name <name>", "Blueprint name").option("-d, --description <desc>", "Blueprint description").option("-v, --visibility <vis>", "Visibility: PRIVATE, TEAM, or PUBLIC", "PRIVATE").option("-t, --tags <tags>", "Tags (comma-separated)").option("-y, --yes", "Skip prompts").action(pushCommand);
 program.command("link [file] [blueprint-id]").description("Link a local file to a cloud blueprint for tracking").option("--list", "List all tracked blueprints").action(linkCommand);
-program.command("unlink <file>").description("Disconnect a local file from its cloud blueprint").action(unlinkCommand);
-program.command("diff [blueprint-id]").description("Show changes between local and remote blueprint").option("--local", "Compare .lynxprompt/rules/ with exported files").action(diffCommand);
+program.command("unlink [file]").description("Disconnect a local file from its cloud blueprint").action(unlinkCommand);
+program.command("diff [file-or-id]").description("Compare tracked files with their cloud blueprints").option("--local", "Compare .lynxprompt/rules/ with exported files").action(diffCommand);
 program.command("init").description("Initialize .lynxprompt/ for multi-editor sync (advanced)").option("-y, --yes", "Skip prompts and use defaults").option("-f, --force", "Re-initialize even if already initialized").action(initCommand);
 program.command("sync").description("Sync .lynxprompt/rules/ to all configured agents").option("--dry-run", "Preview changes without writing files").option("-f, --force", "Skip prompts (for CI/automation)").action(syncCommand);
 program.command("agents [action] [agent]").description("Manage AI agents (list, enable, disable, detect)").option("-i, --interactive", "Interactive agent selection").action(agentsCommand);