lynxprompt 0.3.1 → 0.4.2

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,56 @@ 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;
+  const W = 45;
+  const b = chalk.bold;
+  const pad = (s, len) => s + " ".repeat(Math.max(0, len - s.length));
+  console.log();
+  console.log(b("\u250C" + "\u2500".repeat(W) + "\u2510"));
+  console.log(b("\u2502") + " ".repeat(W) + b("\u2502"));
+  console.log(b("\u2502") + pad(`   ${config2.emoji} Welcome to LynxPrompt CLI!`, W - 1) + b("\u2502"));
+  console.log(b("\u2502") + " ".repeat(W) + b("\u2502"));
+  console.log(b("\u2502") + pad(`   User: ${name}`, W) + b("\u2502"));
+  console.log(b("\u2502") + pad(`   Plan: ${config2.badge}`, W) + b("\u2502"));
+  console.log(b("\u2502") + " ".repeat(W) + b("\u2502"));
+  console.log(b("\u2514" + "\u2500".repeat(W) + "\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";
@@ -1974,7 +2019,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 +2050,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 +2064,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 +2160,265 @@ 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"
+};
+var STATIC_FILE_TEMPLATES = {
+  editorconfig: () => `# EditorConfig is awesome: https://EditorConfig.org
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab
+`,
+  contributing: (opts) => `# Contributing to ${opts.name}
+
+Thank you for your interest in contributing!
+
+## How to Contribute
+
+1. Fork the repository
+2. Create a feature branch (\`git checkout -b feature/amazing-feature\`)
+3. Commit your changes${opts.conventionalCommits ? " using Conventional Commits format" : ""}
+4. Push to the branch (\`git push origin feature/amazing-feature\`)
+5. Open a Pull Request
+
+## Development Setup
+
+\`\`\`bash
+# Clone your fork
+git clone https://github.com/YOUR_USERNAME/${opts.name}.git
+cd ${opts.name}
+
+# Install dependencies
+npm install
+
+# Run development server
+npm run dev
+\`\`\`
+
+## Code Style
+
+Please follow the existing code style and conventions in this project.
+`,
+  codeOfConduct: (opts) => `# Code of Conduct
+
+## Our Pledge
+
+We pledge to make participation in the ${opts.name} project a harassment-free experience for everyone.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment:
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the project team.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 2.1.
+`,
+  security: (opts) => `# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| latest  | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in ${opts.name}, please report it by emailing the maintainers.
+
+**Please do not open a public issue for security vulnerabilities.**
+
+We will acknowledge receipt within 48 hours and provide a detailed response within 7 days.
+`,
+  roadmap: (opts) => `# Roadmap
+
+## ${opts.name} Development Roadmap
+
+### Current Version
+
+- Core functionality
+
+### Planned Features
+
+- [ ] Feature 1
+- [ ] Feature 2
+- [ ] Feature 3
+
+### Long-term Goals
+
+- Goal 1
+- Goal 2
+
+---
+*This roadmap is subject to change based on community feedback and priorities.*
+`,
+  gitignore: (opts) => {
+    const patterns = ["# Dependencies", "node_modules/", ".pnpm-store/", ""];
+    if (opts.stack.includes("python")) {
+      patterns.push("# Python", "__pycache__/", "*.py[cod]", ".venv/", "venv/", "");
+    }
+    patterns.push("# Environment", ".env", ".env.local", ".env*.local", "");
+    patterns.push("# Build outputs", "dist/", "build/", ".next/", "out/", "");
+    patterns.push("# IDE", ".idea/", ".vscode/", "*.swp", "*.swo", "");
+    patterns.push("# OS", ".DS_Store", "Thumbs.db", "");
+    patterns.push("# Logs", "*.log", "npm-debug.log*", "");
+    return patterns.join("\n");
+  },
+  funding: () => `# These are supported funding model platforms
+
+github: [] # Replace with your GitHub username
+patreon: # Replace with your Patreon username
+open_collective: # Replace with your Open Collective username
+ko_fi: # Replace with your Ko-fi username
+custom: [] # Add custom funding links
+`,
+  license: (opts) => {
+    if (opts.license === "mit") {
+      return `MIT License
+
+Copyright (c) ${(/* @__PURE__ */ new Date()).getFullYear()} ${opts.name}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+    }
+    return `# License
+
+This project is licensed under the ${opts.license?.toUpperCase() || "Proprietary"} license.
+`;
+  },
+  readme: (opts) => {
+    const stackBadges = opts.stack.slice(0, 5).map((s) => STACK_NAMES[s] || s).join(" \u2022 ");
+    return `# ${opts.name}
+
+${opts.description || "A project generated with LynxPrompt."}
+
+${stackBadges ? `## Tech Stack
+
+${stackBadges}
+` : ""}
+## Getting Started
+
+\`\`\`bash
+# Clone the repository
+git clone <repository-url>
+cd ${opts.name}
+
+# Install dependencies
+npm install
+
+# Run development server
+npm run dev
+\`\`\`
+
+## License
+
+${opts.license && opts.license !== "none" ? `This project is licensed under the ${opts.license.toUpperCase()} License.` : "See LICENSE file for details."}
+`;
+  },
+  architecture: (opts) => `# Architecture
+
+## ${opts.name} Architecture Overview
+
+${opts.architecture ? `### Pattern: ${opts.architecture}
+` : ""}
+### Directory Structure
+
+\`\`\`
+${opts.name}/
+\u251C\u2500\u2500 src/           # Source code
+\u251C\u2500\u2500 tests/         # Test files
+\u251C\u2500\u2500 docs/          # Documentation
+\u2514\u2500\u2500 ...
+\`\`\`
+
+### Key Components
+
+1. **Component A** - Description
+2. **Component B** - Description
+3. **Component C** - Description
+
+### Data Flow
+
+Describe how data flows through the application.
+
+---
+*Generated by LynxPrompt*
+`,
+  changelog: (opts) => `# Changelog
+
+All notable changes to ${opts.name} will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial project setup
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+`
+};
+var STATIC_FILE_PATHS = {
+  editorconfig: ".editorconfig",
+  contributing: "CONTRIBUTING.md",
+  codeOfConduct: "CODE_OF_CONDUCT.md",
+  security: "SECURITY.md",
+  roadmap: "ROADMAP.md",
+  gitignore: ".gitignore",
+  funding: ".github/FUNDING.yml",
+  license: "LICENSE",
+  readme: "README.md",
+  architecture: "ARCHITECTURE.md",
+  changelog: "CHANGELOG.md"
+};
 function generateConfig(options) {
   const files = {};
   for (const platform of options.platforms) {
@@ -2077,13 +2427,34 @@ function generateConfig(options) {
       files[filename] = generateFileContent(options, platform);
     }
   }
+  if (options.staticFiles && options.staticFiles.length > 0) {
+    for (const fileKey of options.staticFiles) {
+      const filePath = STATIC_FILE_PATHS[fileKey];
+      if (!filePath) continue;
+      if (options.staticFileContents?.[fileKey]) {
+        files[filePath] = options.staticFileContents[fileKey];
+      } else {
+        const templateFn = STATIC_FILE_TEMPLATES[fileKey];
+        if (templateFn) {
+          files[filePath] = templateFn(options);
+        }
+      }
+    }
+  }
+  if (options.includeFunding && !options.staticFiles?.includes("funding")) {
+    files[".github/FUNDING.yml"] = STATIC_FILE_TEMPLATES.funding(options);
+  }
   return files;
 }
 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 +2469,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 +2516,93 @@ function generateFileContent(options, platform) {
     }
     sections.push("");
   }
-  const hasCommands = Object.values(options.commands).some(Boolean);
+  if (options.letAiDecide) {
+    if (isMarkdown || isMdc) {
+      sections.push("> **AI Assistance:** Let AI analyze the codebase and suggest additional technologies and approaches as needed.");
+      sections.push("");
+    }
+  }
+  if (options.repoHost || options.license || options.conventionalCommits || options.semver || options.cicd || options.deploymentTargets?.length || options.buildContainer || options.exampleRepoUrl || options.documentationUrl) {
+    if (isMarkdown || isMdc) {
+      sections.push("## Repository & Infrastructure");
+      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");
+      }
+      if (options.semver) {
+        sections.push("- **Versioning:** Follow [Semantic Versioning](https://semver.org) (semver)");
+      }
+      if (options.dependabot) {
+        sections.push("- **Dependencies:** Dependabot/automated dependency updates enabled");
+      }
+      if (options.cicd) {
+        const cicdNames = {
+          github_actions: "GitHub Actions",
+          gitlab_ci: "GitLab CI",
+          jenkins: "Jenkins",
+          circleci: "CircleCI",
+          travis: "Travis CI",
+          azure_devops: "Azure DevOps",
+          bitbucket: "Bitbucket Pipelines",
+          teamcity: "TeamCity",
+          drone: "Drone",
+          buildkite: "Buildkite"
+        };
+        sections.push(`- **CI/CD:** ${cicdNames[options.cicd] || options.cicd}`);
+      }
+      if (options.deploymentTargets && options.deploymentTargets.length > 0) {
+        const targetNames = {
+          vercel: "Vercel",
+          netlify: "Netlify",
+          aws: "AWS",
+          gcp: "Google Cloud",
+          azure: "Azure",
+          docker: "Docker",
+          kubernetes: "Kubernetes",
+          heroku: "Heroku",
+          digitalocean: "DigitalOcean",
+          railway: "Railway",
+          fly: "Fly.io",
+          cloudflare: "Cloudflare"
+        };
+        const targets = options.deploymentTargets.map((t) => targetNames[t] || t).join(", ");
+        sections.push(`- **Deployment:** ${targets}`);
+      }
+      if (options.buildContainer) {
+        let containerInfo = "Docker container builds enabled";
+        if (options.containerRegistry) {
+          const registryNames = {
+            dockerhub: "Docker Hub",
+            ghcr: "GitHub Container Registry",
+            gcr: "Google Container Registry",
+            ecr: "AWS ECR",
+            acr: "Azure Container Registry",
+            quay: "Quay.io",
+            gitlab: "GitLab Registry",
+            custom: "Custom registry"
+          };
+          containerInfo += ` \u2192 ${registryNames[options.containerRegistry] || options.containerRegistry}`;
+        }
+        sections.push(`- **Containers:** ${containerInfo}`);
+      }
+      if (options.exampleRepoUrl) {
+        sections.push(`- **Example Repo:** ${options.exampleRepoUrl} (use as reference for style/structure)`);
+      }
+      if (options.documentationUrl) {
+        sections.push(`- **Documentation:** ${options.documentationUrl}`);
+      }
+      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 +2613,76 @@ 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];
+  if (options.includePersonalData) {
+    if (isMarkdown || isMdc) {
+      sections.push("## Commit Identity");
+      sections.push("");
+      sections.push("> **Personal data enabled:** Use my name and email for git commits when making changes.");
+      sections.push("");
+    }
+  }
+  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 +2727,30 @@ 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.loggingConventions) {
+      sections.push(`- **Logging:** ${options.loggingConventions}`);
+    }
+    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 +2784,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,37 +2834,82 @@ 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 OUTPUT_FORMATS = [
-  {
-    title: "\u{1F310} AGENTS.md",
-    value: "agents",
-    description: "Universal format - Claude, Copilot, Aider, & more",
-    recommended: true
-  },
-  {
-    title: "\u{1F5B1}\uFE0F  Cursor",
-    value: "cursor",
-    description: ".cursor/rules/ with MDC format"
-  },
-  {
-    title: "\u{1F30A} Windsurf",
-    value: "windsurf",
-    description: ".windsurfrules configuration"
-  },
-  {
-    title: "\u{1F916} Claude Code",
-    value: "claude",
-    description: "CLAUDE.md for Claude AI"
-  },
-  {
-    title: "\u{1F4E6} Multiple",
-    value: "multiple",
-    description: "Generate for multiple AI editors"
-  }
+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 TECH_STACKS = [
+var LANGUAGES = [
   { title: "\u{1F537} TypeScript", value: "typescript" },
   { title: "\u{1F7E1} JavaScript", value: "javascript" },
   { title: "\u{1F40D} Python", value: "python" },
@@ -2281,7 +2919,9 @@ var TECH_STACKS = [
   { 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{1F34E} Swift", value: "swift" },
+  { title: "\u{1F536} Kotlin", value: "kotlin" },
+  { title: "\u2B1B C/C++", value: "cpp" }
 ];
 var FRAMEWORKS = [
   { title: "\u269B\uFE0F  React", value: "react" },
@@ -2300,23 +2940,169 @@ var FRAMEWORKS = [
   { title: "\u26A1 Vite", value: "vite" },
   { title: "\u{1F4F1} React Native", value: "react-native" }
 ];
-var PLATFORMS = [
-  { title: "\u{1F310} AGENTS.md (Universal)", value: "agents", filename: "AGENTS.md" },
-  { title: "\u{1F5B1}\uFE0F  Cursor", value: "cursor", filename: ".cursor/rules/project.mdc" },
-  { title: "\u{1F916} Claude Code", value: "claude", filename: "CLAUDE.md" },
-  { title: "\u{1F419} GitHub Copilot", value: "copilot", filename: ".github/copilot-instructions.md" },
-  { title: "\u{1F30A} Windsurf", value: "windsurf", filename: ".windsurfrules" },
-  { title: "\u26A1 Zed", value: "zed", filename: ".zed/instructions.md" },
-  { title: "\u{1F916} Cline", value: "cline", filename: ".clinerules" }
+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 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 CICD_OPTIONS = [
+  { id: "github_actions", label: "GitHub Actions", icon: "\u{1F419}" },
+  { id: "gitlab_ci", label: "GitLab CI", icon: "\u{1F98A}" },
+  { id: "jenkins", label: "Jenkins", icon: "\u{1F527}" },
+  { id: "circleci", label: "CircleCI", icon: "\u26AB" },
+  { id: "travis", label: "Travis CI", icon: "\u{1F528}" },
+  { id: "azure_devops", label: "Azure DevOps", icon: "\u2601\uFE0F" },
+  { id: "bitbucket", label: "Bitbucket Pipelines", icon: "\u{1FAA3}" },
+  { id: "teamcity", label: "TeamCity", icon: "\u{1F3E2}" },
+  { id: "drone", label: "Drone", icon: "\u{1F681}" },
+  { id: "buildkite", label: "Buildkite", icon: "\u{1F9F1}" }
+];
+var DEPLOYMENT_TARGETS = [
+  { id: "vercel", label: "Vercel", icon: "\u25B2" },
+  { id: "netlify", label: "Netlify", icon: "\u{1F310}" },
+  { id: "aws", label: "AWS", icon: "\u2601\uFE0F" },
+  { id: "gcp", label: "Google Cloud", icon: "\u{1F308}" },
+  { id: "azure", label: "Azure", icon: "\u{1F537}" },
+  { id: "docker", label: "Docker", icon: "\u{1F433}" },
+  { id: "kubernetes", label: "Kubernetes", icon: "\u2638\uFE0F" },
+  { id: "heroku", label: "Heroku", icon: "\u{1F7E3}" },
+  { id: "digitalocean", label: "DigitalOcean", icon: "\u{1F535}" },
+  { id: "railway", label: "Railway", icon: "\u{1F682}" },
+  { id: "fly", label: "Fly.io", icon: "\u2708\uFE0F" },
+  { id: "cloudflare", label: "Cloudflare", icon: "\u{1F536}" }
+];
+var CONTAINER_REGISTRIES = [
+  { id: "dockerhub", label: "Docker Hub", icon: "\u{1F433}" },
+  { id: "ghcr", label: "GitHub Container Registry", icon: "\u{1F419}" },
+  { id: "gcr", label: "Google Container Registry", icon: "\u{1F308}" },
+  { id: "ecr", label: "AWS ECR", icon: "\u2601\uFE0F" },
+  { id: "acr", label: "Azure Container Registry", icon: "\u{1F537}" },
+  { id: "quay", label: "Quay.io", icon: "\u{1F534}" },
+  { id: "gitlab", label: "GitLab Registry", icon: "\u{1F98A}" },
+  { id: "custom", label: "Custom/Self-hosted", icon: "\u{1F3E0}" }
+];
+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 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 PERSONAS = [
-  { title: "\u{1F9D1}\u200D\u{1F4BB} Full-Stack Developer", value: "fullstack", description: "Complete application development" },
-  { title: "\u2699\uFE0F  Backend Developer", value: "backend", description: "APIs, databases, services" },
-  { title: "\u{1F3A8} Frontend Developer", value: "frontend", description: "UI, components, styling" },
-  { title: "\u{1F680} DevOps Engineer", value: "devops", description: "Infrastructure, CI/CD" },
-  { title: "\u{1F4CA} Data Engineer", value: "data", description: "Pipelines, ETL, analytics" },
-  { title: "\u{1F512} Security Engineer", value: "security", description: "Secure code, auditing" },
-  { title: "\u270F\uFE0F  Custom...", value: "custom", description: "Define your own" }
+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 = [
   {
@@ -2344,11 +3130,96 @@ var BOUNDARY_PRESETS = [
     never: ["Modify .env", "Access external APIs without confirmation"]
   }
 ];
-function showStep(current, total, title) {
-  const progress = "\u25CF".repeat(current) + "\u25CB".repeat(total - current);
-  console.log();
-  console.log(chalk8.cyan(`  ${progress}  Step ${current}/${total}: ${title}`));
-  console.log();
+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" }
+];
+var DEV_OS_OPTIONS = [
+  { id: "macos", label: "macOS", icon: "\u{1F34E}" },
+  { id: "linux", label: "Linux", icon: "\u{1F427}" },
+  { id: "windows", label: "Windows", icon: "\u{1FA9F}" },
+  { id: "wsl", label: "WSL", icon: "\u{1F427}" },
+  { id: "remote", label: "Remote/SSH", icon: "\u2601\uFE0F" }
+];
+var ARCHITECTURE_PATTERNS = [
+  { id: "monolith", label: "Monolith" },
+  { id: "microservices", label: "Microservices" },
+  { id: "serverless", label: "Serverless" },
+  { id: "mvc", label: "MVC" },
+  { id: "layered", label: "Layered/N-tier" },
+  { id: "event_driven", label: "Event-driven" },
+  { id: "modular", label: "Modular monolith" },
+  { id: "other", label: "Other" }
+];
+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));
@@ -2362,11 +3233,86 @@ function printBox(lines, color = chalk8.gray) {
   }
   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.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) {
+    const W = 55;
+    const y = chalk8.yellow;
+    const pad = (s, len) => s + " ".repeat(Math.max(0, len - s.length));
+    console.log(y("\u250C" + "\u2500".repeat(W) + "\u2510"));
+    console.log(y("\u2502") + pad(" \u{1F4A1} Log in for full wizard features:", W - 1) + y("\u2502"));
+    console.log(y("\u2502") + " ".repeat(W) + y("\u2502"));
+    console.log(y("\u2502") + pad("    \u2022 Commands & Code Style [PRO]", W) + y("\u2502"));
+    console.log(y("\u2502") + pad("    \u2022 Boundaries, Testing, Static Files [MAX]", W) + y("\u2502"));
+    console.log(y("\u2502") + pad("    \u2022 Push configs to cloud (lynxp push)", W) + y("\u2502"));
+    console.log(y("\u2502") + pad("    \u2022 Sync across devices (lynxp sync)", W) + y("\u2502"));
+    console.log(y("\u2502") + " ".repeat(W) + y("\u2502"));
+    console.log(y("\u2502") + pad("    Run: " + chalk8.cyan("lynxp login"), W + 10) + y("\u2502"));
+    console.log(y("\u2514" + "\u2500".repeat(W) + "\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) {
     const detectedInfo = [
@@ -2398,7 +3344,7 @@ 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 {
@@ -2435,14 +3381,21 @@ async function wizardCommand(options) {
       console.log(`     ${chalk8.cyan("\u2192")} ${chalk8.bold(filename)}`);
     }
     console.log();
-    printBox([
+    const nextStepsLines = [
       chalk8.gray("Your AI assistant will now follow these instructions."),
       "",
       chalk8.gray("Next steps:"),
-      chalk8.cyan("  lynxp check    ") + chalk8.gray("Validate configuration"),
-      chalk8.cyan("  lynxp push     ") + chalk8.gray("Sync to cloud"),
-      chalk8.cyan("  lynxp status   ") + chalk8.gray("View current setup")
-    ], chalk8.gray);
+      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");
@@ -2454,54 +3407,49 @@ async function wizardCommand(options) {
     process.exit(1);
   }
 }
-async function runInteractiveWizard(options, detected) {
+async function runInteractiveWizard(options, detected, userTier) {
   const answers = {};
-  const totalSteps = 5;
-  const promptConfig = {
-    onCancel: () => {
-      console.log(chalk8.yellow("\n  Cancelled. Run 'lynxp wizard' anytime to restart.\n"));
-      process.exit(0);
+  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;
   };
-  showStep(1, totalSteps, "Output Format");
+  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: chalk8.white("Where will you use this?"),
-      choices: OUTPUT_FORMATS.map((f) => ({
-        title: f.recommended ? `${f.title} ${chalk8.green.bold("\u2605 recommended")}` : f.title,
-        value: f.value,
-        description: chalk8.gray(f.description)
+    console.log(chalk8.gray("  Select the AI editors you want to generate config for:"));
+    console.log(chalk8.gray("  (AGENTS.md is recommended - works with most AI tools)"));
+    console.log();
+    const platformResponse = await prompts4({
+      type: "multiselect",
+      name: "platforms",
+      message: chalk8.white("Select AI editors (16 supported):"),
+      choices: ALL_PLATFORMS.map((p) => ({
+        title: p.id === "agents" ? `${p.icon} ${p.name} ${chalk8.green.bold("\u2605 recommended")}` : `${p.icon} ${p.name}`,
+        value: p.id,
+        description: chalk8.gray(p.note),
+        selected: p.id === "agents"
+        // Pre-select AGENTS.md
       })),
-      initial: 0,
-      hint: chalk8.gray("\u2191\u2193 navigate \u2022 enter select")
+      hint: chalk8.gray("space select \u2022 a toggle all \u2022 enter confirm"),
+      min: 1,
+      instructions: false
     }, promptConfig);
-    if (formatResponse.format === "multiple") {
-      console.log();
-      const platformResponse = await prompts4({
-        type: "multiselect",
-        name: "platforms",
-        message: chalk8.white("Select AI editors:"),
-        choices: PLATFORMS.map((p) => ({
-          title: p.title,
-          value: p.value
-        })),
-        hint: chalk8.gray("space select \u2022 a toggle all \u2022 enter confirm"),
-        min: 1,
-        instructions: false
-      }, promptConfig);
-      platforms = platformResponse.platforms || ["agents"];
-    } else {
-      platforms = [formatResponse.format || "agents"];
-    }
+    platforms = platformResponse.platforms || ["agents"];
+    console.log(chalk8.green(`  \u2713 Selected ${platforms.length} platform${platforms.length === 1 ? "" : "s"}`));
   }
   answers.platforms = platforms;
-  showStep(2, totalSteps, "Project Info");
+  const projectStep = getCurrentStep("project");
+  showStep(currentStepNum, projectStep, userTier);
   const nameResponse = await prompts4({
     type: "text",
     name: "name",
@@ -2518,73 +3466,582 @@ async function runInteractiveWizard(options, detected) {
     hint: chalk8.gray("optional - helps AI understand context")
   }, promptConfig);
   answers.description = descResponse.description || "";
-  showStep(3, totalSteps, "Tech Stack");
-  const allStackOptions = [...TECH_STACKS, ...FRAMEWORKS];
-  const detectedStackSet = new Set(detected?.stack || []);
-  const preselected = allStackOptions.map((s, i) => detectedStackSet.has(s.value) ? i : -1).filter((i) => i !== -1);
-  if (preselected.length > 0) {
-    console.log(chalk8.gray(`  Auto-selected: ${detected?.stack?.join(", ")}`));
+  const typeResponse = await prompts4({
+    type: "select",
+    name: "projectType",
+    message: chalk8.white("Project type:"),
+    choices: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      ...PROJECT_TYPES.map((t) => ({
+        title: `${t.icon} ${t.label}`,
+        value: t.id,
+        description: chalk8.gray(t.description)
+      }))
+    ],
+    initial: 0
+  }, promptConfig);
+  answers.projectType = typeResponse.projectType || "";
+  const devOsResponse = await prompts4({
+    type: "select",
+    name: "devOS",
+    message: chalk8.white("Development environment:"),
+    choices: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      ...DEV_OS_OPTIONS.map((o) => ({
+        title: `${o.icon} ${o.label}`,
+        value: o.id
+      }))
+    ],
+    initial: 0,
+    hint: chalk8.gray("Helps generate compatible commands")
+  }, promptConfig);
+  answers.devOS = devOsResponse.devOS || "";
+  const archResponse = await prompts4({
+    type: "select",
+    name: "architecture",
+    message: chalk8.white("Architecture pattern:"),
+    choices: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      ...ARCHITECTURE_PATTERNS.map((a) => ({
+        title: a.label,
+        value: a.id
+      }))
+    ],
+    initial: 0
+  }, promptConfig);
+  answers.architecture = archResponse.architecture || "";
+  const techStep = getCurrentStep("tech");
+  showStep(currentStepNum, techStep, userTier);
+  const letAiResponse = await prompts4({
+    type: "toggle",
+    name: "letAiDecide",
+    message: chalk8.white("Let AI help choose additional technologies?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.letAiDecide = letAiResponse.letAiDecide || false;
+  console.log();
+  console.log(chalk8.gray("  You can also select specific technologies below:"));
+  console.log();
+  const allStackOptions = [...LANGUAGES, ...FRAMEWORKS, ...DATABASES];
+  if (detected?.stack && detected.stack.length > 0) {
+    console.log(chalk8.gray(`  Detected in project: ${detected.stack.join(", ")}`));
     console.log();
   }
   const stackResponse = await prompts4({
     type: "multiselect",
     name: "stack",
-    message: chalk8.white("Tech stack:"),
+    message: chalk8.white("Languages, frameworks & databases:"),
     choices: allStackOptions.map((s) => ({
       title: s.title,
-      value: s.value,
-      selected: detectedStackSet.has(s.value)
+      value: s.value
+      // No pre-selection - user must explicitly choose
     })),
     hint: chalk8.gray("space select \u2022 a toggle all \u2022 enter confirm"),
     instructions: false
   }, promptConfig);
   answers.stack = stackResponse.stack || [];
-  showStep(4, totalSteps, "AI Persona");
+  const repoStep = getCurrentStep("repo");
+  showStep(currentStepNum, repoStep, userTier);
+  const repoHostResponse = await prompts4({
+    type: "select",
+    name: "repoHost",
+    message: chalk8.white("Repository host:"),
+    choices: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      ...REPO_HOSTS.map((h) => ({
+        title: `${h.icon} ${h.label}`,
+        value: h.id
+      }))
+    ],
+    initial: 0
+  }, promptConfig);
+  answers.repoHost = repoHostResponse.repoHost || "";
+  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: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      ...LICENSES.map((l) => ({
+        title: l.label,
+        value: l.id
+      }))
+    ],
+    initial: 0
+  }, promptConfig);
+  answers.license = licenseResponse.license || "";
+  const conventionalResponse = await prompts4({
+    type: "toggle",
+    name: "conventionalCommits",
+    message: chalk8.white("Use Conventional Commits?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.conventionalCommits = conventionalResponse.conventionalCommits || false;
+  const semverResponse = await prompts4({
+    type: "toggle",
+    name: "semver",
+    message: chalk8.white("Use Semantic Versioning?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.semver = semverResponse.semver || false;
+  if (answers.repoHost === "github" || answers.repoHost === "gitlab") {
+    const dependabotResponse = await prompts4({
+      type: "toggle",
+      name: "dependabot",
+      message: chalk8.white("Enable Dependabot/dependency updates?"),
+      initial: false,
+      active: "Yes",
+      inactive: "No"
+    }, promptConfig);
+    answers.dependabot = dependabotResponse.dependabot || false;
+  }
+  const cicdResponse = await prompts4({
+    type: "select",
+    name: "cicd",
+    message: chalk8.white("CI/CD Platform:"),
+    choices: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      ...CICD_OPTIONS.map((c) => ({
+        title: `${c.icon} ${c.label}`,
+        value: c.id
+      }))
+    ],
+    initial: 0
+  }, promptConfig);
+  answers.cicd = cicdResponse.cicd || "";
+  const deployResponse = await prompts4({
+    type: "multiselect",
+    name: "deploymentTargets",
+    message: chalk8.white("Deployment targets:"),
+    choices: DEPLOYMENT_TARGETS.map((t) => ({
+      title: `${t.icon} ${t.label}`,
+      value: t.id
+    })),
+    hint: chalk8.gray("space select \u2022 enter to skip/confirm"),
+    instructions: false
+  }, promptConfig);
+  answers.deploymentTargets = deployResponse.deploymentTargets || [];
+  const containerResponse = await prompts4({
+    type: "toggle",
+    name: "buildContainer",
+    message: chalk8.white("Build container images (Docker)?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.buildContainer = containerResponse.buildContainer || false;
+  if (answers.buildContainer) {
+    const registryResponse = await prompts4({
+      type: "select",
+      name: "containerRegistry",
+      message: chalk8.white("Container registry:"),
+      choices: [
+        { title: chalk8.gray("\u23ED Skip"), value: "" },
+        ...CONTAINER_REGISTRIES.map((r) => ({
+          title: `${r.icon} ${r.label}`,
+          value: r.id
+        }))
+      ],
+      initial: 0
+    }, promptConfig);
+    answers.containerRegistry = registryResponse.containerRegistry || "";
+  }
+  const exampleRepoResponse = await prompts4({
+    type: "text",
+    name: "exampleRepoUrl",
+    message: chalk8.white("Example repository URL (optional):"),
+    hint: chalk8.gray("A similar public repo for AI to learn from")
+  }, promptConfig);
+  answers.exampleRepoUrl = exampleRepoResponse.exampleRepoUrl || "";
+  const docsUrlResponse = await prompts4({
+    type: "text",
+    name: "documentationUrl",
+    message: chalk8.white("External documentation URL (optional):"),
+    hint: chalk8.gray("Confluence, Notion, GitBook, etc.")
+  }, promptConfig);
+  answers.documentationUrl = docsUrlResponse.documentationUrl || "";
+  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: [
+        { title: chalk8.gray("\u23ED Skip"), value: "" },
+        ...NAMING_CONVENTIONS.map((n) => ({
+          title: n.label,
+          value: n.id,
+          description: chalk8.gray(n.desc)
+        }))
+      ],
+      initial: 0
+    }, promptConfig);
+    answers.namingConvention = namingResponse.naming || "";
+    const errorResponse = await prompts4({
+      type: "select",
+      name: "errorHandling",
+      message: chalk8.white("Error handling pattern:"),
+      choices: [
+        { title: chalk8.gray("\u23ED Skip"), value: "" },
+        ...ERROR_PATTERNS.map((e) => ({
+          title: e.label,
+          value: e.id
+        }))
+      ],
+      initial: 0
+    }, promptConfig);
+    answers.errorHandling = errorResponse.errorHandling || "";
+    const loggingResponse = await prompts4({
+      type: "text",
+      name: "loggingConventions",
+      message: chalk8.white("Logging conventions (optional):"),
+      hint: chalk8.gray("e.g., use structured logging, JSON format, specific lib")
+    }, promptConfig);
+    answers.loggingConventions = loggingResponse.loggingConventions || "";
+    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 recommended")}` : r.label,
+      value: r.id
+      // No pre-selection - user must explicitly choose
+    })),
+    hint: chalk8.gray("space select \u2022 enter to skip/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
+      // No pre-selection - user must explicitly choose
+    })),
+    hint: chalk8.gray("space select \u2022 enter to skip/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;
+  const includePersonalResponse = await prompts4({
+    type: "toggle",
+    name: "includePersonalData",
+    message: chalk8.white("Include personal data (name/email for commits)?"),
+    initial: false,
+    active: "Yes",
+    inactive: "No"
+  }, promptConfig);
+  answers.includePersonalData = includePersonalResponse.includePersonalData || 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: [
+        { title: chalk8.gray("\u23ED Skip"), value: "" },
+        ...BOUNDARY_PRESETS.map((b) => ({
+          title: b.title,
+          value: b.value,
+          description: chalk8.gray(b.description)
+        }))
+      ],
+      initial: 0
+    }, promptConfig);
+    answers.boundaries = presetResponse.boundaryPreset || "";
+    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 STATIC_FILE_OPTIONS = [
+      { title: "\u{1F4DD} .editorconfig", value: "editorconfig", desc: "Consistent code formatting", file: ".editorconfig" },
+      { title: "\u{1F91D} CONTRIBUTING.md", value: "contributing", desc: "Contributor guidelines", file: "CONTRIBUTING.md" },
+      { title: "\u{1F4DC} CODE_OF_CONDUCT.md", value: "codeOfConduct", desc: "Community standards", file: "CODE_OF_CONDUCT.md" },
+      { title: "\u{1F512} SECURITY.md", value: "security", desc: "Vulnerability reporting", file: "SECURITY.md" },
+      { title: "\u{1F5FA}\uFE0F  ROADMAP.md", value: "roadmap", desc: "Project roadmap", file: "ROADMAP.md" },
+      { title: "\u{1F4CB} .gitignore", value: "gitignore", desc: "Git ignore patterns", file: ".gitignore" },
+      { title: "\u{1F4B0} FUNDING.yml", value: "funding", desc: "GitHub Sponsors config", file: ".github/FUNDING.yml" },
+      { title: "\u{1F4C4} LICENSE", value: "license", desc: "License file", file: "LICENSE" },
+      { title: "\u{1F4D6} README.md", value: "readme", desc: "Project readme", file: "README.md" },
+      { title: "\u{1F3D7}\uFE0F  ARCHITECTURE.md", value: "architecture", desc: "Architecture docs", file: "ARCHITECTURE.md" },
+      { title: "\u{1F4DD} CHANGELOG.md", value: "changelog", desc: "Version history", file: "CHANGELOG.md" }
+    ];
+    const staticFilesResponse = await prompts4({
+      type: "multiselect",
+      name: "staticFiles",
+      message: chalk8.white("Include static files:"),
+      choices: STATIC_FILE_OPTIONS.map((f) => ({
+        title: f.title,
+        value: f.value,
+        description: chalk8.gray(f.desc)
+      })),
+      hint: chalk8.gray("space select \u2022 enter to skip/confirm"),
+      instructions: false
+    }, promptConfig);
+    answers.staticFiles = staticFilesResponse.staticFiles || [];
+    if (answers.staticFiles?.length > 0) {
+      console.log();
+      console.log(chalk8.cyan("  \u{1F4DD} Customize file contents (press Enter to use defaults):"));
+      console.log(chalk8.gray("  You can paste content or leave empty for auto-generated defaults."));
+      console.log();
+      answers.staticFileContents = {};
+      for (const fileKey of answers.staticFiles) {
+        const fileInfo = STATIC_FILE_OPTIONS.find((f) => f.value === fileKey);
+        if (!fileInfo) continue;
+        const contentResponse = await prompts4({
+          type: "text",
+          name: "content",
+          message: chalk8.white(`Content for ${fileInfo.file}:`),
+          hint: chalk8.gray("paste content or Enter to skip")
+        }, promptConfig);
+        if (contentResponse.content && contentResponse.content.trim()) {
+          answers.staticFileContents[fileKey] = contentResponse.content;
+        }
+      }
+    }
+  }
+  const extraStep = getCurrentStep("extra");
+  showStep(currentStepNum, extraStep, userTier);
   const personaResponse = await prompts4({
     type: "select",
     name: "persona",
-    message: chalk8.white("What role should the AI take?"),
-    choices: PERSONAS.map((p) => ({
-      title: p.title,
-      value: p.value,
-      description: chalk8.gray(p.description)
-    })),
-    initial: 0,
-    hint: chalk8.gray("\u2191\u2193 navigate \u2022 enter select")
+    message: chalk8.white("AI assistant persona:"),
+    choices: [
+      { title: chalk8.gray("\u23ED Skip"), value: "" },
+      { 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
   }, promptConfig);
   if (personaResponse.persona === "custom") {
     const customPersona = await prompts4({
       type: "text",
       name: "value",
       message: chalk8.white("Describe the custom persona:"),
-      hint: chalk8.gray("e.g., 'ML engineer focused on PyTorch and data pipelines'")
+      hint: chalk8.gray("e.g., 'ML engineer focused on PyTorch'")
     }, promptConfig);
-    answers.persona = customPersona.value || "fullstack";
+    answers.persona = customPersona.value || "";
   } else {
-    answers.persona = personaResponse.persona || "fullstack";
+    answers.persona = personaResponse.persona || "";
   }
-  showStep(5, totalSteps, "AI Boundaries");
-  const boundaryResponse = await prompts4({
-    type: "select",
-    name: "boundaries",
-    message: chalk8.white("How much freedom should the AI have?"),
-    choices: BOUNDARY_PRESETS.map((b) => ({
-      title: b.title,
-      value: b.value,
-      description: chalk8.gray(b.description)
-    })),
-    initial: 0,
-    hint: chalk8.gray("\u2191\u2193 navigate \u2022 enter select")
+  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.boundaries = boundaryResponse.boundaries || "standard";
-  const selectedBoundary = BOUNDARY_PRESETS.find((b) => b.value === answers.boundaries);
-  if (selectedBoundary) {
-    console.log();
-    console.log(chalk8.gray("  Always allowed: ") + chalk8.green(selectedBoundary.always.slice(0, 2).join(", ")));
-    console.log(chalk8.gray("  Ask first:      ") + chalk8.yellow(selectedBoundary.askFirst.slice(0, 2).join(", ")));
-    console.log(chalk8.gray("  Never:          ") + chalk8.red(selectedBoundary.never.slice(0, 2).join(", ")));
-  }
-  answers.commands = detected?.commands || {};
+  answers.extraNotes = extraNotesResponse.extraNotes || "";
+  console.log();
+  console.log(chalk8.green("  \u2705 All steps completed!"));
+  console.log();
   return {
     name: answers.name,
     description: answers.description,
@@ -2592,7 +4049,30 @@ 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,
+    devOS: answers.devOS,
+    architecture: answers.architecture,
+    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
   };
 }