@qazuor/claude-code-config 0.4.0 → 0.6.0

package/dist/bin.js

@@ -207,7 +207,7 @@ import { createRequire } from "module";
 
 // src/cli/index.ts
 init_esm_shims();
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/cli/commands/index.ts
 init_esm_shims();
@@ -251,15 +251,10 @@ var BUNDLES = [
     moduleDetails: {
       agents: [
         {
-          id: "react-senior-dev",
-          role: "React Architecture",
+          id: "frontend-engineer",
+          role: "Frontend Development",
           responsibilities: ["Component design", "State management", "Performance optimization"]
         },
-        {
-          id: "tanstack-start-engineer",
-          role: "TanStack Specialist",
-          responsibilities: ["Router setup", "Query patterns", "SSR configuration"]
-        },
         {
           id: "ux-ui-designer",
           role: "UI/UX Design",
@@ -267,6 +262,8 @@ var BUNDLES = [
         }
       ],
       skills: [
+        { id: "react-patterns", purpose: "React component patterns" },
+        { id: "tanstack-start-patterns", purpose: "TanStack Router/Start patterns" },
         { id: "web-app-testing", purpose: "React Testing Library patterns" },
         { id: "shadcn-specialist", purpose: "Shadcn UI component usage" },
         { id: "accessibility-audit", purpose: "WCAG compliance" },
@@ -278,9 +275,10 @@ var BUNDLES = [
       docs: [{ id: "design-standards", topic: "UI/UX design standards" }]
     },
     modules: [
-      { id: "react-senior-dev", category: "agents" },
-      { id: "tanstack-start-engineer", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
       { id: "ux-ui-designer", category: "agents" },
+      { id: "react-patterns", category: "skills" },
+      { id: "tanstack-start-patterns", category: "skills" },
       { id: "web-app-testing", category: "skills" },
       { id: "shadcn-specialist", category: "skills" },
       { id: "accessibility-audit", category: "skills" },
@@ -316,15 +314,10 @@ var BUNDLES = [
     moduleDetails: {
       agents: [
         {
-          id: "astro-engineer",
-          role: "Astro Specialist",
+          id: "frontend-engineer",
+          role: "Frontend Development",
           responsibilities: ["Routing", "Islands architecture", "Build optimization"]
         },
-        {
-          id: "react-senior-dev",
-          role: "React Components",
-          responsibilities: ["Interactive components", "Client hydration"]
-        },
         {
           id: "seo-ai-specialist",
           role: "SEO Optimization",
@@ -332,6 +325,8 @@ var BUNDLES = [
         }
       ],
       skills: [
+        { id: "astro-patterns", purpose: "Astro-specific patterns" },
+        { id: "react-patterns", purpose: "React island components" },
         { id: "web-app-testing", purpose: "Component testing" },
         { id: "vercel-specialist", purpose: "Deployment optimization" },
         { id: "performance-audit", purpose: "Core Web Vitals" }
@@ -340,9 +335,10 @@ var BUNDLES = [
       docs: []
     },
     modules: [
-      { id: "astro-engineer", category: "agents" },
-      { id: "react-senior-dev", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
       { id: "seo-ai-specialist", category: "agents" },
+      { id: "astro-patterns", category: "skills" },
+      { id: "react-patterns", category: "skills" },
       { id: "web-app-testing", category: "skills" },
       { id: "vercel-specialist", category: "skills" },
       { id: "performance-audit", category: "skills" }
@@ -375,17 +371,12 @@ var BUNDLES = [
     moduleDetails: {
       agents: [
         {
-          id: "nextjs-engineer",
-          role: "Next.js Specialist",
-          responsibilities: ["App Router", "Server Actions", "Caching strategies"]
-        },
-        {
-          id: "react-senior-dev",
-          role: "React Components",
-          responsibilities: ["Client components", "State management"]
+          id: "frontend-engineer",
+          role: "Frontend Development",
+          responsibilities: ["App Router", "Server Actions", "Client components"]
         },
         {
-          id: "prisma-engineer",
+          id: "database-engineer",
           role: "Database",
           responsibilities: ["Schema design", "Migrations", "Query optimization"]
         },
@@ -396,6 +387,9 @@ var BUNDLES = [
         }
       ],
       skills: [
+        { id: "nextjs-patterns", purpose: "Next.js App Router patterns" },
+        { id: "react-patterns", purpose: "React component patterns" },
+        { id: "prisma-patterns", purpose: "Prisma ORM patterns" },
         { id: "web-app-testing", purpose: "Next.js testing patterns" },
         { id: "shadcn-specialist", purpose: "UI components" },
         { id: "vercel-specialist", purpose: "Deployment" },
@@ -407,10 +401,12 @@ var BUNDLES = [
       docs: []
     },
     modules: [
-      { id: "nextjs-engineer", category: "agents" },
-      { id: "react-senior-dev", category: "agents" },
-      { id: "prisma-engineer", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
+      { id: "database-engineer", category: "agents" },
       { id: "ux-ui-designer", category: "agents" },
+      { id: "nextjs-patterns", category: "skills" },
+      { id: "react-patterns", category: "skills" },
+      { id: "prisma-patterns", category: "skills" },
       { id: "web-app-testing", category: "skills" },
       { id: "shadcn-specialist", category: "skills" },
       { id: "vercel-specialist", category: "skills" },
@@ -446,12 +442,12 @@ var BUNDLES = [
     moduleDetails: {
       agents: [
         {
-          id: "express-engineer",
-          role: "Express Specialist",
+          id: "api-engineer",
+          role: "API Development",
           responsibilities: ["Route design", "Middleware", "Error handling"]
         },
         {
-          id: "prisma-engineer",
+          id: "database-engineer",
           role: "Database",
           responsibilities: ["Schema", "Migrations", "Queries"]
         },
@@ -462,6 +458,8 @@ var BUNDLES = [
         }
       ],
       skills: [
+        { id: "express-patterns", purpose: "Express.js patterns" },
+        { id: "prisma-patterns", purpose: "Prisma ORM patterns" },
         { id: "api-app-testing", purpose: "API testing with supertest" },
         { id: "error-handling-patterns", purpose: "Error middleware" },
         { id: "security-testing", purpose: "Security best practices" }
@@ -470,9 +468,11 @@ var BUNDLES = [
       docs: [{ id: "architecture-patterns", topic: "API architecture patterns" }]
     },
     modules: [
-      { id: "express-engineer", category: "agents" },
-      { id: "prisma-engineer", category: "agents" },
+      { id: "api-engineer", category: "agents" },
+      { id: "database-engineer", category: "agents" },
       { id: "node-typescript-engineer", category: "agents" },
+      { id: "express-patterns", category: "skills" },
+      { id: "prisma-patterns", category: "skills" },
       { id: "api-app-testing", category: "skills" },
       { id: "error-handling-patterns", category: "skills" },
       { id: "security-testing", category: "skills" },
@@ -506,13 +506,13 @@ var BUNDLES = [
     moduleDetails: {
       agents: [
         {
-          id: "hono-engineer",
-          role: "Hono Specialist",
+          id: "api-engineer",
+          role: "API Development",
           responsibilities: ["Route handlers", "Middleware", "OpenAPI integration"]
         },
         {
-          id: "db-drizzle-engineer",
-          role: "Drizzle Database",
+          id: "database-engineer",
+          role: "Database",
           responsibilities: ["Schema design", "Migrations", "Type-safe queries"]
         },
         {
@@ -522,6 +522,8 @@ var BUNDLES = [
         }
       ],
       skills: [
+        { id: "hono-patterns", purpose: "Hono framework patterns" },
+        { id: "drizzle-patterns", purpose: "Drizzle ORM patterns" },
         { id: "api-app-testing", purpose: "Hono testing patterns" },
         { id: "error-handling-patterns", purpose: "Error middleware" },
         { id: "security-testing", purpose: "Security validation" }
@@ -530,9 +532,11 @@ var BUNDLES = [
       docs: [{ id: "architecture-patterns", topic: "API architecture patterns" }]
     },
     modules: [
-      { id: "hono-engineer", category: "agents" },
-      { id: "db-drizzle-engineer", category: "agents" },
+      { id: "api-engineer", category: "agents" },
+      { id: "database-engineer", category: "agents" },
       { id: "node-typescript-engineer", category: "agents" },
+      { id: "hono-patterns", category: "skills" },
+      { id: "drizzle-patterns", category: "skills" },
       { id: "api-app-testing", category: "skills" },
       { id: "error-handling-patterns", category: "skills" },
       { id: "security-testing", category: "skills" },
@@ -763,7 +767,8 @@ var BUNDLES = [
     tags: ["database", "drizzle", "orm"],
     alternativeTo: ["prisma-database", "mongoose-database"],
     modules: [
-      { id: "db-drizzle-engineer", category: "agents" },
+      { id: "database-engineer", category: "agents" },
+      { id: "drizzle-patterns", category: "skills" },
       { id: "json-data-auditor", category: "skills" }
     ]
   },
@@ -777,7 +782,8 @@ var BUNDLES = [
     tags: ["database", "prisma", "orm"],
     alternativeTo: ["drizzle-database", "mongoose-database"],
     modules: [
-      { id: "prisma-engineer", category: "agents" },
+      { id: "database-engineer", category: "agents" },
+      { id: "prisma-patterns", category: "skills" },
       { id: "json-data-auditor", category: "skills" }
     ]
   },
@@ -791,7 +797,8 @@ var BUNDLES = [
     tags: ["database", "mongodb", "mongoose", "nosql"],
     alternativeTo: ["drizzle-database", "prisma-database"],
     modules: [
-      { id: "mongoose-engineer", category: "agents" },
+      { id: "database-engineer", category: "agents" },
+      { id: "mongoose-patterns", category: "skills" },
       { id: "json-data-auditor", category: "skills" }
     ]
   },
@@ -808,7 +815,8 @@ var BUNDLES = [
     tags: ["api", "hono", "backend"],
     alternativeTo: ["express-api", "fastify-api", "nestjs-api"],
     modules: [
-      { id: "hono-engineer", category: "agents" },
+      { id: "api-engineer", category: "agents" },
+      { id: "hono-patterns", category: "skills" },
       { id: "api-app-testing", category: "skills" },
       { id: "error-handling-patterns", category: "skills" }
     ]
@@ -823,7 +831,8 @@ var BUNDLES = [
     tags: ["api", "express", "backend"],
     alternativeTo: ["hono-api", "fastify-api", "nestjs-api"],
     modules: [
-      { id: "express-engineer", category: "agents" },
+      { id: "api-engineer", category: "agents" },
+      { id: "express-patterns", category: "skills" },
       { id: "api-app-testing", category: "skills" },
       { id: "error-handling-patterns", category: "skills" }
     ]
@@ -838,7 +847,8 @@ var BUNDLES = [
     tags: ["api", "fastify", "backend", "performance"],
     alternativeTo: ["hono-api", "express-api", "nestjs-api"],
     modules: [
-      { id: "fastify-engineer", category: "agents" },
+      { id: "api-engineer", category: "agents" },
+      { id: "fastify-patterns", category: "skills" },
       { id: "api-app-testing", category: "skills" },
       { id: "error-handling-patterns", category: "skills" }
     ]
@@ -853,7 +863,8 @@ var BUNDLES = [
     tags: ["api", "nestjs", "backend", "enterprise"],
     alternativeTo: ["hono-api", "express-api", "fastify-api"],
     modules: [
-      { id: "nestjs-engineer", category: "agents" },
+      { id: "api-engineer", category: "agents" },
+      { id: "nestjs-patterns", category: "skills" },
       { id: "api-app-testing", category: "skills" },
       { id: "error-handling-patterns", category: "skills" }
     ]
@@ -870,8 +881,9 @@ var BUNDLES = [
     techStack: ["React", "Shadcn UI", "Tailwind CSS", "Radix UI"],
     tags: ["react", "ui", "components"],
     modules: [
-      { id: "react-senior-dev", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
       { id: "ux-ui-designer", category: "agents" },
+      { id: "react-patterns", category: "skills" },
       { id: "shadcn-specialist", category: "skills" },
       { id: "brand-guidelines", category: "skills" },
       { id: "accessibility-audit", category: "skills" }
@@ -886,7 +898,8 @@ var BUNDLES = [
     techStack: ["React Hook Form", "Zod", "React", "TypeScript"],
     tags: ["react", "forms", "validation"],
     modules: [
-      { id: "react-senior-dev", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
+      { id: "react-patterns", category: "skills" },
       { id: "react-hook-form-patterns", category: "skills" },
       { id: "shadcn-specialist", category: "skills" }
     ]
@@ -901,7 +914,8 @@ var BUNDLES = [
     tags: ["react", "state", "zustand"],
     alternativeTo: ["react-state-redux"],
     modules: [
-      { id: "react-senior-dev", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
+      { id: "react-patterns", category: "skills" },
       { id: "zustand-patterns", category: "skills" },
       { id: "tanstack-query-patterns", category: "skills" }
     ]
@@ -916,7 +930,8 @@ var BUNDLES = [
     tags: ["react", "state", "redux"],
     alternativeTo: ["react-state-zustand"],
     modules: [
-      { id: "react-senior-dev", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
+      { id: "react-patterns", category: "skills" },
       { id: "redux-toolkit-patterns", category: "skills" },
       { id: "tanstack-query-patterns", category: "skills", optional: true }
     ]
@@ -930,7 +945,8 @@ var BUNDLES = [
     techStack: ["NextAuth.js", "Auth.js", "Next.js", "Prisma"],
     tags: ["nextjs", "auth", "oauth"],
     modules: [
-      { id: "nextjs-engineer", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
+      { id: "nextjs-patterns", category: "skills" },
       { id: "nextauth-patterns", category: "skills" },
       { id: "security-testing", category: "skills" }
     ]
@@ -944,8 +960,9 @@ var BUNDLES = [
     techStack: ["next-intl", "Next.js", "React", "TypeScript"],
     tags: ["nextjs", "i18n", "internationalization"],
     modules: [
-      { id: "nextjs-engineer", category: "agents" },
+      { id: "frontend-engineer", category: "agents" },
       { id: "i18n-specialist", category: "agents", optional: true },
+      { id: "nextjs-patterns", category: "skills" },
       { id: "i18n-patterns", category: "skills" }
     ]
   },
@@ -1065,7 +1082,7 @@ var BUNDLES = [
         }
       ],
       skills: [
-        { id: "documentation-writer", purpose: "Documentation best practices" },
+        { id: "markdown-formatter", purpose: "Markdown formatting" },
         { id: "mermaid-diagram-specialist", purpose: "Diagram creation" }
       ],
       commands: [
@@ -1080,7 +1097,7 @@ var BUNDLES = [
     },
     modules: [
       { id: "tech-writer", category: "agents" },
-      { id: "documentation-writer", category: "skills" },
+      { id: "markdown-formatter", category: "skills" },
       { id: "mermaid-diagram-specialist", category: "skills" },
       { id: "update-docs", category: "commands" },
       { id: "markdown-format", category: "commands" },
@@ -2571,7 +2588,7 @@ init_esm_shims();
 // src/lib/config/reader.ts
 init_esm_shims();
 init_fs();
-var CONFIG_FILE = "config.json";
+var CONFIG_FILE = "qazuor-claude-config.json";
 var CLAUDE_DIR = ".claude";
 async function readConfig(projectPath) {
   const configPath = joinPath(projectPath, CLAUDE_DIR, CONFIG_FILE);
@@ -2593,7 +2610,7 @@ async function hasClaudeDir(projectPath) {
 // src/lib/config/writer.ts
 init_esm_shims();
 init_fs();
-var CONFIG_FILE2 = "config.json";
+var CONFIG_FILE2 = "qazuor-claude-config.json";
 var CLAUDE_DIR2 = ".claude";
 async function writeConfig(projectPath, config, options) {
   const claudePath = joinPath(projectPath, CLAUDE_DIR2);
@@ -3235,21 +3252,333 @@ init_esm_shims();
 // src/lib/git-hooks/husky-installer.ts
 init_esm_shims();
 init_fs();
-function generateCommitMsgHook() {
+
+// src/lib/git-hooks/precommit-generator.ts
+init_esm_shims();
+function generatePreCommitScript(config) {
+  if (!config.enabled) {
+    return generateDisabledScript();
+  }
+  const sections = [];
+  sections.push(generateHeader());
+  if (config.showTiming) {
+    sections.push(generateTimingSetup());
+  }
+  sections.push(generateErrorHandling(config.continueOnFailure));
+  if (config.lint.enabled) {
+    sections.push(generateLintSection(config));
+  }
+  if (config.typecheck.enabled) {
+    sections.push(generateTypecheckSection(config));
+  }
+  if (config.formatCheck.enabled) {
+    sections.push(generateFormatCheckSection(config));
+  }
+  if (config.tests.enabled && config.tests.mode !== "none") {
+    sections.push(generateTestSection(config));
+  }
+  const sortedCustom = [...config.customCommands].sort(
+    (a, b) => (a.order ?? 100) - (b.order ?? 100)
+  );
+  for (const cmd of sortedCustom) {
+    sections.push(generateCustomCommandSection(cmd, config));
+  }
+  sections.push(generateFooter(config));
+  return sections.join("\n\n");
+}
+function generateDisabledScript() {
   return `#!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-npx --no -- commitlint --edit "\${1}"
-`;
+# Pre-commit hook disabled
+exit 0`;
 }
-function generatePreCommitHook(lintCommand) {
-  const command = lintCommand || "pnpm lint-staged";
+function generateHeader() {
   return `#!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-${command}
+# Pre-commit hook - Generated by @qazuor/claude-code-config
+# Bypass with: git commit --no-verify -m "message"
+
+echo "\u{1F50D} Running pre-commit checks..."`;
+}
+function generateTimingSetup() {
+  return `# Timing setup
+START_TIME=$(date +%s)
+step_start() { STEP_START=$(date +%s); }
+step_end() {
+  STEP_END=$(date +%s)
+  ELAPSED_TIME=$((STEP_END - STEP_START))
+  echo "  \u23F1\uFE0F  Completed in \${ELAPSED_TIME}s"
+}`;
+}
+function generateErrorHandling(continueOnFailure) {
+  if (continueOnFailure) {
+    return `# Error tracking (continue on failure mode)
+ERRORS=0
+track_error() {
+  ERRORS=$((ERRORS + 1))
+}`;
+  }
+  return `# Fail fast mode - exit on first error
+set -e`;
+}
+function generateLintSection(config) {
+  const lint = config.lint;
+  let command;
+  if (lint.command) {
+    command = lint.command;
+  } else if (lint.stagedOnly) {
+    command = getLintStagedCommand(lint.tool);
+  } else {
+    command = getLintCommand(lint.tool);
+  }
+  const lines = [];
+  lines.push("# Linting");
+  lines.push('echo ""');
+  lines.push('echo "\u{1F4DD} Linting..."');
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (lint.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Lint passed"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Lint warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Lint passed"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Lint failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Lint failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Lint passed"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function getLintStagedCommand(tool) {
+  switch (tool) {
+    case "biome":
+      return "pnpm biome check --staged --no-errors-on-unmatched";
+    case "eslint":
+      return "pnpm lint-staged";
+    default:
+      return "pnpm lint-staged";
+  }
+}
+function getLintCommand(tool) {
+  switch (tool) {
+    case "biome":
+      return "pnpm biome check .";
+    case "eslint":
+      return "pnpm eslint .";
+    default:
+      return "pnpm lint";
+  }
+}
+function generateTypecheckSection(config) {
+  const typecheck = config.typecheck;
+  const command = typecheck.command ?? "pnpm typecheck";
+  const lines = [];
+  lines.push("# Type checking");
+  lines.push('echo ""');
+  lines.push('echo "\u{1F537} Type checking..."');
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (typecheck.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Types OK"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Type warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Types OK"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Type check failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Type check failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Types OK"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function generateFormatCheckSection(config) {
+  const format = config.formatCheck;
+  let command;
+  if (format.command) {
+    command = format.command;
+  } else {
+    command = getFormatCheckCommand(format.tool);
+  }
+  const lines = [];
+  lines.push("# Format check");
+  lines.push('echo ""');
+  lines.push('echo "\u2728 Format check..."');
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (format.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Format OK"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Format warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Format OK"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Format check failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Format check failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Format OK"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function getFormatCheckCommand(tool) {
+  switch (tool) {
+    case "biome":
+      return "pnpm biome format --check .";
+    case "prettier":
+      return "pnpm prettier --check .";
+    default:
+      return "pnpm format:check";
+  }
+}
+function generateTestSection(config) {
+  const tests = config.tests;
+  let command;
+  if (tests.command) {
+    command = tests.command;
+  } else if (tests.mode === "affected") {
+    command = "pnpm vitest related --run";
+  } else {
+    command = "pnpm test";
+  }
+  if (tests.coverageThreshold > 0) {
+    command = `${command} --coverage --coverage.thresholds.lines=${tests.coverageThreshold}`;
+  }
+  const lines = [];
+  lines.push("# Tests");
+  lines.push('echo ""');
+  lines.push(`echo "\u{1F9EA} Running ${tests.mode === "affected" ? "affected" : "all"} tests..."`);
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (tests.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Tests passed"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Test warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Tests passed"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Tests failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Tests failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Tests passed"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function generateCustomCommandSection(cmd, config) {
+  const lines = [];
+  lines.push(`# Custom: ${cmd.name}`);
+  lines.push('echo ""');
+  lines.push(`echo "\u{1F527} ${cmd.name}..."`);
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (cmd.allowFailure) {
+    lines.push(`if ${cmd.command}; then`);
+    lines.push(`  echo "  \u2705 ${cmd.name} passed"`);
+    lines.push("else");
+    lines.push(`  echo "  \u26A0\uFE0F  ${cmd.name} warnings (non-blocking)"`);
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${cmd.command}; then`);
+    lines.push(`  echo "  \u2705 ${cmd.name} passed"`);
+    lines.push("else");
+    lines.push(`  echo "  \u274C ${cmd.name} failed"`);
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${cmd.command} || { echo "  \u274C ${cmd.name} failed"; exit 1; }`);
+    lines.push(`echo "  \u2705 ${cmd.name} passed"`);
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function generateFooter(config) {
+  const lines = [];
+  lines.push("# Final status");
+  lines.push('echo ""');
+  if (config.showTiming) {
+    lines.push("END_TIME=$(date +%s)");
+    lines.push("TOTAL_TIME=$((END_TIME - START_TIME))");
+  }
+  if (config.continueOnFailure) {
+    lines.push("if [ $ERRORS -gt 0 ]; then");
+    lines.push('  echo "\u274C Pre-commit failed with $ERRORS error(s)"');
+    if (config.showTiming) {
+      lines.push('  echo "\u23F1\uFE0F  Total time: ${TOTAL_TIME}s"');
+    }
+    lines.push("  exit 1");
+    lines.push("fi");
+  }
+  if (config.showTiming) {
+    lines.push('echo "\u2728 All checks passed! (${TOTAL_TIME}s)"');
+  } else {
+    lines.push('echo "\u2728 All checks passed!"');
+  }
+  return lines.join("\n");
+}
+function generateSimplePreCommitHook(command) {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${command}`;
+}
+
+// src/lib/git-hooks/husky-installer.ts
+function generateCommitMsgHook() {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit "\${1}"
 `;
 }
+function generatePreCommitHook(lintCommand, preCommitConfig) {
+  if (preCommitConfig) {
+    return generatePreCommitScript(preCommitConfig);
+  }
+  const command = lintCommand || "pnpm lint-staged";
+  return generateSimplePreCommitHook(command);
+}
 function generatePrePushHook(testCommand) {
   const command = testCommand || "pnpm test";
   return `#!/usr/bin/env sh
@@ -3340,7 +3669,10 @@ async function installHusky(projectPath, config, options) {
     if (config.preCommit) {
       const preCommitPath = joinPath(huskyDir, "pre-commit");
       if (!await pathExists(preCommitPath) || options?.overwrite) {
-        await writeFile(preCommitPath, generatePreCommitHook(config.lintCommand));
+        await writeFile(
+          preCommitPath,
+          generatePreCommitHook(config.lintCommand, config.preCommitConfig)
+        );
         await makeExecutable(preCommitPath);
         result.created.push("pre-commit");
       } else {
@@ -3572,8 +3904,8 @@ async function getHooksStatus(projectPath) {
     let executable = false;
     if (exists) {
       try {
-        const fs6 = await import("fs/promises");
-        const stats = await fs6.stat(filePath);
+        const fs9 = await import("fs/promises");
+        const stats = await fs9.stat(filePath);
         executable = (stats.mode & 73) !== 0;
       } catch {
       }
@@ -5786,11 +6118,13 @@ function processTemplate(template, projectInfo, options) {
   const commands = options?.templateConfig?.commands;
   const targets = options?.templateConfig?.targets;
   const preferences = options?.claudeConfig?.preferences;
+  const standards = options?.claudeConfig?.extras?.standards;
   content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectInfo.name).replace(/\{\{PROJECT_DESCRIPTION\}\}/g, projectInfo.description).replace(/\{\{ORG\}\}/g, projectInfo.org).replace(/\{\{REPO\}\}/g, projectInfo.repo).replace(/\{\{ENTITY_TYPE\}\}/g, projectInfo.entityType).replace(/\{\{ENTITY_TYPE_PLURAL\}\}/g, projectInfo.entityTypePlural).replace(/\{\{LOCATION\}\}/g, projectInfo.location || "");
   const packageManager = preferences?.packageManager || "pnpm";
   content = content.replace(/\{\{PACKAGE_MANAGER\}\}/g, packageManager);
-  const coverageTarget = targets && "coverage" in targets ? String(targets.coverage) : "90";
+  const coverageTarget = standards?.testing?.coverageTarget ? String(standards.testing.coverageTarget) : targets && "coverage" in targets ? String(targets.coverage) : "90";
   content = content.replace(/\{\{COVERAGE_TARGET\}\}/g, coverageTarget);
+  content = processStandardsPlaceholders(content, standards, preferences);
   if (projectInfo.domain) {
     content = content.replace(/\{\{#if DOMAIN\}\}/g, "").replace(/\{\{\/if\}\}/g, "").replace(/\{\{DOMAIN\}\}/g, projectInfo.domain);
   } else {
@@ -5887,6 +6221,55 @@ function generateCommandsSection(commands, packageManager) {
   lines.push("```");
   return lines.join("\n");
 }
+function processStandardsPlaceholders(content, standards, preferences) {
+  let result = content;
+  const primaryLanguage = "TypeScript";
+  result = result.replace(/\{\{PRIMARY_LANGUAGE\}\}/g, primaryLanguage);
+  const maxFileLines = standards?.code?.maxFileLines?.toString() || "500";
+  result = result.replace(/\{\{MAX_FILE_LINES\}\}/g, maxFileLines);
+  const testPattern = standards?.testing?.testPattern === "gwt" ? "GWT (Given-When-Then)" : "AAA (Arrange, Act, Assert)";
+  result = result.replace(/\{\{TEST_PATTERN\}\}/g, testPattern);
+  const responseLanguage = preferences?.responseLanguage === "es" ? "Spanish" : preferences?.responseLanguage === "en" ? "English" : "Spanish";
+  result = result.replace(/\{\{RESPONSE_LANGUAGE\}\}/g, responseLanguage);
+  if (standards?.code?.namedExportsOnly) {
+    result = result.replace(/\{\{#if NAMED_EXPORTS_ONLY\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  } else {
+    result = result.replace(/\{\{#if NAMED_EXPORTS_ONLY\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  if (standards?.code?.jsDocRequired) {
+    result = result.replace(/\{\{#if JSDOC_REQUIRED\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  } else {
+    result = result.replace(/\{\{#if JSDOC_REQUIRED\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  if (standards?.code?.roroPattern) {
+    result = result.replace(/\{\{#if RORO_PATTERN\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  } else {
+    result = result.replace(/\{\{#if RORO_PATTERN\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  if (standards?.testing?.tddRequired) {
+    result = result.replace(/\{\{#if TDD_REQUIRED\}\}/g, "").replace(/\{\{else\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  } else {
+    result = result.replace(/\{\{#if TDD_REQUIRED\}\}[\s\S]*?\{\{else\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  }
+  const testLocation = standards?.testing?.testLocation;
+  if (testLocation) {
+    const testLocationText = testLocation === "colocated" ? "Co-located with source" : "Separate test directory";
+    result = result.replace(/\{\{#if TEST_LOCATION\}\}/g, "").replace(/\{\{\/if\}\}/g, "").replace(/\{\{TEST_LOCATION\}\}/g, testLocationText);
+  } else {
+    result = result.replace(/\{\{#if TEST_LOCATION\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  if (preferences?.includeCoAuthor) {
+    result = result.replace(/\{\{#if INCLUDE_CO_AUTHOR\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  } else {
+    result = result.replace(/\{\{#if INCLUDE_CO_AUTHOR\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  if (preferences?.responseLanguage) {
+    result = result.replace(/\{\{#if RESPONSE_LANGUAGE\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  } else {
+    result = result.replace(/\{\{#if RESPONSE_LANGUAGE\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  return result;
+}
 function getMinimalTemplate() {
   return `# CLAUDE.md
 
@@ -6432,6 +6815,242 @@ async function generateScaffoldWithProgress(projectPath, options) {
   );
 }
 
+// src/lib/scaffold/settings-generator.ts
+init_esm_shims();
+
+// src/constants/claude-settings-defaults.ts
+init_esm_shims();
+var DEFAULT_CLAUDE_SETTINGS = {
+  model: "sonnet",
+  alwaysThinkingEnabled: false,
+  sandbox: {
+    enabled: false,
+    autoAllowBashIfSandboxed: true
+  },
+  permissions: {
+    allow: [],
+    deny: [],
+    ask: [],
+    defaultMode: "acceptEdits"
+  },
+  attribution: {
+    commit: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)\n\n   Co-Authored-By: Claude <noreply@anthropic.com>",
+    pr: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)"
+  },
+  cleanupPeriodDays: 30,
+  stopNotification: "beep"
+};
+var ATTRIBUTION_NO_COAUTHOR = {
+  commit: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)",
+  pr: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)"
+};
+var ATTRIBUTION_WITH_COAUTHOR = {
+  commit: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)\n\n   Co-Authored-By: Claude <noreply@anthropic.com>",
+  pr: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)"
+};
+var BEEP_COMMAND = "echo -ne '\\007'";
+var MODEL_DESCRIPTIONS = {
+  sonnet: "Claude Sonnet - Balanced performance and speed (recommended)",
+  opus: "Claude Opus - Most capable, best for complex tasks",
+  haiku: "Claude Haiku - Fastest, best for simple tasks",
+  default: "Default - Let Claude Code decide based on task"
+};
+var PERMISSION_MODE_DESCRIPTIONS = {
+  acceptEdits: "Accept edits automatically, ask for other operations",
+  askAlways: "Ask for confirmation on all operations",
+  viewOnly: "Read-only mode, no modifications allowed"
+};
+var STOP_NOTIFICATION_DESCRIPTIONS = {
+  beep: "Play a beep sound when task completes",
+  custom: "Run a custom command when task completes",
+  none: "No notification"
+};
+var CLAUDE_SETTINGS_PRESETS = {
+  /** Default preset - balanced settings */
+  default: {
+    ...DEFAULT_CLAUDE_SETTINGS
+  },
+  /** Performance preset - faster model, less confirmations */
+  performance: {
+    ...DEFAULT_CLAUDE_SETTINGS,
+    model: "haiku",
+    permissions: {
+      ...DEFAULT_CLAUDE_SETTINGS.permissions,
+      defaultMode: "acceptEdits"
+    }
+  },
+  /** Quality preset - best model, extended thinking */
+  quality: {
+    ...DEFAULT_CLAUDE_SETTINGS,
+    model: "opus",
+    alwaysThinkingEnabled: true
+  },
+  /** Secure preset - sandbox enabled, more confirmations */
+  secure: {
+    ...DEFAULT_CLAUDE_SETTINGS,
+    sandbox: {
+      enabled: true,
+      autoAllowBashIfSandboxed: true
+    },
+    permissions: {
+      ...DEFAULT_CLAUDE_SETTINGS.permissions,
+      defaultMode: "askAlways"
+    }
+  }
+};
+var PRESET_DESCRIPTIONS2 = {
+  default: "Balanced settings for most projects",
+  performance: "Faster responses with Haiku model",
+  quality: "Best quality with Opus model and extended thinking",
+  secure: "Enhanced security with sandbox and confirmations"
+};
+
+// src/lib/scaffold/settings-generator.ts
+init_fs();
+async function generateSettings(projectPath, options) {
+  const settingsPath = joinPath(projectPath, ".claude", "settings.json");
+  const exists = await pathExists(settingsPath);
+  if (exists && !options?.overwrite) {
+    return {
+      created: false,
+      skipped: true,
+      path: settingsPath
+    };
+  }
+  try {
+    const settings = buildSettingsJson(options);
+    await writeJson(settingsPath, settings, { spaces: 2 });
+    return {
+      created: true,
+      skipped: false,
+      path: settingsPath
+    };
+  } catch (error) {
+    return {
+      created: false,
+      skipped: false,
+      path: settingsPath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function generateSettingsWithSpinner(projectPath, options) {
+  return withSpinner("Generating settings.json...", () => generateSettings(projectPath, options), {
+    successText: "Created settings.json"
+  });
+}
+async function generateSettingsLocal(projectPath, options) {
+  const settingsPath = joinPath(projectPath, ".claude", "settings.local.json");
+  const exists = await pathExists(settingsPath);
+  if (exists && !options?.overwrite) {
+    return {
+      created: false,
+      skipped: true,
+      path: settingsPath
+    };
+  }
+  try {
+    const settings = buildSettingsLocalJson(options);
+    await writeJson(settingsPath, settings, { spaces: 2 });
+    return {
+      created: true,
+      skipped: false,
+      path: settingsPath
+    };
+  } catch (error) {
+    return {
+      created: false,
+      skipped: false,
+      path: settingsPath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function generateSettingsLocalWithSpinner(projectPath, options) {
+  return withSpinner(
+    "Generating settings.local.json...",
+    () => generateSettingsLocal(projectPath, options),
+    {
+      successText: "Created settings.local.json"
+    }
+  );
+}
+function buildSettingsJson(options) {
+  const claudeSettings = options?.claudeSettings || DEFAULT_CLAUDE_SETTINGS;
+  const includeCoAuthor = options?.includeCoAuthor ?? true;
+  const settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json"
+  };
+  if (claudeSettings.model && claudeSettings.model !== "default") {
+    settings.model = claudeSettings.model;
+  }
+  if (claudeSettings.alwaysThinkingEnabled) {
+    settings.alwaysThinkingEnabled = true;
+  }
+  if (claudeSettings.cleanupPeriodDays !== 30) {
+    settings.cleanupPeriodDays = claudeSettings.cleanupPeriodDays;
+  }
+  settings.attribution = includeCoAuthor ? ATTRIBUTION_WITH_COAUTHOR : ATTRIBUTION_NO_COAUTHOR;
+  settings.permissions = {
+    allow: [],
+    deny: []
+  };
+  if (claudeSettings.sandbox?.enabled) {
+    settings.sandbox = {
+      enabled: true,
+      autoAllowBashIfSandboxed: claudeSettings.sandbox.autoAllowBashIfSandboxed ?? true
+    };
+  }
+  return settings;
+}
+function buildSettingsLocalJson(options) {
+  const claudeSettings = options?.claudeSettings || DEFAULT_CLAUDE_SETTINGS;
+  const settings = {};
+  const allow = [...options?.additionalAllow || []];
+  const deny = [...options?.additionalDeny || []];
+  if (claudeSettings.permissions?.allow) {
+    allow.push(...claudeSettings.permissions.allow);
+  }
+  if (claudeSettings.permissions?.deny) {
+    deny.push(...claudeSettings.permissions.deny);
+  }
+  settings.permissions = {
+    allow: [...new Set(allow)],
+    // Deduplicate
+    deny: [...new Set(deny)],
+    ask: claudeSettings.permissions?.ask || [],
+    defaultMode: claudeSettings.permissions?.defaultMode || "acceptEdits"
+  };
+  if (claudeSettings.stopNotification && claudeSettings.stopNotification !== "none") {
+    const command = claudeSettings.stopNotification === "custom" && claudeSettings.customStopCommand ? claudeSettings.customStopCommand : BEEP_COMMAND;
+    settings.hooks = {
+      Stop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command,
+              timeout: 5
+            }
+          ]
+        }
+      ],
+      SubagentStop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command,
+              timeout: 5
+            }
+          ]
+        }
+      ]
+    };
+  }
+  return settings;
+}
+
 // src/lib/templates/config-replacer.ts
 init_esm_shims();
 import * as fs4 from "fs/promises";
@@ -8385,53 +9004,189 @@ async function promptCICDConfig(options) {
   };
 }
 
-// src/cli/prompts/code-style.ts
+// src/cli/prompts/claude-settings.ts
 init_esm_shims();
-var CODE_STYLE_TOOLS = [
-  {
-    name: "EditorConfig",
-    value: "editorconfig",
-    description: "Consistent coding styles across editors",
-    checked: true
-  },
-  {
-    name: "Commitlint",
-    value: "commitlint",
-    description: "Lint commit messages (conventional commits)",
-    checked: true
-  },
-  {
-    name: "Biome",
-    value: "biome",
-    description: "Fast linter and formatter (ESLint + Prettier alternative)",
-    checked: false
-  },
-  {
-    name: "Prettier",
-    value: "prettier",
-    description: "Code formatter (use if not using Biome)",
-    checked: false
-  }
-];
-async function promptCodeStyleConfig(options) {
-  logger.section("Code Style", "\u{1F3A8}");
-  logger.info("Configure code formatting and linting tools");
-  logger.newline();
-  const enableCodeStyle = await confirm({
-    message: "Would you like to install code style configuration files?",
+async function promptClaudeSettings(options) {
+  logger.section("Claude Code Settings", "\u{1F916}");
+  const wantToConfigure = await confirm({
+    message: "Would you like to configure Claude Code settings?",
     default: true
   });
-  if (!enableCodeStyle) {
+  if (!wantToConfigure) {
     return {
-      enabled: false,
-      editorconfig: false,
-      commitlint: false,
-      biome: false,
-      prettier: false
+      ...DEFAULT_CLAUDE_SETTINGS,
+      attribution: options?.includeCoAuthor ? DEFAULT_CLAUDE_SETTINGS.attribution : {
+        commit: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)",
+        pr: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)"
+      }
     };
   }
-  const selectedTools = await checkbox({
-    message: "Select the tools to configure:",
+  const setupMode = await select({
+    message: "How would you like to configure?",
+    choices: [
+      { name: "Use a preset", value: "preset" },
+      { name: "Customize settings", value: "custom" }
+    ],
+    default: "preset"
+  });
+  if (setupMode === "preset") {
+    return promptClaudeSettingsPreset(options);
+  }
+  return promptClaudeSettingsCustom(options);
+}
+async function promptClaudeSettingsPreset(options) {
+  const preset = await select({
+    message: "Choose a settings preset:",
+    choices: Object.entries(PRESET_DESCRIPTIONS2).map(([key, description]) => ({
+      name: `${key.charAt(0).toUpperCase() + key.slice(1)} - ${description}`,
+      value: key
+    })),
+    default: "default"
+  });
+  const config = { ...CLAUDE_SETTINGS_PRESETS[preset] };
+  if (options?.includeCoAuthor === false) {
+    config.attribution = {
+      commit: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)",
+      pr: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)"
+    };
+  }
+  return config;
+}
+async function promptClaudeSettingsCustom(options) {
+  const defaults = options?.defaults || DEFAULT_CLAUDE_SETTINGS;
+  const model = await select({
+    message: "Default Claude model:",
+    choices: Object.entries(MODEL_DESCRIPTIONS).map(([key, description]) => ({
+      name: description,
+      value: key
+    })),
+    default: defaults.model || "sonnet"
+  });
+  const alwaysThinkingEnabled = await confirm({
+    message: "Enable extended thinking by default? (better for complex tasks)",
+    default: defaults.alwaysThinkingEnabled ?? false
+  });
+  const sandboxEnabled = await confirm({
+    message: "Enable bash sandboxing? (isolates shell commands for security)",
+    default: defaults.sandbox?.enabled ?? false
+  });
+  const permissionMode = await select({
+    message: "Default permission mode:",
+    choices: Object.entries(PERMISSION_MODE_DESCRIPTIONS).map(([key, description]) => ({
+      name: description,
+      value: key
+    })),
+    default: defaults.permissions?.defaultMode || "acceptEdits"
+  });
+  const cleanupPeriodStr = await input({
+    message: "Session cleanup period (days, 0 = delete all immediately):",
+    default: String(defaults.cleanupPeriodDays ?? 30),
+    validate: (value) => {
+      const num = Number.parseInt(value, 10);
+      if (Number.isNaN(num) || num < 0 || num > 365) {
+        return "Please enter a number between 0 and 365";
+      }
+      return true;
+    }
+  });
+  const cleanupPeriodDays = Number.parseInt(cleanupPeriodStr, 10);
+  const stopNotification = await select({
+    message: "Notification when task completes:",
+    choices: Object.entries(STOP_NOTIFICATION_DESCRIPTIONS).map(([key, description]) => ({
+      name: description,
+      value: key
+    })),
+    default: defaults.stopNotification || "beep"
+  });
+  let customStopCommand;
+  if (stopNotification === "custom") {
+    customStopCommand = await input({
+      message: "Custom command to run on task completion:",
+      default: defaults.customStopCommand || ""
+    });
+  }
+  const config = {
+    model,
+    alwaysThinkingEnabled,
+    sandbox: {
+      enabled: sandboxEnabled,
+      autoAllowBashIfSandboxed: true
+    },
+    permissions: {
+      allow: defaults.permissions?.allow || [],
+      deny: defaults.permissions?.deny || [],
+      ask: defaults.permissions?.ask || [],
+      defaultMode: permissionMode
+    },
+    attribution: options?.includeCoAuthor === false ? {
+      commit: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)",
+      pr: "\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)"
+    } : DEFAULT_CLAUDE_SETTINGS.attribution,
+    cleanupPeriodDays,
+    stopNotification,
+    customStopCommand
+  };
+  if (stopNotification === "beep") {
+    config.hooks = {
+      Stop: [{ hooks: [{ type: "command", command: BEEP_COMMAND, timeout: 5 }] }],
+      SubagentStop: [{ hooks: [{ type: "command", command: BEEP_COMMAND, timeout: 5 }] }]
+    };
+  } else if (stopNotification === "custom" && customStopCommand) {
+    config.hooks = {
+      Stop: [{ hooks: [{ type: "command", command: customStopCommand, timeout: 10 }] }],
+      SubagentStop: [{ hooks: [{ type: "command", command: customStopCommand, timeout: 10 }] }]
+    };
+  }
+  return config;
+}
+
+// src/cli/prompts/code-style.ts
+init_esm_shims();
+var CODE_STYLE_TOOLS = [
+  {
+    name: "EditorConfig",
+    value: "editorconfig",
+    description: "Consistent coding styles across editors",
+    checked: true
+  },
+  {
+    name: "Commitlint",
+    value: "commitlint",
+    description: "Lint commit messages (conventional commits)",
+    checked: true
+  },
+  {
+    name: "Biome",
+    value: "biome",
+    description: "Fast linter and formatter (ESLint + Prettier alternative)",
+    checked: false
+  },
+  {
+    name: "Prettier",
+    value: "prettier",
+    description: "Code formatter (use if not using Biome)",
+    checked: false
+  }
+];
+async function promptCodeStyleConfig(options) {
+  logger.section("Code Style", "\u{1F3A8}");
+  logger.info("Configure code formatting and linting tools");
+  logger.newline();
+  const enableCodeStyle = await confirm({
+    message: "Would you like to install code style configuration files?",
+    default: true
+  });
+  if (!enableCodeStyle) {
+    return {
+      enabled: false,
+      editorconfig: false,
+      commitlint: false,
+      biome: false,
+      prettier: false
+    };
+  }
+  const selectedTools = await checkbox({
+    message: "Select the tools to configure:",
     choices: CODE_STYLE_TOOLS.map((tool) => ({
       name: `${tool.name} - ${tool.description}`,
       value: tool.value,
@@ -9522,7 +10277,95 @@ async function promptSubagentStopHook() {
 
 // src/cli/prompts/item-select.ts
 init_esm_shims();
-async function promptBatchAction(category, totalItems, hasPreset) {
+
+// src/cli/prompts/mutual-exclusivity.ts
+init_esm_shims();
+function getConflictingSelections(module, selectedIds) {
+  if (!module.alternativeTo) {
+    return [];
+  }
+  return module.alternativeTo.filter((altId) => selectedIds.includes(altId));
+}
+function createChoicesWithExclusivity(modules, selectedIds, options) {
+  const choices = [];
+  for (const module of modules) {
+    const conflicts = getConflictingSelections(module, selectedIds);
+    const isConflicting = conflicts.length > 0;
+    const isPreselected = options?.preselected?.includes(module.id);
+    const isSelected = selectedIds.includes(module.id);
+    let name = module.name;
+    let description = module.description;
+    let disabled = false;
+    if (isConflicting) {
+      const conflictNames = conflicts.join(", ");
+      disabled = options?.showConflictReason ? `Conflicts with: ${conflictNames}` : `Alternative to ${conflictNames} (already selected)`;
+      name = colors.muted(`${module.name} (incompatible)`);
+      description = `${colors.muted("\u26A0")} ${disabled}`;
+    }
+    choices.push({
+      name,
+      value: module.id,
+      description,
+      disabled: isConflicting ? disabled : false,
+      checked: isSelected || isPreselected && !isConflicting
+    });
+  }
+  return choices;
+}
+function validateNoConflicts(selectedIds, allModules) {
+  const conflicts = [];
+  for (const id of selectedIds) {
+    const module = allModules.find((m) => m.id === id);
+    if (!module?.alternativeTo) continue;
+    for (const altId of module.alternativeTo) {
+      if (selectedIds.includes(altId)) {
+        const existingConflict = conflicts.find(
+          (c) => c.selected === id && c.conflictsWith === altId || c.selected === altId && c.conflictsWith === id
+        );
+        if (!existingConflict) {
+          conflicts.push({ selected: id, conflictsWith: altId });
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function groupByExclusivity(modules) {
+  const groups = /* @__PURE__ */ new Map();
+  const processedIds = /* @__PURE__ */ new Set();
+  for (const module of modules) {
+    if (processedIds.has(module.id)) continue;
+    const groupMembers = /* @__PURE__ */ new Set([module.id]);
+    const toProcess = [...module.alternativeTo || []];
+    while (toProcess.length > 0) {
+      const altId = toProcess.pop();
+      if (!altId || groupMembers.has(altId)) continue;
+      const altModule = modules.find((m) => m.id === altId);
+      if (altModule) {
+        groupMembers.add(altId);
+        for (const transitiveAlt of altModule.alternativeTo || []) {
+          if (!groupMembers.has(transitiveAlt)) {
+            toProcess.push(transitiveAlt);
+          }
+        }
+      }
+    }
+    if (groupMembers.size > 1) {
+      const sortedMembers = Array.from(groupMembers).sort();
+      const groupId = `exclusivity-group-${sortedMembers[0]}`;
+      groups.set(groupId, sortedMembers);
+      for (const memberId of groupMembers) {
+        processedIds.add(memberId);
+      }
+    } else {
+      processedIds.add(module.id);
+    }
+  }
+  return groups;
+}
+
+// src/cli/prompts/item-select.ts
+async function promptBatchAction(category, totalItems, options) {
   const choices = [
     {
       name: "Install all (recommended)",
@@ -9540,7 +10383,14 @@ async function promptBatchAction(category, totalItems, hasPreset) {
       description: `Skip all ${category}`
     }
   ];
-  if (hasPreset) {
+  if (options?.hasExclusivityGroups && options.exclusivityGroupCount) {
+    choices.splice(1, 0, {
+      name: colors.primary("Smart selection (handles conflicts)"),
+      value: "smart",
+      description: `Intelligent selection with ${options.exclusivityGroupCount} mutually exclusive group(s)`
+    });
+  }
+  if (options?.hasPreset) {
     choices.splice(1, 0, {
       name: "Use preset for this category",
       value: "preset",
@@ -9550,27 +10400,43 @@ async function promptBatchAction(category, totalItems, hasPreset) {
   return select({
     message: `${capitalize(category)} selection (${totalItems} available):`,
     choices,
-    default: "all"
+    default: options?.hasExclusivityGroups ? "smart" : "all"
   });
 }
 async function selectItemsFromCategory(category, items, options) {
-  const selectedItems = [];
-  const skippedItems = [];
   logger.newline();
   logger.subtitle(`${capitalize(category)} Selection`);
   logger.info(`${items.length} ${category} available`);
+  const exclusivityGroups = groupByExclusivity(items);
+  const hasExclusivityGroups = exclusivityGroups.size > 0;
+  if (hasExclusivityGroups) {
+    logger.info(
+      colors.warning(
+        `${exclusivityGroups.size} group(s) of mutually exclusive ${category} detected`
+      )
+    );
+  }
   logger.newline();
-  const batchAction = await promptBatchAction(
-    category,
-    items.length,
-    options?.preselected && options.preselected.length > 0
-  );
+  const batchAction = await promptBatchAction(category, items.length, {
+    hasPreset: options?.preselected && options.preselected.length > 0,
+    hasExclusivityGroups,
+    exclusivityGroupCount: exclusivityGroups.size
+  });
   if (batchAction === "all") {
-    return {
-      category,
-      selectedItems: items.map((i) => i.id),
-      skippedItems: []
-    };
+    const conflicts = validateNoConflicts(
+      items.map((i) => i.id),
+      items
+    );
+    if (conflicts.length > 0) {
+      logger.warn("Cannot install all: some modules are mutually exclusive.");
+      logger.info("Switching to smart selection mode...");
+    } else {
+      return {
+        category,
+        selectedItems: items.map((i) => i.id),
+        skippedItems: []
+      };
+    }
   }
   if (batchAction === "none") {
     return {
@@ -9581,24 +10447,106 @@ async function selectItemsFromCategory(category, items, options) {
   }
   if (batchAction === "preset" && options?.preselected) {
     const preselectedSet = new Set(options.preselected);
-    return {
+    const preselectedIds = items.filter((i) => preselectedSet.has(i.id)).map((i) => i.id);
+    const conflicts = validateNoConflicts(preselectedIds, items);
+    if (conflicts.length > 0) {
+      logger.warn("Preset contains conflicting modules. Switching to smart selection...");
+    } else {
+      return {
+        category,
+        selectedItems: preselectedIds,
+        skippedItems: items.filter((i) => !preselectedSet.has(i.id)).map((i) => i.id)
+      };
+    }
+  }
+  if (batchAction === "smart" || batchAction === "all" || batchAction === "preset") {
+    return selectItemsWithExclusivity(category, items, options);
+  }
+  return selectItemsOneByOne(category, items, options);
+}
+async function selectItemsWithExclusivity(category, items, options) {
+  let selectedIds = options?.preselected?.filter((id) => items.some((i) => i.id === id)) || [];
+  let confirmed = false;
+  while (!confirmed) {
+    const choices = createChoicesWithExclusivity(items, selectedIds, {
+      preselected: options?.preselected,
+      showConflictReason: true
+    });
+    logger.newline();
+    logger.info(
+      colors.muted("Items marked as incompatible are disabled based on your selections.")
+    );
+    logger.info(colors.muted("Uncheck items to enable their alternatives."));
+    logger.newline();
+    const newSelection = await checkbox({
+      message: `Select ${category} (Space to toggle, Enter to confirm):`,
+      choices: choices.map((c) => ({
+        name: c.name,
+        value: c.value,
+        description: c.description,
+        disabled: c.disabled,
+        checked: c.checked
+      })),
+      required: false
+    });
+    const conflicts = validateNoConflicts(newSelection, items);
+    if (conflicts.length > 0) {
+      logger.warn("Your selection contains conflicts:");
+      for (const conflict of conflicts) {
+        const module1 = items.find((i) => i.id === conflict.selected)?.name || conflict.selected;
+        const module2 = items.find((i) => i.id === conflict.conflictsWith)?.name || conflict.conflictsWith;
+        logger.info(`  ${colors.error("\u2022")} ${module1} and ${module2} are mutually exclusive`);
+      }
+      logger.info("Please adjust your selection.");
+      selectedIds = newSelection;
+      continue;
+    }
+    selectedIds = newSelection;
+    showCategorySelectionSummary({
       category,
-      selectedItems: items.filter((i) => preselectedSet.has(i.id)).map((i) => i.id),
-      skippedItems: items.filter((i) => !preselectedSet.has(i.id)).map((i) => i.id)
-    };
+      selectedItems: selectedIds,
+      skippedItems: items.filter((i) => !selectedIds.includes(i.id)).map((i) => i.id)
+    });
+    confirmed = await confirm({
+      message: "Is this selection correct?",
+      default: true
+    });
   }
+  return {
+    category,
+    selectedItems: selectedIds,
+    skippedItems: items.filter((i) => !selectedIds.includes(i.id)).map((i) => i.id)
+  };
+}
+async function selectItemsOneByOne(category, items, options) {
+  const selectedItems = [];
+  const skippedItems = [];
   const remainingItems = [...items];
   let currentIndex = 0;
   while (currentIndex < remainingItems.length) {
     const item = remainingItems[currentIndex];
     const remaining = remainingItems.length - currentIndex - 1;
     const isPreselected = options?.preselected?.includes(item.id);
+    const conflicts = item.alternativeTo?.filter((altId) => selectedItems.includes(altId)) || [];
+    if (conflicts.length > 0) {
+      const conflictNames = conflicts.map((id) => items.find((i) => i.id === id)?.name || id).join(", ");
+      logger.info(
+        colors.muted(`Skipping ${item.name} (conflicts with selected: ${conflictNames})`)
+      );
+      skippedItems.push(item.id);
+      currentIndex++;
+      continue;
+    }
     const progress = colors.muted(`[${currentIndex + 1}/${remainingItems.length}]`);
     console.log(`
 ${progress} ${colors.bold(item.name)}`);
     if (options?.showDescriptions && item.description) {
       logger.note(item.description);
     }
+    if (item.alternativeTo && item.alternativeTo.length > 0) {
+      const altNames = item.alternativeTo.map((id) => items.find((i) => i.id === id)?.name || id).join(", ");
+      logger.info(colors.warning(`\u26A0 Selecting this will disable: ${altNames}`));
+    }
     const action = await promptItemWithShortcuts(item, {
       defaultInstall: isPreselected,
       remainingCount: remaining
@@ -9615,7 +10563,13 @@ ${progress} ${colors.bold(item.name)}`);
       case "install-rest":
         selectedItems.push(item.id);
         for (let i = currentIndex + 1; i < remainingItems.length; i++) {
-          selectedItems.push(remainingItems[i].id);
+          const nextItem = remainingItems[i];
+          const nextConflicts = nextItem.alternativeTo?.filter((altId) => selectedItems.includes(altId)) || [];
+          if (nextConflicts.length === 0) {
+            selectedItems.push(nextItem.id);
+          } else {
+            skippedItems.push(nextItem.id);
+          }
         }
         currentIndex = remainingItems.length;
         break;
@@ -9657,6 +10611,17 @@ async function promptItemWithShortcuts(item, options) {
     default: options.defaultInstall !== false ? "install" : "skip"
   });
 }
+function showCategorySelectionSummary(result) {
+  const { category, selectedItems, skippedItems } = result;
+  logger.newline();
+  logger.subtitle(`${capitalize(category)} Summary`);
+  if (selectedItems.length > 0) {
+    logger.success(`Selected (${selectedItems.length}): ${selectedItems.join(", ")}`);
+  }
+  if (skippedItems.length > 0) {
+    logger.info(`Skipped (${skippedItems.length}): ${colors.muted(skippedItems.join(", "))}`);
+  }
+}
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -10420,6 +11385,122 @@ async function confirmProjectInfo(info) {
   });
 }
 
+// src/cli/prompts/related-skills.ts
+init_esm_shims();
+function getAllRelatedSkillIds(agentModules) {
+  const relatedIds = /* @__PURE__ */ new Set();
+  for (const agent of agentModules) {
+    if (agent.relatedSkills) {
+      for (const skillId of agent.relatedSkills) {
+        relatedIds.add(skillId);
+      }
+    }
+  }
+  return Array.from(relatedIds);
+}
+function getAgentsWithRelatedSkills(selectedAgentIds, agentModules) {
+  return agentModules.filter(
+    (agent) => selectedAgentIds.includes(agent.id) && agent.relatedSkills && agent.relatedSkills.length > 0
+  );
+}
+async function promptRelatedSkillsForAgent(agent, skillModules, options) {
+  if (!agent.relatedSkills || agent.relatedSkills.length === 0) {
+    return [];
+  }
+  const relatedSkillDefs = agent.relatedSkills.map((skillId) => skillModules.find((s) => s.id === skillId)).filter((s) => s !== void 0);
+  if (relatedSkillDefs.length === 0) {
+    return [];
+  }
+  if (relatedSkillDefs.length === 1) {
+    const skill = relatedSkillDefs[0];
+    const action = await select({
+      message: `${colors.primary(agent.name)} has a related skill. Install it?`,
+      choices: [
+        {
+          name: `Install ${skill.name}`,
+          value: "install",
+          description: skill.description
+        },
+        {
+          name: "Skip",
+          value: "skip",
+          description: "Do not install this skill"
+        }
+      ],
+      default: "install"
+    });
+    return action === "install" ? [skill.id] : [];
+  }
+  const choices = relatedSkillDefs.map((skill) => ({
+    name: skill.name,
+    value: skill.id,
+    description: skill.description,
+    checked: options?.preselected?.includes(skill.id) ?? false
+  }));
+  if (options?.allowMultiple !== false) {
+    const selected2 = await checkbox({
+      message: `${colors.primary(agent.name)} supports multiple frameworks. Select which patterns to install:`,
+      choices,
+      required: false
+    });
+    return selected2;
+  }
+  const choicesWithSkip = [
+    ...choices.map((c) => ({ name: c.name, value: c.value, description: c.description })),
+    {
+      name: colors.muted("Skip (none)"),
+      value: "__skip__",
+      description: "Do not install any related skill for this agent"
+    }
+  ];
+  const selected = await select({
+    message: `${colors.primary(agent.name)} supports multiple frameworks. Select which patterns to use:`,
+    choices: choicesWithSkip,
+    default: choicesWithSkip[0]?.value
+  });
+  return selected === "__skip__" ? [] : [selected];
+}
+async function promptAllRelatedSkills(selectedAgentIds, registry, options) {
+  const agentsWithRelated = getAgentsWithRelatedSkills(selectedAgentIds, registry.agents);
+  const allRelatedSkillIds = getAllRelatedSkillIds(registry.agents);
+  if (agentsWithRelated.length === 0) {
+    return {
+      relatedSkillsSelected: [],
+      relatedSkillsSkipped: [],
+      allRelatedSkillIds
+    };
+  }
+  logger.newline();
+  logger.subtitle("Framework-Specific Skills");
+  logger.info(
+    "The selected agents support framework-specific patterns. Select which ones to install."
+  );
+  logger.newline();
+  const selectedSkills = [];
+  const skippedSkills = [];
+  for (const agent of agentsWithRelated) {
+    const selected = await promptRelatedSkillsForAgent(agent, registry.skills, {
+      preselected: options?.preselectedSkills,
+      allowMultiple: options?.allowMultiplePerAgent
+    });
+    selectedSkills.push(...selected);
+    const agentRelatedIds = agent.relatedSkills || [];
+    const skipped = agentRelatedIds.filter((id) => !selected.includes(id));
+    skippedSkills.push(...skipped);
+  }
+  const uniqueSelected = [...new Set(selectedSkills)];
+  const uniqueSkipped = [...new Set(skippedSkills)].filter((id) => !uniqueSelected.includes(id));
+  return {
+    relatedSkillsSelected: uniqueSelected,
+    relatedSkillsSkipped: uniqueSkipped,
+    allRelatedSkillIds
+  };
+}
+function filterOutRelatedSkills(skillModules, relatedSkillIds) {
+  const relatedSet = new Set(relatedSkillIds);
+  return skillModules.filter((skill) => !relatedSet.has(skill.id));
+}
+
 // src/cli/prompts/scaffold.ts
 init_esm_shims();
 async function promptScaffoldType(options) {
@@ -10609,27 +11690,27 @@ async function buildConfigContext(projectPath) {
     values: {}
   };
   try {
-    const fs6 = await import("fs/promises");
-    const path8 = await import("path");
-    const pkgPath = path8.join(projectPath, "package.json");
-    const pkgContent = await fs6.readFile(pkgPath, "utf-8");
+    const fs9 = await import("fs/promises");
+    const path11 = await import("path");
+    const pkgPath = path11.join(projectPath, "package.json");
+    const pkgContent = await fs9.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     context.scripts = pkg.scripts || {};
     context.dependencies = {
       ...pkg.dependencies || {},
       ...pkg.devDependencies || {}
     };
-    context.hasTypeScript = Boolean(context.dependencies.typescript) || await fileExists(path8.join(projectPath, "tsconfig.json"));
-    if (await fileExists(path8.join(projectPath, "pnpm-lock.yaml"))) {
+    context.hasTypeScript = Boolean(context.dependencies.typescript) || await fileExists(path11.join(projectPath, "tsconfig.json"));
+    if (await fileExists(path11.join(projectPath, "pnpm-lock.yaml"))) {
       context.packageManager = "pnpm";
-    } else if (await fileExists(path8.join(projectPath, "yarn.lock"))) {
+    } else if (await fileExists(path11.join(projectPath, "yarn.lock"))) {
       context.packageManager = "yarn";
-    } else if (await fileExists(path8.join(projectPath, "bun.lockb"))) {
+    } else if (await fileExists(path11.join(projectPath, "bun.lockb"))) {
       context.packageManager = "bun";
     } else {
       context.packageManager = "npm";
     }
-    context.isGitRepo = await fileExists(path8.join(projectPath, ".git"));
+    context.isGitRepo = await fileExists(path11.join(projectPath, ".git"));
     if (context.isGitRepo) {
       try {
         const { execSync } = await import("child_process");
@@ -10648,8 +11729,8 @@ async function buildConfigContext(projectPath) {
 }
 async function fileExists(filePath) {
   try {
-    const fs6 = await import("fs/promises");
-    await fs6.access(filePath);
+    const fs9 = await import("fs/promises");
+    await fs9.access(filePath);
     return true;
   } catch {
     return false;
@@ -11181,11 +12262,66 @@ function createBundleSelectionStep() {
       }
       if (mode === "individual" || mode === "both") {
         const preselectedFromBundles = resolveBundles(result.selectedBundles);
-        const categories = ["agents", "skills", "commands", "docs"];
         if (ctx.registry) {
           logger.newline();
           logger.subtitle("Individual Module Selection");
-          for (const category of categories) {
+          const agentPreselected = mode === "both" ? preselectedFromBundles.agents : [];
+          const agentResult = await selectItemsFromCategory("agents", ctx.registry.agents, {
+            preselected: agentPreselected,
+            showDescriptions: true
+          });
+          if (mode === "both") {
+            result.additionalModules.agents = agentResult.selectedItems.filter(
+              (id) => !agentPreselected.includes(id)
+            );
+          } else {
+            result.additionalModules.agents = agentResult.selectedItems;
+          }
+          const allSelectedAgents = [
+            ...preselectedFromBundles.agents,
+            ...result.additionalModules.agents
+          ];
+          const relatedSkillsResult = await promptAllRelatedSkills(
+            allSelectedAgents,
+            ctx.registry,
+            {
+              preselectedSkills: mode === "both" ? preselectedFromBundles.skills : [],
+              allowMultiplePerAgent: true
+            }
+          );
+          const skillPreselected = mode === "both" ? preselectedFromBundles.skills : [];
+          const independentSkills = filterOutRelatedSkills(
+            ctx.registry.skills,
+            relatedSkillsResult.allRelatedSkillIds
+          );
+          const independentPreselected = skillPreselected.filter(
+            (id) => !relatedSkillsResult.allRelatedSkillIds.includes(id)
+          );
+          let independentSkillsSelected = [];
+          if (independentSkills.length > 0) {
+            logger.newline();
+            logger.info(
+              colors.muted("Now selecting general-purpose skills (not framework-specific):")
+            );
+            const skillResult = await selectItemsFromCategory("skills", independentSkills, {
+              preselected: independentPreselected,
+              showDescriptions: true
+            });
+            independentSkillsSelected = skillResult.selectedItems;
+          }
+          const allSelectedSkills = [
+            ...relatedSkillsResult.relatedSkillsSelected,
+            ...independentSkillsSelected
+          ];
+          if (mode === "both") {
+            result.additionalModules.skills = allSelectedSkills.filter(
+              (id) => !skillPreselected.includes(id)
+            );
+          } else {
+            result.additionalModules.skills = allSelectedSkills;
+          }
+          const otherCategories = ["commands", "docs"];
+          for (const category of otherCategories) {
             const preselected = mode === "both" ? preselectedFromBundles[category] : [];
             const categoryResult = await selectItemsFromCategory(category, ctx.registry[category], {
               preselected,
@@ -11357,6 +12493,28 @@ function createTemplateConfigStep() {
     }
   };
 }
+function createClaudeSettingsStep() {
+  return {
+    metadata: {
+      id: "claudeSettings",
+      name: "Claude Code Settings",
+      description: "Configure Claude Code model, permissions, and behavior",
+      required: false
+    },
+    computeDefaults: (ctx) => ctx.claudeSettings,
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(11, "Configure Claude Code settings or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptClaudeSettings({
+        defaults,
+        includeCoAuthor: ctx.preferences?.includeCoAuthor
+      });
+      return createResult(value, "next");
+    }
+  };
+}
 function createInitWizardConfig(projectPath, detection, registry) {
   void projectPath;
   void detection;
@@ -11405,6 +12563,10 @@ function createInitWizardConfig(projectPath, detection, registry) {
     {
       id: "templateConfig",
       definition: createTemplateConfigStep()
+    },
+    {
+      id: "claudeSettings",
+      definition: createClaudeSettingsStep()
     }
   ];
   return {
@@ -11683,8 +12845,8 @@ function createInitCommand() {
   ).option("-t, --template <url>", "Remote git repo for templates").option("--branch <name>", "Branch/tag for remote template").option("-y, --yes", "Accept defaults, skip prompts").option("-f, --force", "Overwrite existing .claude/").option("--dry-run", "Show what would happen without making changes").option("--claude-only", "Only Claude config, no project scaffold").option("--no-placeholders", "Skip placeholder replacement").option("--no-mcp", "Skip MCP configuration").option("-v, --verbose", "Detailed output").action(runInit);
   return cmd;
 }
-async function runInit(path8, options) {
-  const projectPath = resolvePath(path8 || ".");
+async function runInit(path11, options) {
+  const projectPath = resolvePath(path11 || ".");
   logger.configure({ verbose: options.verbose, silent: false });
   logger.title("@qazuor/claude-code-config");
   logger.info(`Initializing Claude configuration in ${colors.primary(projectPath)}`);
@@ -11693,6 +12855,7 @@ async function runInit(path8, options) {
     showCancelHint();
   }
   try {
+    let existingConfig = null;
     if (await hasExistingClaudeConfig(projectPath)) {
       if (!options.force) {
         const action = await promptExistingProjectAction();
@@ -11703,6 +12866,10 @@ async function runInit(path8, options) {
         if (action !== "overwrite" && action !== "merge") {
           return;
         }
+        existingConfig = await readConfig(projectPath);
+        if (existingConfig) {
+          logger.info("Using existing configuration as defaults");
+        }
       }
     }
     const detection = await detectProject(projectPath);
@@ -11719,12 +12886,12 @@ async function runInit(path8, options) {
       () => loadRegistry(templatesPath),
       { silent: options.dryRun }
     );
-    const buildResult = options.yes ? await buildDefaultConfig(projectPath, detection, options) : await buildInteractiveConfig(projectPath, detection, registry, options);
+    const buildResult = options.yes ? await buildDefaultConfig(projectPath, detection, options) : await buildInteractiveConfig(projectPath, detection, registry, options, existingConfig);
     if (!buildResult) {
       logger.warn("Configuration cancelled");
       return;
     }
-    const { config, skippedMcpConfigs, templateConfig, cicdConfig } = buildResult;
+    const { config, skippedMcpConfigs, templateConfig, cicdConfig, claudeSettings } = buildResult;
     if (templateConfig) {
       config.templateConfig = templateConfig;
     }
@@ -11741,7 +12908,15 @@ async function runInit(path8, options) {
       showConfigSummary(config);
       return;
     }
-    await executeInstallation(projectPath, config, registry, templatesPath, options, cicdConfig);
+    await executeInstallation(
+      projectPath,
+      config,
+      registry,
+      templatesPath,
+      options,
+      cicdConfig,
+      claudeSettings
+    );
     if (templateConfig && !options.noPlaceholders) {
       const claudePath = joinPath(projectPath, ".claude");
       await replaceTemplateConfigWithSpinner(claudePath, templateConfig);
@@ -11885,7 +13060,7 @@ async function buildDefaultConfig(projectPath, detection, options) {
     // No MCP servers in default mode
   };
 }
-async function buildInteractiveConfig(projectPath, detection, registry, options) {
+async function buildInteractiveConfig(projectPath, detection, registry, options, existingConfig) {
   const projectName = await getProjectName(projectPath);
   const projectDesc = await getProjectDescription(projectPath);
   const wizardConfig = createInitWizardConfig(
@@ -11899,24 +13074,45 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
     },
     registry
   );
+  const existingProject = existingConfig?.project;
+  const existingPrefs = existingConfig?.preferences;
   const initialContext = {
     projectPath,
     registry,
     detection: {
       detected: detection.detected,
       projectType: detection.projectType,
-      packageManager: detection.packageManager,
+      packageManager: existingPrefs?.packageManager || detection.packageManager,
       suggestedBundles: detection.suggestedBundles,
       detectedTechnologies: detection.detectedTechnologies
     },
+    // Use existing project info as defaults, fallback to detected values
     projectInfo: {
-      name: projectName || "",
-      description: projectDesc || "",
-      org: "",
-      repo: projectName?.toLowerCase().replace(/\s+/g, "-") || "",
-      entityType: "item",
-      entityTypePlural: "items"
-    }
+      name: existingProject?.name || projectName || "",
+      description: existingProject?.description || projectDesc || "",
+      org: existingProject?.org || "",
+      repo: existingProject?.repo || projectName?.toLowerCase().replace(/\s+/g, "-") || "",
+      entityType: existingProject?.entityType || "item",
+      entityTypePlural: existingProject?.entityTypePlural || "items",
+      domain: existingProject?.domain,
+      location: existingProject?.location,
+      author: existingProject?.author
+    },
+    // Use existing preferences as defaults
+    preferences: existingPrefs ? {
+      language: existingPrefs.language,
+      responseLanguage: existingPrefs.responseLanguage,
+      includeCoAuthor: existingPrefs.includeCoAuthor,
+      packageManager: existingPrefs.packageManager
+    } : void 0,
+    // Use existing hook config as defaults
+    hookConfig: existingConfig?.extras?.hooks,
+    // Use existing code style config as defaults
+    codeStyleConfig: existingConfig?.extras?.codeStyle,
+    // Use existing folder preferences as defaults
+    folderPreferences: existingConfig?.extras?.folderPreferences,
+    // Use existing permissions config as defaults
+    permissionsConfig: existingConfig?.customizations?.permissions
   };
   const wizardResult = await runWizard(
     wizardConfig,
@@ -11937,7 +13133,8 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
     codeStyleConfig,
     cicdConfig,
     folderPreferences,
-    templateConfig: templateConfigResult
+    templateConfig: templateConfigResult,
+    claudeSettings
   } = wizardResult.values;
   let mcpConfig = { level: "project", servers: [] };
   let skippedMcpConfigs = [];
@@ -11995,10 +13192,11 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
     config,
     skippedMcpConfigs,
     templateConfig: templateConfigResult,
-    cicdConfig
+    cicdConfig,
+    claudeSettings
   };
 }
-async function executeInstallation(projectPath, config, registry, templatesPath, options, cicdConfig) {
+async function executeInstallation(projectPath, config, registry, templatesPath, options, cicdConfig, claudeSettings) {
   logger.newline();
   logger.title("Installing Configuration");
   if (config.scaffold.type === "full-project") {
@@ -12020,6 +13218,28 @@ async function executeInstallation(projectPath, config, registry, templatesPath,
   } else if (claudeMdResult.skipped) {
     logger.info("CLAUDE.md already exists, skipped");
   }
+  if (claudeSettings) {
+    const settingsResult = await generateSettingsWithSpinner(projectPath, {
+      claudeSettings,
+      includeCoAuthor: config.preferences.includeCoAuthor,
+      overwrite: options.force
+    });
+    if (settingsResult.error) {
+      logger.warn(`settings.json generation warning: ${settingsResult.error}`);
+    } else if (settingsResult.skipped) {
+      logger.info("settings.json already exists, skipped");
+    }
+    const settingsLocalResult = await generateSettingsLocalWithSpinner(projectPath, {
+      claudeSettings,
+      includeCoAuthor: config.preferences.includeCoAuthor,
+      overwrite: options.force
+    });
+    if (settingsLocalResult.error) {
+      logger.warn(`settings.local.json generation warning: ${settingsLocalResult.error}`);
+    } else if (settingsLocalResult.skipped) {
+      logger.info("settings.local.json already exists, skipped");
+    }
+  }
   const modulesByCategory = {
     agents: filterModules(registry, "agents", config.modules.agents.selected),
     skills: filterModules(registry, "skills", config.modules.skills.selected),
@@ -12642,7 +13862,7 @@ async function runStatus(options) {
     }
     const config = await readConfig(projectPath);
     if (!config) {
-      logger.warn(".claude directory exists but config.json is missing");
+      logger.warn(".claude directory exists but qazuor-claude-config.json is missing");
       logger.info('Run "claude-config init" to initialize properly');
       process.exit(0);
     }
@@ -13142,8 +14362,8 @@ function createConfigureCommand() {
   ).option("--preview", "Preview changes without applying").option("--show-defaults", "Show global defaults").option("-v, --verbose", "Detailed output").action(runConfigure);
   return cmd;
 }
-async function runConfigure(path8, options) {
-  const projectPath = resolvePath(path8 || ".");
+async function runConfigure(path11, options) {
+  const projectPath = resolvePath(path11 || ".");
   const claudePath = joinPath(projectPath, ".claude");
   logger.configure({ verbose: options.verbose, silent: false });
   logger.title("Template Configuration");
@@ -13274,16 +14494,1837 @@ async function interactiveMode(claudePath, projectPath, options) {
     };
     existingConfig.customizations.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     await writeConfig(projectPath, existingConfig);
-    logger.success("Configuration saved to .claude/config.json");
+    logger.success("Configuration saved to .claude/qazuor-claude-config.json");
   }
   await promptSaveGlobalDefaults(templateConfig);
   logger.newline();
   logger.success("Template configuration complete!");
 }
 
+// src/cli/commands/standards.ts
+init_esm_shims();
+import { Command as Command8 } from "commander";
+
+// src/constants/standards-defaults.ts
+init_esm_shims();
+var DEFAULT_CODE_STANDARDS = {
+  indentStyle: "space",
+  indentSize: 2,
+  maxLineLength: 100,
+  maxFileLines: 500,
+  quoteStyle: "single",
+  semicolons: true,
+  trailingCommas: "es5",
+  allowAny: false,
+  namedExportsOnly: true,
+  roroPattern: true,
+  jsDocRequired: true
+};
+var DEFAULT_TESTING_STANDARDS = {
+  coverageTarget: 80,
+  tddRequired: true,
+  testPattern: "aaa",
+  testLocation: "separate",
+  unitTestMaxMs: 100,
+  integrationTestMaxMs: 1e3
+};
+var DEFAULT_DOCUMENTATION_STANDARDS = {
+  jsDocLevel: "standard",
+  requireExamples: false,
+  changelogFormat: "conventional",
+  inlineCommentPolicy: "why-not-what"
+};
+var DEFAULT_DESIGN_STANDARDS = {
+  cssFramework: "tailwind",
+  componentLibrary: "shadcn",
+  accessibilityLevel: "AA",
+  darkModeSupport: true
+};
+var DEFAULT_SECURITY_STANDARDS = {
+  authPattern: "jwt",
+  inputValidation: "zod",
+  csrfProtection: true,
+  rateLimiting: true
+};
+var DEFAULT_PERFORMANCE_STANDARDS = {
+  lcpTarget: 2500,
+  fidTarget: 100,
+  clsTarget: 0.1,
+  bundleSizeTargetKb: 250,
+  apiResponseTargetMs: 300
+};
+var DEFAULT_STANDARDS_CONFIG = {
+  code: DEFAULT_CODE_STANDARDS,
+  testing: DEFAULT_TESTING_STANDARDS,
+  documentation: DEFAULT_DOCUMENTATION_STANDARDS,
+  design: DEFAULT_DESIGN_STANDARDS,
+  security: DEFAULT_SECURITY_STANDARDS,
+  performance: DEFAULT_PERFORMANCE_STANDARDS
+};
+var STANDARDS_PRESETS = {
+  strict: {
+    name: "Strict",
+    description: "High quality standards with strict enforcement (90%+ coverage, TDD required)",
+    config: {
+      code: {
+        ...DEFAULT_CODE_STANDARDS,
+        allowAny: false,
+        jsDocRequired: true
+      },
+      testing: {
+        ...DEFAULT_TESTING_STANDARDS,
+        coverageTarget: 90,
+        tddRequired: true
+      },
+      documentation: {
+        ...DEFAULT_DOCUMENTATION_STANDARDS,
+        jsDocLevel: "comprehensive",
+        requireExamples: true
+      },
+      design: {
+        ...DEFAULT_DESIGN_STANDARDS,
+        accessibilityLevel: "AAA"
+      },
+      security: {
+        ...DEFAULT_SECURITY_STANDARDS,
+        csrfProtection: true,
+        rateLimiting: true
+      },
+      performance: {
+        ...DEFAULT_PERFORMANCE_STANDARDS,
+        lcpTarget: 2e3,
+        apiResponseTargetMs: 200
+      }
+    }
+  },
+  balanced: {
+    name: "Balanced",
+    description: "Good balance between quality and pragmatism (80% coverage)",
+    config: DEFAULT_STANDARDS_CONFIG
+  },
+  relaxed: {
+    name: "Relaxed",
+    description: "More flexible standards for rapid development (70% coverage)",
+    config: {
+      code: {
+        ...DEFAULT_CODE_STANDARDS,
+        maxFileLines: 800,
+        jsDocRequired: false
+      },
+      testing: {
+        ...DEFAULT_TESTING_STANDARDS,
+        coverageTarget: 70,
+        tddRequired: false
+      },
+      documentation: {
+        ...DEFAULT_DOCUMENTATION_STANDARDS,
+        jsDocLevel: "minimal",
+        requireExamples: false
+      },
+      design: {
+        ...DEFAULT_DESIGN_STANDARDS,
+        accessibilityLevel: "A"
+      },
+      security: {
+        ...DEFAULT_SECURITY_STANDARDS
+      },
+      performance: {
+        ...DEFAULT_PERFORMANCE_STANDARDS,
+        lcpTarget: 4e3,
+        apiResponseTargetMs: 500
+      }
+    }
+  },
+  startup: {
+    name: "Startup",
+    description: "Fast iteration with minimum viable standards (60% coverage)",
+    config: {
+      code: {
+        ...DEFAULT_CODE_STANDARDS,
+        maxFileLines: 1e3,
+        jsDocRequired: false,
+        roroPattern: false
+      },
+      testing: {
+        coverageTarget: 60,
+        tddRequired: false,
+        testPattern: "aaa",
+        testLocation: "colocated",
+        unitTestMaxMs: 200,
+        integrationTestMaxMs: 2e3
+      },
+      documentation: {
+        jsDocLevel: "minimal",
+        requireExamples: false,
+        changelogFormat: "conventional",
+        inlineCommentPolicy: "minimal"
+      },
+      design: {
+        cssFramework: "tailwind",
+        componentLibrary: "shadcn",
+        accessibilityLevel: "A",
+        darkModeSupport: false
+      },
+      security: {
+        authPattern: "jwt",
+        inputValidation: "zod",
+        csrfProtection: false,
+        rateLimiting: false
+      },
+      performance: {
+        lcpTarget: 4e3,
+        fidTarget: 300,
+        clsTarget: 0.25,
+        bundleSizeTargetKb: 500,
+        apiResponseTargetMs: 500
+      }
+    }
+  },
+  enterprise: {
+    name: "Enterprise",
+    description: "Enterprise-grade standards with full compliance (95%+ coverage)",
+    config: {
+      code: {
+        indentStyle: "space",
+        indentSize: 2,
+        maxLineLength: 120,
+        maxFileLines: 400,
+        quoteStyle: "single",
+        semicolons: true,
+        trailingCommas: "all",
+        allowAny: false,
+        namedExportsOnly: true,
+        roroPattern: true,
+        jsDocRequired: true
+      },
+      testing: {
+        coverageTarget: 95,
+        tddRequired: true,
+        testPattern: "aaa",
+        testLocation: "separate",
+        unitTestMaxMs: 50,
+        integrationTestMaxMs: 500
+      },
+      documentation: {
+        jsDocLevel: "comprehensive",
+        requireExamples: true,
+        changelogFormat: "keepachangelog",
+        inlineCommentPolicy: "why-not-what"
+      },
+      design: {
+        cssFramework: "tailwind",
+        componentLibrary: "radix",
+        accessibilityLevel: "AAA",
+        darkModeSupport: true
+      },
+      security: {
+        authPattern: "oauth",
+        inputValidation: "zod",
+        csrfProtection: true,
+        rateLimiting: true
+      },
+      performance: {
+        lcpTarget: 1500,
+        fidTarget: 50,
+        clsTarget: 0.05,
+        bundleSizeTargetKb: 150,
+        apiResponseTargetMs: 150
+      }
+    }
+  },
+  custom: {
+    name: "Custom",
+    description: "Configure each standard manually",
+    config: DEFAULT_STANDARDS_CONFIG
+  }
+};
+
+// src/lib/standards/index.ts
+init_esm_shims();
+
+// src/lib/standards/definitions.ts
+init_esm_shims();
+var CODE_STANDARDS_DEFINITION = {
+  id: "code",
+  name: "Code Standards",
+  description: "Code style, formatting, and TypeScript conventions",
+  icon: "\u{1F4DD}",
+  options: [
+    {
+      id: "indentStyle",
+      label: "Indent Style",
+      description: "Use spaces or tabs for indentation",
+      type: "select",
+      choices: [
+        { name: "Spaces", value: "space", description: "Standard for most projects" },
+        { name: "Tabs", value: "tab", description: "Better for accessibility" }
+      ],
+      affectsPlaceholders: ["{{INDENT_STYLE}}"]
+    },
+    {
+      id: "indentSize",
+      label: "Indent Size",
+      description: "Number of spaces/tab width",
+      type: "select",
+      choices: [
+        { name: "2 spaces", value: "2", description: "Most common in JS/TS" },
+        { name: "4 spaces", value: "4", description: "More readable for some" }
+      ],
+      affectsPlaceholders: ["{{INDENT_SIZE}}"]
+    },
+    {
+      id: "maxLineLength",
+      label: "Max Line Length",
+      description: "Maximum characters per line",
+      type: "select",
+      choices: [
+        { name: "80 characters", value: "80", description: "Classic terminal width" },
+        { name: "100 characters", value: "100", description: "Modern balance" },
+        { name: "120 characters", value: "120", description: "Wide screens" }
+      ],
+      affectsPlaceholders: ["{{MAX_LINE_LENGTH}}"]
+    },
+    {
+      id: "maxFileLines",
+      label: "Max File Lines",
+      description: "Maximum lines per file (excluding tests, docs, JSON)",
+      type: "select",
+      choices: [
+        { name: "300 lines", value: "300", description: "Very strict" },
+        { name: "500 lines", value: "500", description: "Recommended" },
+        { name: "800 lines", value: "800", description: "Relaxed" },
+        { name: "1000 lines", value: "1000", description: "Very relaxed" }
+      ],
+      affectsPlaceholders: ["{{MAX_FILE_LINES}}"]
+    },
+    {
+      id: "quoteStyle",
+      label: "Quote Style",
+      description: "Single or double quotes for strings",
+      type: "select",
+      choices: [
+        { name: "Single quotes", value: "single", description: "const x = 'hello'" },
+        { name: "Double quotes", value: "double", description: 'const x = "hello"' }
+      ],
+      affectsPlaceholders: ["{{QUOTE_STYLE}}"]
+    },
+    {
+      id: "semicolons",
+      label: "Semicolons",
+      description: "Use semicolons at end of statements",
+      type: "boolean",
+      affectsPlaceholders: ["{{USE_SEMICOLONS}}"]
+    },
+    {
+      id: "trailingCommas",
+      label: "Trailing Commas",
+      description: "Add trailing commas in multiline constructs",
+      type: "select",
+      choices: [
+        { name: "ES5", value: "es5", description: "Where valid in ES5 (objects, arrays)" },
+        { name: "All", value: "all", description: "Everywhere possible" },
+        { name: "None", value: "none", description: "No trailing commas" }
+      ],
+      affectsPlaceholders: ["{{TRAILING_COMMAS}}"]
+    },
+    {
+      id: "allowAny",
+      label: 'Allow "any" Type',
+      description: 'Allow the "any" type in TypeScript',
+      type: "boolean",
+      affectsPlaceholders: ["{{ALLOW_ANY}}"]
+    },
+    {
+      id: "namedExportsOnly",
+      label: "Named Exports Only",
+      description: "Require named exports (no default exports)",
+      type: "boolean",
+      affectsPlaceholders: ["{{NAMED_EXPORTS_ONLY}}"]
+    },
+    {
+      id: "roroPattern",
+      label: "RO-RO Pattern",
+      description: "Require Receive Object, Return Object pattern",
+      type: "boolean",
+      affectsPlaceholders: ["{{RORO_PATTERN}}"]
+    },
+    {
+      id: "jsDocRequired",
+      label: "JSDoc Required",
+      description: "Require JSDoc for all exports",
+      type: "boolean",
+      affectsPlaceholders: ["{{JSDOC_REQUIRED}}"]
+    }
+  ],
+  targetFiles: ["code-standards.md", "architecture-patterns.md"]
+};
+var TESTING_STANDARDS_DEFINITION = {
+  id: "testing",
+  name: "Testing Standards",
+  description: "Test coverage, TDD, and testing methodology",
+  icon: "\u{1F9EA}",
+  options: [
+    {
+      id: "coverageTarget",
+      label: "Coverage Target",
+      description: "Minimum code coverage percentage",
+      type: "select",
+      choices: [
+        { name: "60%", value: "60", description: "Minimum viable" },
+        { name: "70%", value: "70", description: "Relaxed" },
+        { name: "80%", value: "80", description: "Standard" },
+        { name: "90%", value: "90", description: "Strict" },
+        { name: "95%", value: "95", description: "Enterprise" }
+      ],
+      affectsPlaceholders: ["{{COVERAGE_TARGET}}"]
+    },
+    {
+      id: "tddRequired",
+      label: "TDD Required",
+      description: "Require Test-Driven Development (Red-Green-Refactor)",
+      type: "boolean",
+      affectsPlaceholders: ["{{TDD_REQUIRED}}"]
+    },
+    {
+      id: "testPattern",
+      label: "Test Pattern",
+      description: "Test structure pattern",
+      type: "select",
+      choices: [
+        { name: "AAA", value: "aaa", description: "Arrange-Act-Assert" },
+        { name: "GWT", value: "gwt", description: "Given-When-Then" }
+      ],
+      affectsPlaceholders: ["{{TEST_PATTERN}}"]
+    },
+    {
+      id: "testLocation",
+      label: "Test Location",
+      description: "Where to place test files",
+      type: "select",
+      choices: [
+        { name: "Separate", value: "separate", description: "test/ folder at root" },
+        { name: "Colocated", value: "colocated", description: "__tests__ near source" }
+      ],
+      affectsPlaceholders: ["{{TEST_LOCATION}}"]
+    },
+    {
+      id: "unitTestMaxMs",
+      label: "Unit Test Max (ms)",
+      description: "Maximum milliseconds per unit test",
+      type: "select",
+      choices: [
+        { name: "50ms", value: "50", description: "Very fast" },
+        { name: "100ms", value: "100", description: "Standard" },
+        { name: "200ms", value: "200", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{UNIT_TEST_MAX_MS}}"]
+    },
+    {
+      id: "integrationTestMaxMs",
+      label: "Integration Test Max (ms)",
+      description: "Maximum milliseconds per integration test",
+      type: "select",
+      choices: [
+        { name: "500ms", value: "500", description: "Fast" },
+        { name: "1000ms", value: "1000", description: "Standard" },
+        { name: "2000ms", value: "2000", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{INTEGRATION_TEST_MAX_MS}}"]
+    }
+  ],
+  targetFiles: ["testing-standards.md"]
+};
+var DOCUMENTATION_STANDARDS_DEFINITION = {
+  id: "documentation",
+  name: "Documentation Standards",
+  description: "JSDoc, comments, and changelog conventions",
+  icon: "\u{1F4DA}",
+  options: [
+    {
+      id: "jsDocLevel",
+      label: "JSDoc Level",
+      description: "Level of detail in JSDoc comments",
+      type: "select",
+      choices: [
+        { name: "Minimal", value: "minimal", description: "Brief description only" },
+        { name: "Standard", value: "standard", description: "Description + params + returns" },
+        { name: "Comprehensive", value: "comprehensive", description: "Full docs with examples" }
+      ],
+      affectsPlaceholders: ["{{JSDOC_LEVEL}}"]
+    },
+    {
+      id: "requireExamples",
+      label: "Require Examples",
+      description: "Require @example in JSDoc",
+      type: "boolean",
+      affectsPlaceholders: ["{{REQUIRE_EXAMPLES}}"]
+    },
+    {
+      id: "changelogFormat",
+      label: "Changelog Format",
+      description: "Changelog format to follow",
+      type: "select",
+      choices: [
+        { name: "Conventional", value: "conventional", description: "Auto-generated from commits" },
+        { name: "Keep a Changelog", value: "keepachangelog", description: "Manual, semantic" }
+      ],
+      affectsPlaceholders: ["{{CHANGELOG_FORMAT}}"]
+    },
+    {
+      id: "inlineCommentPolicy",
+      label: "Inline Comment Policy",
+      description: "Policy for inline code comments",
+      type: "select",
+      choices: [
+        {
+          name: "Why not What",
+          value: "why-not-what",
+          description: "Explain reasoning, not obvious"
+        },
+        { name: "Minimal", value: "minimal", description: "Only when necessary" },
+        { name: "Extensive", value: "extensive", description: "Comment thoroughly" }
+      ],
+      affectsPlaceholders: ["{{INLINE_COMMENT_POLICY}}"]
+    }
+  ],
+  targetFiles: ["documentation-standards.md"]
+};
+var DESIGN_STANDARDS_DEFINITION = {
+  id: "design",
+  name: "Design Standards",
+  description: "UI/UX, CSS, and accessibility standards",
+  icon: "\u{1F3A8}",
+  options: [
+    {
+      id: "cssFramework",
+      label: "CSS Framework",
+      description: "CSS/styling approach",
+      type: "select",
+      choices: [
+        { name: "Tailwind CSS", value: "tailwind", description: "Utility-first CSS" },
+        { name: "CSS Modules", value: "css-modules", description: "Scoped CSS" },
+        { name: "Styled Components", value: "styled-components", description: "CSS-in-JS" },
+        { name: "Vanilla CSS", value: "vanilla", description: "Plain CSS" }
+      ],
+      affectsPlaceholders: ["{{CSS_FRAMEWORK}}"]
+    },
+    {
+      id: "componentLibrary",
+      label: "Component Library",
+      description: "UI component library",
+      type: "select",
+      choices: [
+        { name: "shadcn/ui", value: "shadcn", description: "Copy-paste components" },
+        { name: "Radix UI", value: "radix", description: "Unstyled primitives" },
+        { name: "Headless UI", value: "headless", description: "Unstyled, accessible" },
+        { name: "None", value: "none", description: "Build from scratch" }
+      ],
+      affectsPlaceholders: ["{{COMPONENT_LIBRARY}}"]
+    },
+    {
+      id: "accessibilityLevel",
+      label: "Accessibility Level",
+      description: "WCAG accessibility compliance level",
+      type: "select",
+      choices: [
+        { name: "Level A", value: "A", description: "Minimum" },
+        { name: "Level AA", value: "AA", description: "Standard (recommended)" },
+        { name: "Level AAA", value: "AAA", description: "Highest" }
+      ],
+      affectsPlaceholders: ["{{WCAG_LEVEL}}", "{{ACCESSIBILITY_LEVEL}}"]
+    },
+    {
+      id: "darkModeSupport",
+      label: "Dark Mode Support",
+      description: "Support dark mode theme",
+      type: "boolean",
+      affectsPlaceholders: ["{{DARK_MODE_SUPPORT}}"]
+    }
+  ],
+  targetFiles: ["design-standards.md"]
+};
+var SECURITY_STANDARDS_DEFINITION = {
+  id: "security",
+  name: "Security Standards",
+  description: "Authentication, validation, and security practices",
+  icon: "\u{1F512}",
+  options: [
+    {
+      id: "authPattern",
+      label: "Auth Pattern",
+      description: "Authentication approach",
+      type: "select",
+      choices: [
+        { name: "JWT", value: "jwt", description: "JSON Web Tokens" },
+        { name: "Session", value: "session", description: "Server-side sessions" },
+        { name: "OAuth", value: "oauth", description: "OAuth 2.0 / OIDC" },
+        { name: "None", value: "none", description: "No authentication" }
+      ],
+      affectsPlaceholders: ["{{AUTH_PATTERN}}"]
+    },
+    {
+      id: "inputValidation",
+      label: "Input Validation",
+      description: "Validation library",
+      type: "select",
+      choices: [
+        { name: "Zod", value: "zod", description: "TypeScript-first validation" },
+        { name: "Yup", value: "yup", description: "Schema builder" },
+        { name: "Joi", value: "joi", description: "Data validation" },
+        { name: "Manual", value: "manual", description: "Custom validation" }
+      ],
+      affectsPlaceholders: ["{{VALIDATION_LIBRARY}}", "{{INPUT_VALIDATION}}"]
+    },
+    {
+      id: "csrfProtection",
+      label: "CSRF Protection",
+      description: "Enable Cross-Site Request Forgery protection",
+      type: "boolean",
+      affectsPlaceholders: ["{{CSRF_PROTECTION}}"]
+    },
+    {
+      id: "rateLimiting",
+      label: "Rate Limiting",
+      description: "Enable API rate limiting",
+      type: "boolean",
+      affectsPlaceholders: ["{{RATE_LIMITING}}"]
+    }
+  ],
+  targetFiles: ["security-standards.md"]
+};
+var PERFORMANCE_STANDARDS_DEFINITION = {
+  id: "performance",
+  name: "Performance Standards",
+  description: "Core Web Vitals and performance targets",
+  icon: "\u26A1",
+  options: [
+    {
+      id: "lcpTarget",
+      label: "LCP Target (ms)",
+      description: "Largest Contentful Paint target",
+      type: "select",
+      choices: [
+        { name: "1500ms", value: "1500", description: "Excellent" },
+        { name: "2000ms", value: "2000", description: "Good" },
+        { name: "2500ms", value: "2500", description: "Standard" },
+        { name: "4000ms", value: "4000", description: "Needs improvement" }
+      ],
+      affectsPlaceholders: ["{{LCP_TARGET}}"]
+    },
+    {
+      id: "fidTarget",
+      label: "FID Target (ms)",
+      description: "First Input Delay target",
+      type: "select",
+      choices: [
+        { name: "50ms", value: "50", description: "Excellent" },
+        { name: "100ms", value: "100", description: "Good" },
+        { name: "200ms", value: "200", description: "Standard" },
+        { name: "300ms", value: "300", description: "Needs improvement" }
+      ],
+      affectsPlaceholders: ["{{FID_TARGET}}"]
+    },
+    {
+      id: "clsTarget",
+      label: "CLS Target",
+      description: "Cumulative Layout Shift target",
+      type: "select",
+      choices: [
+        { name: "0.05", value: "0.05", description: "Excellent" },
+        { name: "0.1", value: "0.1", description: "Good" },
+        { name: "0.15", value: "0.15", description: "Standard" },
+        { name: "0.25", value: "0.25", description: "Needs improvement" }
+      ],
+      affectsPlaceholders: ["{{CLS_TARGET}}"]
+    },
+    {
+      id: "bundleSizeTargetKb",
+      label: "Bundle Size (KB)",
+      description: "Maximum initial bundle size",
+      type: "select",
+      choices: [
+        { name: "100KB", value: "100", description: "Very strict" },
+        { name: "150KB", value: "150", description: "Strict" },
+        { name: "250KB", value: "250", description: "Standard" },
+        { name: "500KB", value: "500", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{BUNDLE_SIZE_TARGET}}"]
+    },
+    {
+      id: "apiResponseTargetMs",
+      label: "API Response (ms)",
+      description: "Maximum API response time",
+      type: "select",
+      choices: [
+        { name: "100ms", value: "100", description: "Very fast" },
+        { name: "200ms", value: "200", description: "Fast" },
+        { name: "300ms", value: "300", description: "Standard" },
+        { name: "500ms", value: "500", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{API_RESPONSE_TARGET}}"]
+    }
+  ],
+  targetFiles: ["performance-standards.md"]
+};
+var STANDARDS_DEFINITIONS = {
+  code: CODE_STANDARDS_DEFINITION,
+  testing: TESTING_STANDARDS_DEFINITION,
+  documentation: DOCUMENTATION_STANDARDS_DEFINITION,
+  design: DESIGN_STANDARDS_DEFINITION,
+  security: SECURITY_STANDARDS_DEFINITION,
+  performance: PERFORMANCE_STANDARDS_DEFINITION
+};
+
+// src/lib/standards/replacer.ts
+init_esm_shims();
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+import ora3 from "ora";
+var PROCESSABLE_EXTENSIONS2 = [".md", ".json", ".yaml", ".yml", ".txt"];
+var SKIP_DIRECTORIES3 = ["node_modules", ".git", "dist", "build", ".next", ".turbo"];
+function flattenStandardsConfig(config) {
+  const flattened = {};
+  if (config.code) {
+    flattened["{{INDENT_STYLE}}"] = config.code.indentStyle;
+    flattened["{{INDENT_SIZE}}"] = String(config.code.indentSize);
+    flattened["{{MAX_LINE_LENGTH}}"] = String(config.code.maxLineLength);
+    flattened["{{MAX_FILE_LINES}}"] = String(config.code.maxFileLines);
+    flattened["{{QUOTE_STYLE}}"] = config.code.quoteStyle;
+    flattened["{{USE_SEMICOLONS}}"] = config.code.semicolons ? "yes" : "no";
+    flattened["{{TRAILING_COMMAS}}"] = config.code.trailingCommas;
+    flattened["{{ALLOW_ANY}}"] = config.code.allowAny ? "yes" : "no";
+    flattened["{{NAMED_EXPORTS_ONLY}}"] = config.code.namedExportsOnly ? "yes" : "no";
+    flattened["{{RORO_PATTERN}}"] = config.code.roroPattern ? "yes" : "no";
+    flattened["{{JSDOC_REQUIRED}}"] = config.code.jsDocRequired ? "yes" : "no";
+  }
+  if (config.testing) {
+    flattened["{{COVERAGE_TARGET}}"] = String(config.testing.coverageTarget);
+    flattened["{{TDD_REQUIRED}}"] = config.testing.tddRequired ? "yes" : "no";
+    flattened["{{TEST_PATTERN}}"] = config.testing.testPattern.toUpperCase();
+    flattened["{{TEST_LOCATION}}"] = config.testing.testLocation;
+    flattened["{{UNIT_TEST_MAX_MS}}"] = String(config.testing.unitTestMaxMs);
+    flattened["{{INTEGRATION_TEST_MAX_MS}}"] = String(config.testing.integrationTestMaxMs);
+  }
+  if (config.documentation) {
+    flattened["{{JSDOC_LEVEL}}"] = config.documentation.jsDocLevel;
+    flattened["{{REQUIRE_EXAMPLES}}"] = config.documentation.requireExamples ? "yes" : "no";
+    flattened["{{CHANGELOG_FORMAT}}"] = config.documentation.changelogFormat;
+    flattened["{{INLINE_COMMENT_POLICY}}"] = config.documentation.inlineCommentPolicy;
+  }
+  if (config.design) {
+    flattened["{{CSS_FRAMEWORK}}"] = config.design.cssFramework;
+    flattened["{{COMPONENT_LIBRARY}}"] = config.design.componentLibrary;
+    flattened["{{WCAG_LEVEL}}"] = config.design.accessibilityLevel;
+    flattened["{{ACCESSIBILITY_LEVEL}}"] = config.design.accessibilityLevel;
+    flattened["{{DARK_MODE_SUPPORT}}"] = config.design.darkModeSupport ? "yes" : "no";
+  }
+  if (config.security) {
+    flattened["{{AUTH_PATTERN}}"] = config.security.authPattern;
+    flattened["{{VALIDATION_LIBRARY}}"] = config.security.inputValidation;
+    flattened["{{INPUT_VALIDATION}}"] = config.security.inputValidation;
+    flattened["{{CSRF_PROTECTION}}"] = config.security.csrfProtection ? "yes" : "no";
+    flattened["{{RATE_LIMITING}}"] = config.security.rateLimiting ? "yes" : "no";
+  }
+  if (config.performance) {
+    flattened["{{LCP_TARGET}}"] = String(config.performance.lcpTarget);
+    flattened["{{FID_TARGET}}"] = String(config.performance.fidTarget);
+    flattened["{{CLS_TARGET}}"] = String(config.performance.clsTarget);
+    flattened["{{BUNDLE_SIZE_TARGET}}"] = String(config.performance.bundleSizeTargetKb);
+    flattened["{{API_RESPONSE_TARGET}}"] = String(config.performance.apiResponseTargetMs);
+  }
+  return flattened;
+}
+function shouldProcessFile2(filePath) {
+  const ext = path8.extname(filePath).toLowerCase();
+  return PROCESSABLE_EXTENSIONS2.includes(ext);
+}
+function shouldSkipDirectory3(dirName) {
+  return SKIP_DIRECTORIES3.includes(dirName) || dirName.startsWith(".");
+}
+async function getAllFiles3(dir) {
+  const files = [];
+  try {
+    const entries = await fs6.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!shouldSkipDirectory3(entry.name)) {
+          const subFiles = await getAllFiles3(fullPath);
+          files.push(...subFiles);
+        }
+      } else if (entry.isFile() && shouldProcessFile2(entry.name)) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+async function replaceInFile3(filePath, replacements) {
+  const changes = [];
+  try {
+    let content = await fs6.readFile(filePath, "utf-8");
+    let modified = false;
+    for (const [placeholder, value] of Object.entries(replacements)) {
+      if (content.includes(placeholder)) {
+        content = content.split(placeholder).join(value);
+        changes.push({ placeholder, value });
+        modified = true;
+      }
+    }
+    if (modified) {
+      await fs6.writeFile(filePath, content, "utf-8");
+    }
+  } catch {
+  }
+  return changes;
+}
+async function replaceStandardsPlaceholders(claudePath, config) {
+  const replacements = flattenStandardsConfig(config);
+  const standardsDir = path8.join(claudePath, "docs", "standards");
+  const files = await getAllFiles3(standardsDir);
+  const report = {
+    modifiedFiles: [],
+    replacedPlaceholders: [],
+    unusedPlaceholders: [],
+    errors: []
+  };
+  const usedPlaceholders = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    try {
+      const changes = await replaceInFile3(file, replacements);
+      if (changes.length > 0) {
+        report.modifiedFiles.push(path8.relative(claudePath, file));
+        for (const change of changes) {
+          if (!report.replacedPlaceholders.includes(change.placeholder)) {
+            report.replacedPlaceholders.push(change.placeholder);
+          }
+          usedPlaceholders.add(change.placeholder);
+        }
+      }
+    } catch (error) {
+      report.errors.push(`Error processing ${file}: ${String(error)}`);
+    }
+  }
+  for (const placeholder of Object.keys(replacements)) {
+    if (!usedPlaceholders.has(placeholder)) {
+      report.unusedPlaceholders.push(placeholder);
+    }
+  }
+  return report;
+}
+async function replaceStandardsWithSpinner(claudePath, config) {
+  const spinner2 = ora3("Applying standards configuration...").start();
+  try {
+    const report = await replaceStandardsPlaceholders(claudePath, config);
+    if (report.modifiedFiles.length > 0) {
+      spinner2.succeed(
+        `Applied ${report.replacedPlaceholders.length} standards to ${report.modifiedFiles.length} files`
+      );
+    } else {
+      spinner2.info("No standards placeholders found to replace");
+    }
+    return report;
+  } catch (error) {
+    spinner2.fail("Failed to apply standards configuration");
+    throw error;
+  }
+}
+async function previewStandardsReplacements(claudePath, config) {
+  const replacements = flattenStandardsConfig(config);
+  const standardsDir = path8.join(claudePath, "docs", "standards");
+  const files = await getAllFiles3(standardsDir);
+  const preview = [];
+  for (const file of files) {
+    try {
+      const content = await fs6.readFile(file, "utf-8");
+      for (const [placeholder, value] of Object.entries(replacements)) {
+        if (content.includes(placeholder)) {
+          preview.push({
+            file: path8.relative(claudePath, file),
+            placeholder,
+            value
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return preview;
+}
+function formatStandardsReport(report) {
+  const lines = [];
+  lines.push("Standards Configuration Applied");
+  lines.push("\u2500".repeat(40));
+  lines.push(`Files modified: ${report.modifiedFiles.length}`);
+  lines.push(`Placeholders replaced: ${report.replacedPlaceholders.length}`);
+  if (report.modifiedFiles.length > 0) {
+    lines.push("");
+    lines.push("Modified files:");
+    for (const file of report.modifiedFiles) {
+      lines.push(`  \u2713 ${file}`);
+    }
+  }
+  if (report.unusedPlaceholders.length > 0) {
+    lines.push("");
+    lines.push("Unused placeholders (no matching templates):");
+    for (const p of report.unusedPlaceholders.slice(0, 5)) {
+      lines.push(`  - ${p}`);
+    }
+    if (report.unusedPlaceholders.length > 5) {
+      lines.push(`  ... and ${report.unusedPlaceholders.length - 5} more`);
+    }
+  }
+  if (report.errors.length > 0) {
+    lines.push("");
+    lines.push("Errors:");
+    for (const error of report.errors) {
+      lines.push(`  \u2717 ${error}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/lib/standards/scanner.ts
+init_esm_shims();
+import * as fs7 from "fs/promises";
+import * as path9 from "path";
+var SCANNABLE_EXTENSIONS2 = [".md", ".json", ".yaml", ".yml", ".txt"];
+var PLACEHOLDER_PATTERN = /\{\{([A-Z_]+)\}\}/g;
+async function getScanableFiles(dir) {
+  const files = [];
+  try {
+    const entries = await fs7.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path9.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await getScanableFiles(fullPath);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        const ext = path9.extname(entry.name).toLowerCase();
+        if (SCANNABLE_EXTENSIONS2.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function extractPlaceholders2(content) {
+  const matches = content.match(PLACEHOLDER_PATTERN);
+  return matches ? [...new Set(matches)] : [];
+}
+async function scanStandardsPlaceholders(claudePath, config) {
+  const standardsDir = path9.join(claudePath, "docs", "standards");
+  const files = await getScanableFiles(standardsDir);
+  const placeholdersByFile = /* @__PURE__ */ new Map();
+  const allPlaceholders = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    try {
+      const content = await fs7.readFile(file, "utf-8");
+      const placeholders = extractPlaceholders2(content);
+      if (placeholders.length > 0) {
+        const relPath = path9.relative(claudePath, file);
+        placeholdersByFile.set(relPath, placeholders);
+        for (const p of placeholders) {
+          allPlaceholders.add(p);
+        }
+      }
+    } catch {
+    }
+  }
+  const configuredPlaceholders = config ? new Set(Object.keys(flattenStandardsConfig(config))) : /* @__PURE__ */ new Set();
+  const unconfigured = /* @__PURE__ */ new Map();
+  for (const placeholder of allPlaceholders) {
+    if (!configuredPlaceholders.has(placeholder)) {
+      const filesWithPlaceholder = [];
+      for (const [file, placeholders] of placeholdersByFile) {
+        if (placeholders.includes(placeholder)) {
+          filesWithPlaceholder.push(file);
+        }
+      }
+      unconfigured.set(placeholder, filesWithPlaceholder);
+    }
+  }
+  return {
+    unconfiguredPlaceholders: Array.from(unconfigured.entries()).map(([placeholder, files2]) => ({
+      placeholder,
+      files: files2
+    })),
+    totalPlaceholders: allPlaceholders.size,
+    configuredPlaceholders: configuredPlaceholders.size
+  };
+}
+function formatScanResult(result) {
+  const lines = [];
+  lines.push("Standards Placeholder Scan");
+  lines.push("\u2500".repeat(40));
+  lines.push(`Total placeholders found: ${result.totalPlaceholders}`);
+  lines.push(`Already configured: ${result.configuredPlaceholders}`);
+  lines.push(`Unconfigured: ${result.unconfiguredPlaceholders.length}`);
+  if (result.unconfiguredPlaceholders.length > 0) {
+    lines.push("");
+    lines.push("Unconfigured placeholders:");
+    for (const { placeholder, files } of result.unconfiguredPlaceholders) {
+      lines.push(`  ${placeholder}`);
+      for (const file of files.slice(0, 3)) {
+        lines.push(`    \u2514\u2500 ${file}`);
+      }
+      if (files.length > 3) {
+        lines.push(`    \u2514\u2500 ... and ${files.length - 3} more files`);
+      }
+    }
+  } else {
+    lines.push("");
+    lines.push("\u2713 All placeholders are configured!");
+  }
+  return lines.join("\n");
+}
+
+// src/lib/standards/template-sync.ts
+init_esm_shims();
+import * as fs8 from "fs/promises";
+import * as path10 from "path";
+import ora4 from "ora";
+var STANDARDS_TEMPLATES = [
+  "code-standards.md",
+  "testing-standards.md",
+  "documentation-standards.md",
+  "design-standards.md",
+  "security-standards.md",
+  "performance-standards.md"
+];
+async function fileExists2(filePath) {
+  try {
+    await fs8.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBackup(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  await fs8.copyFile(filePath, backupPath);
+  return backupPath;
+}
+async function hasPlaceholders(filePath) {
+  try {
+    const content = await fs8.readFile(filePath, "utf-8");
+    return content.includes("AUTO-GENERATED: Configured values") || /\{\{[A-Z_]+\}\}/.test(content);
+  } catch {
+    return false;
+  }
+}
+async function syncTemplate(templateName, sourcePath, targetPath, options) {
+  const sourceFile = path10.join(sourcePath, templateName);
+  const targetFile = path10.join(targetPath, templateName);
+  if (!await fileExists2(sourceFile)) {
+    return { status: "skipped" };
+  }
+  const targetExists = await fileExists2(targetFile);
+  if (targetExists) {
+    const alreadyHasPlaceholders = await hasPlaceholders(targetFile);
+    if (alreadyHasPlaceholders && !options.overwrite) {
+      return { status: "skipped" };
+    }
+    let backupPath;
+    if (options.backup) {
+      backupPath = await createBackup(targetFile);
+    }
+    await fs8.copyFile(sourceFile, targetFile);
+    return { status: "updated", backup: backupPath };
+  }
+  await fs8.mkdir(path10.dirname(targetFile), { recursive: true });
+  await fs8.copyFile(sourceFile, targetFile);
+  return { status: "created" };
+}
+async function syncStandardsTemplates(claudePath, options = {}) {
+  const result = {
+    created: [],
+    updated: [],
+    skipped: [],
+    errors: []
+  };
+  const packagesTemplatesPath = path10.join(getTemplatesPath(), "docs", "standards");
+  const projectTemplatesPath = path10.join(claudePath, "docs", "standards");
+  await fs8.mkdir(projectTemplatesPath, { recursive: true });
+  for (const template of STANDARDS_TEMPLATES) {
+    try {
+      const syncResult = await syncTemplate(
+        template,
+        packagesTemplatesPath,
+        projectTemplatesPath,
+        options
+      );
+      switch (syncResult.status) {
+        case "created":
+          result.created.push(template);
+          break;
+        case "updated":
+          result.updated.push(template);
+          break;
+        case "skipped":
+          result.skipped.push(template);
+          break;
+      }
+    } catch (error) {
+      result.errors.push(`${template}: ${String(error)}`);
+    }
+  }
+  return result;
+}
+async function syncStandardsTemplatesWithSpinner(claudePath, options = {}) {
+  const spinner2 = ora4("Syncing standards templates...").start();
+  try {
+    const result = await syncStandardsTemplates(claudePath, options);
+    const total = result.created.length + result.updated.length;
+    if (total > 0) {
+      spinner2.succeed(
+        `Synced ${total} template${total !== 1 ? "s" : ""} (${result.created.length} created, ${result.updated.length} updated)`
+      );
+    } else if (result.skipped.length > 0) {
+      spinner2.info("All templates already up to date");
+    } else {
+      spinner2.warn("No templates to sync");
+    }
+    return result;
+  } catch (error) {
+    spinner2.fail("Failed to sync templates");
+    throw error;
+  }
+}
+async function checkTemplatesNeedUpdate(claudePath) {
+  const projectTemplatesPath = path10.join(claudePath, "docs", "standards");
+  const missing = [];
+  const outdated = [];
+  for (const template of STANDARDS_TEMPLATES) {
+    const targetFile = path10.join(projectTemplatesPath, template);
+    if (!await fileExists2(targetFile)) {
+      missing.push(template);
+    } else if (!await hasPlaceholders(targetFile)) {
+      outdated.push(template);
+    }
+  }
+  return {
+    needsUpdate: missing.length > 0 || outdated.length > 0,
+    missing,
+    outdated
+  };
+}
+function formatSyncResult(result) {
+  const lines = [];
+  lines.push("Template Sync Results");
+  lines.push("\u2500".repeat(40));
+  if (result.created.length > 0) {
+    lines.push(`Created: ${result.created.length}`);
+    for (const f of result.created) {
+      lines.push(`  \u2713 ${f}`);
+    }
+  }
+  if (result.updated.length > 0) {
+    lines.push(`Updated: ${result.updated.length}`);
+    for (const f of result.updated) {
+      lines.push(`  \u2713 ${f}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    lines.push(`Skipped (already up to date): ${result.skipped.length}`);
+  }
+  if (result.errors.length > 0) {
+    lines.push(`Errors: ${result.errors.length}`);
+    for (const e of result.errors) {
+      lines.push(`  \u2717 ${e}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/standards.ts
+init_fs();
+
+// src/cli/prompts/standards.ts
+init_esm_shims();
+async function promptStandardsConfig(options) {
+  logger.section("Project Standards", "\u{1F4D0}");
+  logger.info("Configure quality standards for your project");
+  logger.newline();
+  if (options?.category) {
+    const existingConfig = options.defaults ?? DEFAULT_STANDARDS_CONFIG;
+    const categoryConfig = await promptCategoryConfig(options.category, existingConfig);
+    return {
+      ...existingConfig,
+      [options.category]: categoryConfig
+    };
+  }
+  const enableStandards = await confirm({
+    message: "Would you like to configure project standards?",
+    default: true
+  });
+  if (!enableStandards) {
+    return DEFAULT_STANDARDS_CONFIG;
+  }
+  const preset = await promptStandardsPreset();
+  if (preset !== "custom") {
+    const presetConfig = STANDARDS_PRESETS[preset];
+    logger.success(`Using "${presetConfig.name}" preset`);
+    return presetConfig.config;
+  }
+  logger.newline();
+  logger.info("Configure each standards category:");
+  const codeConfig = await promptCodeStandards(options?.defaults?.code);
+  const testingConfig = await promptTestingStandards(options?.defaults?.testing);
+  const documentationConfig = await promptDocumentationStandards(options?.defaults?.documentation);
+  const designConfig = await promptDesignStandards(options?.defaults?.design);
+  const securityConfig = await promptSecurityStandards(options?.defaults?.security);
+  const performanceConfig = await promptPerformanceStandards(options?.defaults?.performance);
+  return {
+    code: codeConfig,
+    testing: testingConfig,
+    documentation: documentationConfig,
+    design: designConfig,
+    security: securityConfig,
+    performance: performanceConfig
+  };
+}
+async function promptStandardsPreset() {
+  return select({
+    message: "Choose a standards preset:",
+    choices: Object.entries(STANDARDS_PRESETS).map(([key, preset]) => ({
+      name: `${preset.name} - ${preset.description}`,
+      value: key
+    })),
+    default: "balanced"
+  });
+}
+async function promptCategoryConfig(category, existingConfig) {
+  switch (category) {
+    case "code":
+      return promptCodeStandards(existingConfig.code);
+    case "testing":
+      return promptTestingStandards(existingConfig.testing);
+    case "documentation":
+      return promptDocumentationStandards(existingConfig.documentation);
+    case "design":
+      return promptDesignStandards(existingConfig.design);
+    case "security":
+      return promptSecurityStandards(existingConfig.security);
+    case "performance":
+      return promptPerformanceStandards(existingConfig.performance);
+  }
+}
+async function promptCodeStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.code;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const indentStyle = await select({
+    message: "Indent style:",
+    choices: [
+      { name: "Spaces", value: "space" },
+      { name: "Tabs", value: "tab" }
+    ],
+    default: defaults?.indentStyle ?? DEFAULT_STANDARDS_CONFIG.code.indentStyle
+  });
+  const indentSize = await select({
+    message: "Indent size:",
+    choices: [
+      { name: "2 spaces", value: 2 },
+      { name: "4 spaces", value: 4 }
+    ],
+    default: defaults?.indentSize ?? DEFAULT_STANDARDS_CONFIG.code.indentSize
+  });
+  const maxLineLength = await select({
+    message: "Max line length:",
+    choices: [
+      { name: "80 characters", value: 80 },
+      { name: "100 characters", value: 100 },
+      { name: "120 characters", value: 120 }
+    ],
+    default: defaults?.maxLineLength ?? DEFAULT_STANDARDS_CONFIG.code.maxLineLength
+  });
+  const maxFileLines = await select({
+    message: "Max file lines:",
+    choices: [
+      { name: "300 lines (strict)", value: 300 },
+      { name: "500 lines (standard)", value: 500 },
+      { name: "800 lines (relaxed)", value: 800 }
+    ],
+    default: defaults?.maxFileLines ?? DEFAULT_STANDARDS_CONFIG.code.maxFileLines
+  });
+  const quoteStyle = await select({
+    message: "Quote style:",
+    choices: [
+      { name: "Single quotes", value: "single" },
+      { name: "Double quotes", value: "double" }
+    ],
+    default: defaults?.quoteStyle ?? DEFAULT_STANDARDS_CONFIG.code.quoteStyle
+  });
+  const semicolons = await confirm({
+    message: "Use semicolons?",
+    default: defaults?.semicolons ?? DEFAULT_STANDARDS_CONFIG.code.semicolons
+  });
+  const trailingCommas = await select({
+    message: "Trailing commas:",
+    choices: [
+      { name: "ES5 (recommended)", value: "es5" },
+      { name: "All", value: "all" },
+      { name: "None", value: "none" }
+    ],
+    default: defaults?.trailingCommas ?? DEFAULT_STANDARDS_CONFIG.code.trailingCommas
+  });
+  const allowAny = await confirm({
+    message: 'Allow "any" type in TypeScript?',
+    default: defaults?.allowAny ?? DEFAULT_STANDARDS_CONFIG.code.allowAny
+  });
+  const namedExportsOnly = await confirm({
+    message: "Require named exports only (no default exports)?",
+    default: defaults?.namedExportsOnly ?? DEFAULT_STANDARDS_CONFIG.code.namedExportsOnly
+  });
+  const roroPattern = await confirm({
+    message: "Require RO-RO pattern (Receive Object, Return Object)?",
+    default: defaults?.roroPattern ?? DEFAULT_STANDARDS_CONFIG.code.roroPattern
+  });
+  const jsDocRequired = await confirm({
+    message: "Require JSDoc for all exports?",
+    default: defaults?.jsDocRequired ?? DEFAULT_STANDARDS_CONFIG.code.jsDocRequired
+  });
+  return {
+    indentStyle,
+    indentSize,
+    maxLineLength,
+    maxFileLines,
+    quoteStyle,
+    semicolons,
+    trailingCommas,
+    allowAny,
+    namedExportsOnly,
+    roroPattern,
+    jsDocRequired
+  };
+}
+async function promptTestingStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.testing;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const coverageTarget = await select({
+    message: "Minimum code coverage:",
+    choices: [
+      { name: "60% (startup)", value: 60 },
+      { name: "70% (relaxed)", value: 70 },
+      { name: "80% (standard)", value: 80 },
+      { name: "90% (strict)", value: 90 },
+      { name: "95% (enterprise)", value: 95 }
+    ],
+    default: defaults?.coverageTarget ?? DEFAULT_STANDARDS_CONFIG.testing.coverageTarget
+  });
+  const tddRequired = await confirm({
+    message: "Require TDD methodology (Red-Green-Refactor)?",
+    default: defaults?.tddRequired ?? DEFAULT_STANDARDS_CONFIG.testing.tddRequired
+  });
+  const testPattern = await select({
+    message: "Test pattern:",
+    choices: [
+      { name: "AAA (Arrange-Act-Assert)", value: "aaa" },
+      { name: "GWT (Given-When-Then)", value: "gwt" }
+    ],
+    default: defaults?.testPattern ?? DEFAULT_STANDARDS_CONFIG.testing.testPattern
+  });
+  const testLocation = await select({
+    message: "Test file location:",
+    choices: [
+      { name: "Separate (test/ folder)", value: "separate" },
+      { name: "Colocated (__tests__ near source)", value: "colocated" }
+    ],
+    default: defaults?.testLocation ?? DEFAULT_STANDARDS_CONFIG.testing.testLocation
+  });
+  const unitTestMaxMs = await select({
+    message: "Max time per unit test:",
+    choices: [
+      { name: "50ms (fast)", value: 50 },
+      { name: "100ms (standard)", value: 100 },
+      { name: "200ms (relaxed)", value: 200 }
+    ],
+    default: defaults?.unitTestMaxMs ?? DEFAULT_STANDARDS_CONFIG.testing.unitTestMaxMs
+  });
+  const integrationTestMaxMs = await select({
+    message: "Max time per integration test:",
+    choices: [
+      { name: "500ms (fast)", value: 500 },
+      { name: "1000ms (standard)", value: 1e3 },
+      { name: "2000ms (relaxed)", value: 2e3 }
+    ],
+    default: defaults?.integrationTestMaxMs ?? DEFAULT_STANDARDS_CONFIG.testing.integrationTestMaxMs
+  });
+  return {
+    coverageTarget,
+    tddRequired,
+    testPattern,
+    testLocation,
+    unitTestMaxMs,
+    integrationTestMaxMs
+  };
+}
+async function promptDocumentationStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.documentation;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const jsDocLevel = await select({
+    message: "JSDoc detail level:",
+    choices: [
+      { name: "Minimal (brief description)", value: "minimal" },
+      { name: "Standard (description + params + returns)", value: "standard" },
+      { name: "Comprehensive (full docs with examples)", value: "comprehensive" }
+    ],
+    default: defaults?.jsDocLevel ?? DEFAULT_STANDARDS_CONFIG.documentation.jsDocLevel
+  });
+  const requireExamples = await confirm({
+    message: "Require @example in JSDoc?",
+    default: defaults?.requireExamples ?? DEFAULT_STANDARDS_CONFIG.documentation.requireExamples
+  });
+  const changelogFormat = await select({
+    message: "Changelog format:",
+    choices: [
+      { name: "Conventional (auto-generated from commits)", value: "conventional" },
+      { name: "Keep a Changelog (manual, semantic)", value: "keepachangelog" }
+    ],
+    default: defaults?.changelogFormat ?? DEFAULT_STANDARDS_CONFIG.documentation.changelogFormat
+  });
+  const inlineCommentPolicy = await select({
+    message: "Inline comment policy:",
+    choices: [
+      { name: "Why not What (explain reasoning)", value: "why-not-what" },
+      { name: "Minimal (only when necessary)", value: "minimal" },
+      { name: "Extensive (comment thoroughly)", value: "extensive" }
+    ],
+    default: defaults?.inlineCommentPolicy ?? DEFAULT_STANDARDS_CONFIG.documentation.inlineCommentPolicy
+  });
+  return {
+    jsDocLevel,
+    requireExamples,
+    changelogFormat,
+    inlineCommentPolicy
+  };
+}
+async function promptDesignStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.design;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const cssFramework = await select({
+    message: "CSS framework:",
+    choices: [
+      { name: "Tailwind CSS", value: "tailwind" },
+      { name: "CSS Modules", value: "css-modules" },
+      { name: "Styled Components", value: "styled-components" },
+      { name: "Vanilla CSS", value: "vanilla" }
+    ],
+    default: defaults?.cssFramework ?? DEFAULT_STANDARDS_CONFIG.design.cssFramework
+  });
+  const componentLibrary = await select({
+    message: "Component library:",
+    choices: [
+      { name: "shadcn/ui", value: "shadcn" },
+      { name: "Radix UI", value: "radix" },
+      { name: "Headless UI", value: "headless" },
+      { name: "None", value: "none" }
+    ],
+    default: defaults?.componentLibrary ?? DEFAULT_STANDARDS_CONFIG.design.componentLibrary
+  });
+  const accessibilityLevel = await select({
+    message: "WCAG accessibility level:",
+    choices: [
+      { name: "Level A (minimum)", value: "A" },
+      { name: "Level AA (recommended)", value: "AA" },
+      { name: "Level AAA (highest)", value: "AAA" }
+    ],
+    default: defaults?.accessibilityLevel ?? DEFAULT_STANDARDS_CONFIG.design.accessibilityLevel
+  });
+  const darkModeSupport = await confirm({
+    message: "Support dark mode?",
+    default: defaults?.darkModeSupport ?? DEFAULT_STANDARDS_CONFIG.design.darkModeSupport
+  });
+  return {
+    cssFramework,
+    componentLibrary,
+    accessibilityLevel,
+    darkModeSupport
+  };
+}
+async function promptSecurityStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.security;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const authPattern = await select({
+    message: "Authentication pattern:",
+    choices: [
+      { name: "JWT (JSON Web Tokens)", value: "jwt" },
+      { name: "Session (server-side)", value: "session" },
+      { name: "OAuth 2.0 / OIDC", value: "oauth" },
+      { name: "None", value: "none" }
+    ],
+    default: defaults?.authPattern ?? DEFAULT_STANDARDS_CONFIG.security.authPattern
+  });
+  const inputValidation = await select({
+    message: "Input validation library:",
+    choices: [
+      { name: "Zod (TypeScript-first)", value: "zod" },
+      { name: "Yup (schema builder)", value: "yup" },
+      { name: "Joi (data validation)", value: "joi" },
+      { name: "Manual (custom)", value: "manual" }
+    ],
+    default: defaults?.inputValidation ?? DEFAULT_STANDARDS_CONFIG.security.inputValidation
+  });
+  const csrfProtection = await confirm({
+    message: "Enable CSRF protection?",
+    default: defaults?.csrfProtection ?? DEFAULT_STANDARDS_CONFIG.security.csrfProtection
+  });
+  const rateLimiting = await confirm({
+    message: "Enable rate limiting?",
+    default: defaults?.rateLimiting ?? DEFAULT_STANDARDS_CONFIG.security.rateLimiting
+  });
+  return {
+    authPattern,
+    inputValidation,
+    csrfProtection,
+    rateLimiting
+  };
+}
+async function promptPerformanceStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.performance;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const lcpTarget = await select({
+    message: "LCP target (Largest Contentful Paint):",
+    choices: [
+      { name: "1500ms (excellent)", value: 1500 },
+      { name: "2000ms (good)", value: 2e3 },
+      { name: "2500ms (standard)", value: 2500 },
+      { name: "4000ms (needs improvement)", value: 4e3 }
+    ],
+    default: defaults?.lcpTarget ?? DEFAULT_STANDARDS_CONFIG.performance.lcpTarget
+  });
+  const fidTarget = await select({
+    message: "FID target (First Input Delay):",
+    choices: [
+      { name: "50ms (excellent)", value: 50 },
+      { name: "100ms (good)", value: 100 },
+      { name: "200ms (standard)", value: 200 },
+      { name: "300ms (needs improvement)", value: 300 }
+    ],
+    default: defaults?.fidTarget ?? DEFAULT_STANDARDS_CONFIG.performance.fidTarget
+  });
+  const clsTarget = await select({
+    message: "CLS target (Cumulative Layout Shift):",
+    choices: [
+      { name: "0.05 (excellent)", value: 0.05 },
+      { name: "0.1 (good)", value: 0.1 },
+      { name: "0.15 (standard)", value: 0.15 },
+      { name: "0.25 (needs improvement)", value: 0.25 }
+    ],
+    default: defaults?.clsTarget ?? DEFAULT_STANDARDS_CONFIG.performance.clsTarget
+  });
+  const bundleSizeTargetKb = await select({
+    message: "Bundle size target (KB):",
+    choices: [
+      { name: "100KB (strict)", value: 100 },
+      { name: "150KB (good)", value: 150 },
+      { name: "250KB (standard)", value: 250 },
+      { name: "500KB (relaxed)", value: 500 }
+    ],
+    default: defaults?.bundleSizeTargetKb ?? DEFAULT_STANDARDS_CONFIG.performance.bundleSizeTargetKb
+  });
+  const apiResponseTargetMs = await select({
+    message: "API response time target (ms):",
+    choices: [
+      { name: "100ms (fast)", value: 100 },
+      { name: "200ms (good)", value: 200 },
+      { name: "300ms (standard)", value: 300 },
+      { name: "500ms (relaxed)", value: 500 }
+    ],
+    default: defaults?.apiResponseTargetMs ?? DEFAULT_STANDARDS_CONFIG.performance.apiResponseTargetMs
+  });
+  return {
+    lcpTarget,
+    fidTarget,
+    clsTarget,
+    bundleSizeTargetKb,
+    apiResponseTargetMs
+  };
+}
+function showStandardsSummary(config) {
+  logger.newline();
+  logger.subtitle("Standards Summary");
+  logger.item(
+    `Code: ${config.code.indentSize} ${config.code.indentStyle}s, ${config.code.quoteStyle} quotes`
+  );
+  logger.info(
+    colors.muted(
+      `  Max: ${config.code.maxLineLength} chars/line, ${config.code.maxFileLines} lines/file`
+    )
+  );
+  logger.info(
+    colors.muted(
+      `  Rules: ${config.code.allowAny ? "any allowed" : "no any"}, ${config.code.namedExportsOnly ? "named exports" : "default exports"}`
+    )
+  );
+  logger.item(
+    `Testing: ${config.testing.coverageTarget}% coverage, ${config.testing.tddRequired ? "TDD required" : "TDD optional"}`
+  );
+  logger.info(
+    colors.muted(
+      `  Pattern: ${config.testing.testPattern.toUpperCase()}, Location: ${config.testing.testLocation}`
+    )
+  );
+  logger.item(`Documentation: ${config.documentation.jsDocLevel} JSDoc`);
+  logger.info(colors.muted(`  Comments: ${config.documentation.inlineCommentPolicy}`));
+  logger.item(`Design: ${config.design.cssFramework}, ${config.design.componentLibrary}`);
+  logger.info(
+    colors.muted(
+      `  A11y: WCAG ${config.design.accessibilityLevel}, ${config.design.darkModeSupport ? "dark mode" : "no dark mode"}`
+    )
+  );
+  logger.item(`Security: ${config.security.authPattern}, ${config.security.inputValidation}`);
+  logger.info(
+    colors.muted(
+      `  ${config.security.csrfProtection ? "CSRF" : "no CSRF"}, ${config.security.rateLimiting ? "rate limiting" : "no rate limiting"}`
+    )
+  );
+  logger.item(
+    `Performance: LCP ${config.performance.lcpTarget}ms, FID ${config.performance.fidTarget}ms`
+  );
+  logger.info(
+    colors.muted(
+      `  Bundle: ${config.performance.bundleSizeTargetKb}KB, API: ${config.performance.apiResponseTargetMs}ms`
+    )
+  );
+}
+async function confirmStandardsConfig(config) {
+  showStandardsSummary(config);
+  logger.newline();
+  return confirm({
+    message: "Apply these standards?",
+    default: true
+  });
+}
+
+// src/cli/commands/standards.ts
+function createStandardsCommand() {
+  const cmd = new Command8("standards").description("Configure project standards interactively").argument("[path]", "Project path (default: current directory)").option("--scan", "Scan for unconfigured standard placeholders").option(
+    "-c, --category <name>",
+    "Configure specific category (code|testing|documentation|design|security|performance)"
+  ).option("--preview", "Preview changes without applying").option("-y, --yes", "Accept defaults without prompts").option("-v, --verbose", "Detailed output").option("--update-templates", "Update/sync templates from package to project").action(runStandards);
+  return cmd;
+}
+async function runStandards(path11, options) {
+  const projectPath = resolvePath(path11 || ".");
+  const claudePath = joinPath(projectPath, ".claude");
+  logger.configure({ verbose: options.verbose, silent: false });
+  logger.title("Project Standards Configuration");
+  try {
+    if (options.scan) {
+      await scanMode2(claudePath, projectPath);
+      return;
+    }
+    if (options.updateTemplates) {
+      await updateTemplatesMode(claudePath, options);
+      return;
+    }
+    if (options.preview) {
+      await previewMode2(claudePath, projectPath);
+      return;
+    }
+    if (options.yes) {
+      await defaultsMode(claudePath, projectPath, options);
+      return;
+    }
+    await interactiveMode2(claudePath, projectPath, options);
+  } catch (error) {
+    logger.error(
+      `Standards configuration failed: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+}
+async function scanMode2(claudePath, projectPath) {
+  logger.info(`Scanning ${colors.primary(claudePath)} for standard placeholders...`);
+  logger.newline();
+  const existingConfig = await readConfig(projectPath);
+  const standardsConfig = existingConfig?.extras?.standards;
+  const scanResult = await scanStandardsPlaceholders(claudePath, standardsConfig);
+  logger.info(formatScanResult(scanResult));
+  if (scanResult.unconfiguredPlaceholders.length > 0) {
+    logger.newline();
+    logger.info("Run `claude-config standards` to configure them");
+  }
+}
+async function updateTemplatesMode(claudePath, options) {
+  logger.info("Checking for template updates...");
+  logger.newline();
+  const status = await checkTemplatesNeedUpdate(claudePath);
+  if (!status.needsUpdate) {
+    logger.success("All templates are up to date!");
+    return;
+  }
+  if (status.missing.length > 0) {
+    logger.info(`Missing templates (${status.missing.length}):`);
+    for (const template of status.missing) {
+      logger.info(`  ${colors.warning("+")} ${template}`);
+    }
+    logger.newline();
+  }
+  if (status.outdated.length > 0) {
+    logger.info(`Outdated templates (${status.outdated.length}):`);
+    for (const template of status.outdated) {
+      logger.info(`  ${colors.primary("~")} ${template}`);
+    }
+    logger.newline();
+  }
+  const result = await syncStandardsTemplatesWithSpinner(claudePath, {
+    overwrite: true,
+    backup: true
+  });
+  if (options.verbose) {
+    logger.newline();
+    logger.info(formatSyncResult(result));
+  }
+  logger.newline();
+  logger.success("Templates updated successfully!");
+  logger.info("Run `claude-config standards` to configure the new placeholders");
+}
+async function previewMode2(claudePath, projectPath) {
+  const existingConfig = await readConfig(projectPath);
+  if (!existingConfig?.extras?.standards) {
+    logger.warn("No standards configuration found");
+    logger.info("Run `claude-config standards` first to set up configuration");
+    return;
+  }
+  logger.info("Preview of replacements:");
+  logger.newline();
+  const replacements = await previewStandardsReplacements(
+    claudePath,
+    existingConfig.extras.standards
+  );
+  if (replacements.length === 0) {
+    logger.info("No standard placeholders to replace");
+    return;
+  }
+  const byFile = {};
+  for (const r of replacements) {
+    if (!byFile[r.file]) {
+      byFile[r.file] = [];
+    }
+    byFile[r.file].push({ placeholder: r.placeholder, value: r.value });
+  }
+  for (const [file, changes] of Object.entries(byFile)) {
+    logger.subtitle(file);
+    for (const change of changes) {
+      logger.info(`  ${change.placeholder} \u2192 ${colors.primary(change.value)}`);
+    }
+    logger.newline();
+  }
+  logger.success(
+    `Total: ${replacements.length} replacements in ${Object.keys(byFile).length} files`
+  );
+}
+async function defaultsMode(claudePath, projectPath, options) {
+  const templateStatus = await checkTemplatesNeedUpdate(claudePath);
+  if (templateStatus.needsUpdate) {
+    logger.warn("Some templates are missing or outdated:");
+    if (templateStatus.missing.length > 0) {
+      logger.info(`  Missing: ${templateStatus.missing.length} template(s)`);
+    }
+    if (templateStatus.outdated.length > 0) {
+      logger.info(`  Outdated: ${templateStatus.outdated.length} template(s)`);
+    }
+    logger.newline();
+    logger.info(
+      `Run ${colors.primary("qazuor-claude-config standards --update-templates")} first to sync templates`
+    );
+    logger.newline();
+  }
+  logger.info("Applying default standards configuration...");
+  logger.newline();
+  const standardsConfig = DEFAULT_STANDARDS_CONFIG;
+  showStandardsSummary(standardsConfig);
+  logger.newline();
+  const report = await replaceStandardsWithSpinner(claudePath, standardsConfig);
+  if (options.verbose) {
+    logger.newline();
+    logger.info(formatStandardsReport(report));
+  }
+  if (report.modifiedFiles.length === 0 && report.unusedPlaceholders.length > 0) {
+    logger.newline();
+    logger.warn("No placeholders were replaced in templates.");
+    logger.info(
+      `Your templates might be outdated. Run ${colors.primary("--update-templates")} to sync them.`
+    );
+  }
+  await saveStandardsConfig(projectPath, standardsConfig);
+  logger.newline();
+  logger.success("Standards configuration complete!");
+}
+async function interactiveMode2(claudePath, projectPath, options) {
+  const templateStatus = await checkTemplatesNeedUpdate(claudePath);
+  if (templateStatus.needsUpdate) {
+    logger.warn("Some templates are missing or outdated:");
+    if (templateStatus.missing.length > 0) {
+      logger.info(`  Missing: ${templateStatus.missing.length} template(s)`);
+    }
+    if (templateStatus.outdated.length > 0) {
+      logger.info(`  Outdated: ${templateStatus.outdated.length} template(s)`);
+    }
+    logger.newline();
+    logger.info(
+      `Run ${colors.primary("qazuor-claude-config standards --update-templates")} first to sync templates`
+    );
+    logger.newline();
+  }
+  const existingConfig = await readConfig(projectPath);
+  const existingStandards = existingConfig?.extras?.standards;
+  const standardsConfig = await promptStandardsConfig({
+    defaults: existingStandards,
+    category: options.category
+  });
+  const confirmed = await confirmStandardsConfig(standardsConfig);
+  if (!confirmed) {
+    logger.warn("Configuration cancelled");
+    return;
+  }
+  const report = await replaceStandardsWithSpinner(claudePath, standardsConfig);
+  if (options.verbose) {
+    logger.newline();
+    logger.info(formatStandardsReport(report));
+  }
+  if (report.modifiedFiles.length === 0 && report.unusedPlaceholders.length > 0) {
+    logger.newline();
+    logger.warn("No placeholders were replaced in templates.");
+    logger.info(
+      `Your templates might be outdated. Run ${colors.primary("--update-templates")} to sync them.`
+    );
+  }
+  await saveStandardsConfig(projectPath, standardsConfig);
+  logger.newline();
+  logger.success("Standards configuration complete!");
+}
+async function saveStandardsConfig(projectPath, standardsConfig) {
+  const existingConfig = await readConfig(projectPath);
+  if (existingConfig) {
+    existingConfig.extras = {
+      ...existingConfig.extras,
+      standards: standardsConfig
+    };
+    existingConfig.customizations.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await writeConfig(projectPath, existingConfig);
+    logger.success("Configuration saved to .claude/qazuor-claude-config.json");
+  } else {
+    logger.warn("No existing config found - standards not saved");
+    logger.info("Run `claude-config init` first to initialize the project");
+  }
+}
+
 // src/cli/index.ts
 var VERSION2 = "0.1.0";
-var program = new Command8().name("qazuor-claude-config").description("CLI tool to install and manage Claude Code configurations").version(VERSION2);
+var program = new Command9().name("qazuor-claude-config").description("CLI tool to install and manage Claude Code configurations").version(VERSION2);
 program.addCommand(createInitCommand());
 program.addCommand(createListCommand());
 program.addCommand(createAddCommand());
@@ -13291,6 +16332,7 @@ program.addCommand(createRemoveCommand());
 program.addCommand(createStatusCommand());
 program.addCommand(createUpdateCommand());
 program.addCommand(createConfigureCommand());
+program.addCommand(createStandardsCommand());
 
 // src/lib/utils/banner.ts
 init_esm_shims();