@qazuor/claude-code-config 0.2.0 → 0.3.0

package/dist/bin.js

@@ -7647,6 +7647,304 @@ function cleanup() {
   stopEscListener();
 }
 
+// src/lib/wizard/index.ts
+init_esm_shims();
+
+// src/lib/wizard/step.ts
+init_esm_shims();
+function createStepState(definition, index) {
+  return {
+    metadata: {
+      ...definition.metadata,
+      index
+    },
+    status: index === 0 ? "current" : "pending",
+    value: void 0,
+    history: [],
+    isModified: false
+  };
+}
+function recordStepHistory(state, value, exitDirection) {
+  const entry = {
+    timestamp: /* @__PURE__ */ new Date(),
+    value,
+    exitDirection,
+    visitCount: state.history.length + 1
+  };
+  return {
+    ...state,
+    value,
+    history: [...state.history, entry],
+    isModified: true
+  };
+}
+function shouldSkipStep(definition, context) {
+  return definition.skipCondition?.(context) ?? false;
+}
+
+// src/lib/wizard/navigator.ts
+init_esm_shims();
+import { Separator } from "@inquirer/prompts";
+var BACK_OPTION_VALUE = "__wizard_back__";
+function calculateNextStep(state, direction) {
+  const currentIndex = state.stepOrder.indexOf(state.currentStepId);
+  const totalSteps = state.stepOrder.length;
+  switch (direction) {
+    case "next": {
+      if (currentIndex >= totalSteps - 1) {
+        return {
+          nextStepId: null,
+          currentStepNewStatus: "completed"
+        };
+      }
+      return {
+        nextStepId: state.stepOrder[currentIndex + 1],
+        currentStepNewStatus: "completed"
+      };
+    }
+    case "back": {
+      if (currentIndex <= 0) {
+        return {
+          nextStepId: state.currentStepId,
+          currentStepNewStatus: "current"
+        };
+      }
+      return {
+        nextStepId: state.stepOrder[currentIndex - 1],
+        currentStepNewStatus: "pending"
+      };
+    }
+    case "skip": {
+      if (currentIndex >= totalSteps - 1) {
+        return {
+          nextStepId: null,
+          currentStepNewStatus: "skipped"
+        };
+      }
+      return {
+        nextStepId: state.stepOrder[currentIndex + 1],
+        currentStepNewStatus: "skipped"
+      };
+    }
+    case "cancel": {
+      return {
+        nextStepId: null,
+        currentStepNewStatus: "pending"
+      };
+    }
+  }
+}
+function applyNavigation(state, direction, currentValue) {
+  const { nextStepId, currentStepNewStatus } = calculateNextStep(state, direction);
+  const currentStepState = state.steps[state.currentStepId];
+  const updatedCurrentStep = {
+    ...currentStepState,
+    status: currentStepNewStatus,
+    value: currentValue
+  };
+  const updatedSteps = {
+    ...state.steps,
+    [state.currentStepId]: updatedCurrentStep
+  };
+  if (nextStepId === null) {
+    return {
+      ...state,
+      steps: updatedSteps,
+      isComplete: direction === "next" || direction === "skip",
+      isCancelled: direction === "cancel"
+    };
+  }
+  const nextStepState = state.steps[nextStepId];
+  const updatedNextStep = {
+    ...nextStepState,
+    status: "current"
+  };
+  return {
+    ...state,
+    steps: {
+      ...updatedSteps,
+      [nextStepId]: updatedNextStep
+    },
+    currentStepId: nextStepId
+  };
+}
+async function promptKeepOrReconfigure(stepName) {
+  logger.newline();
+  const result = await select({
+    message: `"${stepName}" was already configured. What would you like to do?`,
+    choices: [
+      {
+        name: "Keep current values and continue",
+        value: "keep",
+        description: "Skip this step and proceed to the next one"
+      },
+      {
+        name: "Re-configure this step",
+        value: "reconfigure",
+        description: "Show the prompts again with your previous values as defaults"
+      }
+    ],
+    default: "keep"
+  });
+  return result;
+}
+function showStepProgress(state, isRevisit) {
+  if (!state.metadata.showProgress) {
+    return;
+  }
+  const currentIndex = state.stepOrder.indexOf(state.currentStepId);
+  const total = state.metadata.totalSteps;
+  const currentStep = state.steps[state.currentStepId];
+  const progressChars = state.stepOrder.map((_stepId, idx) => {
+    if (idx < currentIndex) {
+      return colors.success("\u25CF");
+    }
+    if (idx === currentIndex) {
+      return colors.primary("\u25C9");
+    }
+    return colors.muted("\u25CB");
+  });
+  const progressBar = progressChars.join(" ");
+  const stepIndicator = `[${currentIndex + 1}/${total}]`;
+  const revisitBadge = isRevisit ? colors.warning(" (revisiting)") : "";
+  logger.newline();
+  logger.info(`${colors.muted(stepIndicator)} ${progressBar}${revisitBadge}`);
+  logger.subtitle(currentStep.metadata.name);
+  if (currentStep.metadata.description) {
+    logger.info(colors.muted(currentStep.metadata.description));
+  }
+}
+
+// src/lib/wizard/history.ts
+init_esm_shims();
+function getLastValue(stepState) {
+  if (stepState.history.length === 0) {
+    return stepState.value;
+  }
+  return stepState.history[stepState.history.length - 1].value;
+}
+function wasStepCompleted(stepState) {
+  return stepState.status === "completed" || stepState.history.length > 0;
+}
+
+// src/lib/wizard/engine.ts
+init_esm_shims();
+function createWizardState(config) {
+  const stepOrder = config.steps.map((s) => s.id);
+  const steps = {};
+  for (let i = 0; i < config.steps.length; i++) {
+    const step = config.steps[i];
+    steps[step.id] = createStepState(step.definition, i);
+  }
+  const metadata = {
+    id: config.id,
+    title: config.title,
+    totalSteps: config.steps.length,
+    startTime: /* @__PURE__ */ new Date(),
+    allowSkip: config.allowSkip ?? true,
+    showProgress: config.showProgress ?? true
+  };
+  return {
+    steps,
+    currentStepId: stepOrder[0],
+    stepOrder,
+    isComplete: false,
+    isCancelled: false,
+    metadata
+  };
+}
+async function runWizard(config, initialContext = {}) {
+  let state = createWizardState(config);
+  const stepMap = /* @__PURE__ */ new Map();
+  for (const step of config.steps) {
+    stepMap.set(step.id, step.definition);
+  }
+  let context = { ...initialContext };
+  let movingForwardAfterBack = false;
+  while (!state.isComplete && !state.isCancelled) {
+    const currentStepId = state.currentStepId;
+    const stepDef = stepMap.get(currentStepId);
+    if (!stepDef) {
+      throw new Error(`Step definition not found for: ${currentStepId}`);
+    }
+    const stepState = state.steps[currentStepId];
+    if (shouldSkipStep(stepDef, context)) {
+      state = applyNavigation(state, "skip", void 0);
+      continue;
+    }
+    const previouslyCompleted = wasStepCompleted(stepState);
+    if (movingForwardAfterBack && previouslyCompleted) {
+      const action = await promptKeepOrReconfigure(stepState.metadata.name);
+      if (action === "keep") {
+        state = applyNavigation(state, "next", stepState.value);
+        continue;
+      }
+    }
+    const isRevisit = stepState.history.length > 0;
+    showStepProgress(state, isRevisit);
+    const previousValue = getLastValue(stepState);
+    const defaults = previousValue ?? stepDef.computeDefaults(context);
+    const result = await stepDef.execute(context, defaults);
+    if (result.navigation !== "back") {
+      context = {
+        ...context,
+        [currentStepId]: result.value
+      };
+      const updatedStepState = recordStepHistory(stepState, result.value, result.navigation);
+      state = {
+        ...state,
+        steps: {
+          ...state.steps,
+          [currentStepId]: updatedStepState
+        }
+      };
+    }
+    if (result.navigation === "back") {
+      movingForwardAfterBack = false;
+    } else if (result.navigation === "next") {
+      movingForwardAfterBack = isRevisit || movingForwardAfterBack;
+    }
+    state = applyNavigation(state, result.navigation, result.value);
+  }
+  const values = {};
+  for (const stepId of state.stepOrder) {
+    const step = state.steps[stepId];
+    if (step.value !== void 0) {
+      values[stepId] = step.value;
+    }
+  }
+  return {
+    values,
+    state,
+    cancelled: state.isCancelled
+  };
+}
+function showWizardSummary(state) {
+  const completed = state.stepOrder.filter((id) => {
+    const step = state.steps[id];
+    return step.status === "completed";
+  }).length;
+  const skipped = state.stepOrder.filter((id) => {
+    const step = state.steps[id];
+    return step.status === "skipped";
+  }).length;
+  const revisited = state.stepOrder.filter((id) => {
+    const step = state.steps[id];
+    return step.history.length > 1;
+  }).length;
+  logger.newline();
+  logger.success(`Wizard completed: ${completed} steps configured`);
+  if (skipped > 0) {
+    logger.info(`  ${skipped} steps skipped`);
+  }
+  if (revisited > 0) {
+    logger.info(`  ${revisited} steps were reconfigured`);
+  }
+}
+
+// src/lib/wizard/init-steps.ts
+init_esm_shims();
+
 // src/cli/prompts/bundle-select.ts
 init_esm_shims();
 
@@ -8086,111 +8384,541 @@ async function promptCICDConfig(options) {
   };
 }
 
-// src/cli/prompts/folder-preferences.ts
-init_esm_shims();
-
-// src/constants/folder-preferences.ts
+// src/cli/prompts/code-style.ts
 init_esm_shims();
-var DEFAULT_FOLDER_PREFERENCES = {
-  tests: {
-    location: "test-folder-root",
-    pattern: "*.test.ts"
-  },
-  planning: {
-    location: "claude-sessions",
-    commitToGit: false
-  },
-  docs: {
-    location: "docs-root"
-  },
-  cicd: {
-    location: "github-workflows",
-    workflows: []
-  }
-};
-var TEST_LOCATION_OPTIONS = [
-  {
-    value: "colocated",
-    name: "Colocated with source files",
-    description: "Tests next to source files (e.g., src/utils/foo.ts \u2192 src/utils/foo.test.ts). Good for small projects."
-  },
+var CODE_STYLE_TOOLS = [
   {
-    value: "test-folder-root",
-    name: "Root test/ folder (Recommended)",
-    description: "Tests in test/ folder mirroring src structure (e.g., test/utils/foo.test.ts). Best for medium-large projects."
+    name: "EditorConfig",
+    value: "editorconfig",
+    description: "Consistent coding styles across editors",
+    checked: true
   },
   {
-    value: "test-folder-src",
-    name: "Inside src/__tests__/",
-    description: "Tests in src/__tests__/ folder (e.g., src/__tests__/utils/foo.test.ts). Common in Create React App."
-  }
-];
-var PLANNING_LOCATION_OPTIONS = [
-  {
-    value: "claude-sessions",
-    name: ".claude/sessions/planning/ (Recommended)",
-    description: "Planning files in .claude/sessions/planning/. Keeps Claude-specific files organized."
+    name: "Commitlint",
+    value: "commitlint",
+    description: "Lint commit messages (conventional commits)",
+    checked: true
   },
   {
-    value: "docs-planning",
-    name: "docs/planning/",
-    description: "Planning files in docs/planning/. Good if you want planning docs alongside other docs."
+    name: "Biome",
+    value: "biome",
+    description: "Fast linter and formatter (ESLint + Prettier alternative)",
+    checked: false
   },
   {
-    value: "root-planning",
-    name: "planning/ at root",
-    description: "Planning files in planning/ at project root. Maximum visibility."
+    name: "Prettier",
+    value: "prettier",
+    description: "Code formatter (use if not using Biome)",
+    checked: false
   }
 ];
-var DOCS_LOCATION_OPTIONS = [
-  {
-    value: "docs-root",
-    name: "docs/ at project root (Recommended)",
-    description: "Documentation in docs/ folder. Standard location for most projects."
-  },
-  {
-    value: "claude-docs",
-    name: ".claude/docs/",
-    description: "Documentation in .claude/docs/. Keeps all Claude-related files together."
-  },
-  {
-    value: "readme-only",
-    name: "README files only",
-    description: "Only README.md files, no separate docs folder. Good for simple projects."
+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
+    };
   }
-];
-var TEST_PATTERN_OPTIONS = [
-  {
-    value: "*.test.ts",
-    name: "*.test.ts (Recommended)",
-    description: "Standard test pattern (foo.test.ts)"
-  },
-  {
-    value: "*.spec.ts",
-    name: "*.spec.ts",
-    description: "Spec pattern common in Angular (foo.spec.ts)"
-  },
-  {
-    value: "*.test.tsx",
-    name: "*.test.tsx",
-    description: "For React component tests (Component.test.tsx)"
+  const selectedTools = await checkbox({
+    message: "Select the tools to configure:",
+    choices: CODE_STYLE_TOOLS.map((tool) => ({
+      name: `${tool.name} - ${tool.description}`,
+      value: tool.value,
+      checked: options?.defaults?.[tool.value] ?? tool.checked
+    }))
+  });
+  if (selectedTools.includes("biome") && selectedTools.includes("prettier")) {
+    logger.warn("Note: Both Biome and Prettier selected. Biome can replace Prettier.");
+    const keepBoth = await confirm({
+      message: "Keep both? (Prettier may conflict with Biome)",
+      default: false
+    });
+    if (!keepBoth) {
+      const preferred = await select({
+        message: "Which formatter would you prefer?",
+        choices: [
+          { name: "Biome (faster, all-in-one)", value: "biome" },
+          { name: "Prettier (more plugins)", value: "prettier" }
+        ]
+      });
+      const indexToRemove = preferred === "biome" ? selectedTools.indexOf("prettier") : selectedTools.indexOf("biome");
+      if (indexToRemove > -1) {
+        selectedTools.splice(indexToRemove, 1);
+      }
+    }
   }
-];
-var GITHUB_WORKFLOW_TEMPLATES = [
-  // CI Workflows
-  {
-    id: "ci-node",
-    name: "Node.js CI",
-    description: "Run tests, lint, and type-check on push and PR",
-    filename: "ci.yml",
-    category: "ci",
-    suitedFor: ["node", "typescript", "javascript"],
-    recommended: true
-  },
-  {
-    id: "ci-node-matrix",
-    name: "Node.js CI (Matrix)",
-    description: "Test across multiple Node.js versions (18, 20, 22)",
+  if (selectedTools.length === 0) {
+    return {
+      enabled: false,
+      editorconfig: false,
+      commitlint: false,
+      biome: false,
+      prettier: false
+    };
+  }
+  const customizeSettings = await confirm({
+    message: "Would you like to customize code style settings? (No = use standard defaults)",
+    default: false
+  });
+  let editorconfigOptions;
+  let biomeOptions;
+  let prettierOptions;
+  let commitlintOptions;
+  if (customizeSettings) {
+    const hasFormatter = selectedTools.includes("editorconfig") || selectedTools.includes("biome") || selectedTools.includes("prettier");
+    if (hasFormatter) {
+      const preset = await promptStylePreset();
+      if (preset !== "custom") {
+        const presetConfig = CODE_STYLE_PRESETS[preset];
+        if (selectedTools.includes("editorconfig")) {
+          editorconfigOptions = presetConfig.editorconfig;
+        }
+        if (selectedTools.includes("biome") && presetConfig.biome) {
+          biomeOptions = {
+            ...DEFAULT_BIOME_OPTIONS,
+            formatter: presetConfig.biome
+          };
+        }
+        if (selectedTools.includes("prettier") && presetConfig.prettier) {
+          prettierOptions = presetConfig.prettier;
+        }
+      } else {
+        if (selectedTools.includes("editorconfig")) {
+          editorconfigOptions = await promptEditorConfigOptions();
+        }
+        if (selectedTools.includes("biome")) {
+          biomeOptions = await promptBiomeOptions();
+        }
+        if (selectedTools.includes("prettier")) {
+          prettierOptions = await promptPrettierOptions();
+        }
+      }
+    }
+    if (selectedTools.includes("commitlint")) {
+      commitlintOptions = await promptCommitlintOptions();
+    }
+  } else {
+    if (selectedTools.includes("editorconfig")) {
+      editorconfigOptions = DEFAULT_EDITORCONFIG_OPTIONS;
+    }
+    if (selectedTools.includes("biome")) {
+      biomeOptions = DEFAULT_BIOME_OPTIONS;
+    }
+    if (selectedTools.includes("prettier")) {
+      prettierOptions = DEFAULT_PRETTIER_OPTIONS;
+    }
+    if (selectedTools.includes("commitlint")) {
+      commitlintOptions = DEFAULT_COMMITLINT_OPTIONS;
+    }
+  }
+  return {
+    enabled: selectedTools.length > 0,
+    editorconfig: selectedTools.includes("editorconfig"),
+    editorconfigOptions,
+    commitlint: selectedTools.includes("commitlint"),
+    commitlintOptions,
+    biome: selectedTools.includes("biome"),
+    biomeOptions,
+    prettier: selectedTools.includes("prettier"),
+    prettierOptions
+  };
+}
+async function promptStylePreset() {
+  logger.newline();
+  logger.info("Choose a code style preset:");
+  return select({
+    message: "Style preset:",
+    choices: Object.entries(CODE_STYLE_PRESETS).map(([key, preset]) => ({
+      name: `${preset.name} - ${preset.description}`,
+      value: key
+    })),
+    default: "standard"
+  });
+}
+async function promptEditorConfigOptions() {
+  logger.newline();
+  logger.subtitle("EditorConfig Options");
+  const indentStyle = await select({
+    message: "Indent style:",
+    choices: [
+      { name: "Spaces", value: "space" },
+      { name: "Tabs", value: "tab" }
+    ],
+    default: DEFAULT_EDITORCONFIG_OPTIONS.indentStyle
+  });
+  const indentSizeStr = await input({
+    message: "Indent size:",
+    default: String(DEFAULT_EDITORCONFIG_OPTIONS.indentSize),
+    validate: (v) => {
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 1 || num > 8) return "Enter a number between 1 and 8";
+      return true;
+    }
+  });
+  const indentSize = Number(indentSizeStr);
+  const endOfLine = await select({
+    message: "Line endings:",
+    choices: [
+      { name: "LF (Unix/Mac)", value: "lf" },
+      { name: "CRLF (Windows)", value: "crlf" },
+      { name: "CR (Old Mac)", value: "cr" }
+    ],
+    default: DEFAULT_EDITORCONFIG_OPTIONS.endOfLine
+  });
+  const maxLineLengthStr = await input({
+    message: 'Max line length (or "off"):',
+    default: String(DEFAULT_EDITORCONFIG_OPTIONS.maxLineLength),
+    validate: (v) => {
+      if (v.toLowerCase() === "off") return true;
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 40 || num > 200)
+        return 'Enter a number between 40 and 200, or "off"';
+      return true;
+    }
+  });
+  const maxLineLength = maxLineLengthStr.toLowerCase() === "off" ? "off" : Number(maxLineLengthStr);
+  return {
+    indentStyle,
+    indentSize,
+    endOfLine,
+    insertFinalNewline: true,
+    trimTrailingWhitespace: true,
+    charset: "utf-8",
+    maxLineLength
+  };
+}
+async function promptBiomeOptions() {
+  logger.newline();
+  logger.subtitle("Biome Options");
+  const indentStyle = await select({
+    message: "Indent style:",
+    choices: [
+      { name: "Spaces", value: "space" },
+      { name: "Tabs", value: "tab" }
+    ],
+    default: DEFAULT_BIOME_OPTIONS.formatter.indentStyle
+  });
+  const indentWidthStr = await input({
+    message: "Indent width:",
+    default: String(DEFAULT_BIOME_OPTIONS.formatter.indentWidth),
+    validate: (v) => {
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 1 || num > 8) return "Enter a number between 1 and 8";
+      return true;
+    }
+  });
+  const indentWidth = Number(indentWidthStr);
+  const lineWidthStr = await input({
+    message: "Line width:",
+    default: String(DEFAULT_BIOME_OPTIONS.formatter.lineWidth),
+    validate: (v) => {
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 40 || num > 200) return "Enter a number between 40 and 200";
+      return true;
+    }
+  });
+  const lineWidth = Number(lineWidthStr);
+  const quoteStyle = await select({
+    message: "Quote style:",
+    choices: [
+      { name: "Single quotes", value: "single" },
+      { name: "Double quotes", value: "double" }
+    ],
+    default: DEFAULT_BIOME_OPTIONS.formatter.quoteStyle
+  });
+  const semicolons = await select({
+    message: "Semicolons:",
+    choices: [
+      { name: "Always", value: "always" },
+      { name: "As needed (ASI)", value: "asNeeded" }
+    ],
+    default: DEFAULT_BIOME_OPTIONS.formatter.semicolons
+  });
+  const trailingCommas = await select({
+    message: "Trailing commas:",
+    choices: [
+      { name: "All", value: "all" },
+      { name: "ES5 (only where valid in ES5)", value: "es5" },
+      { name: "None", value: "none" }
+    ],
+    default: DEFAULT_BIOME_OPTIONS.formatter.trailingCommas
+  });
+  const enableRecommended = await confirm({
+    message: "Enable recommended linter rules?",
+    default: true
+  });
+  return {
+    formatter: {
+      indentStyle,
+      indentWidth,
+      lineWidth,
+      quoteStyle,
+      semicolons,
+      trailingCommas,
+      quoteProperties: "asNeeded",
+      bracketSpacing: true,
+      bracketSameLine: false,
+      arrowParentheses: "always"
+    },
+    linter: {
+      recommended: enableRecommended,
+      correctness: enableRecommended,
+      suspicious: enableRecommended,
+      style: enableRecommended,
+      complexity: enableRecommended,
+      security: enableRecommended,
+      performance: enableRecommended,
+      a11y: enableRecommended
+    },
+    organizeImports: true,
+    ignorePatterns: DEFAULT_BIOME_OPTIONS.ignorePatterns
+  };
+}
+async function promptPrettierOptions() {
+  logger.newline();
+  logger.subtitle("Prettier Options");
+  const printWidthStr = await input({
+    message: "Print width:",
+    default: String(DEFAULT_PRETTIER_OPTIONS.printWidth),
+    validate: (v) => {
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 40 || num > 200) return "Enter a number between 40 and 200";
+      return true;
+    }
+  });
+  const printWidth = Number(printWidthStr);
+  const tabWidthStr = await input({
+    message: "Tab width:",
+    default: String(DEFAULT_PRETTIER_OPTIONS.tabWidth),
+    validate: (v) => {
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 1 || num > 8) return "Enter a number between 1 and 8";
+      return true;
+    }
+  });
+  const tabWidth = Number(tabWidthStr);
+  const useTabs = await confirm({
+    message: "Use tabs instead of spaces?",
+    default: DEFAULT_PRETTIER_OPTIONS.useTabs
+  });
+  const semi = await confirm({
+    message: "Use semicolons?",
+    default: DEFAULT_PRETTIER_OPTIONS.semi
+  });
+  const singleQuote = await confirm({
+    message: "Use single quotes?",
+    default: DEFAULT_PRETTIER_OPTIONS.singleQuote
+  });
+  const trailingComma = await select({
+    message: "Trailing commas:",
+    choices: [
+      { name: "All", value: "all" },
+      { name: "ES5", value: "es5" },
+      { name: "None", value: "none" }
+    ],
+    default: DEFAULT_PRETTIER_OPTIONS.trailingComma
+  });
+  const bracketSpacing = await confirm({
+    message: "Bracket spacing? ({ foo: bar })",
+    default: DEFAULT_PRETTIER_OPTIONS.bracketSpacing
+  });
+  const arrowParens = await select({
+    message: "Arrow function parentheses:",
+    choices: [
+      { name: "Always (x) => x", value: "always" },
+      { name: "Avoid x => x", value: "avoid" }
+    ],
+    default: DEFAULT_PRETTIER_OPTIONS.arrowParens
+  });
+  return {
+    printWidth,
+    tabWidth,
+    useTabs,
+    semi,
+    singleQuote,
+    jsxSingleQuote: false,
+    trailingComma,
+    bracketSpacing,
+    bracketSameLine: false,
+    arrowParens,
+    endOfLine: "lf",
+    proseWrap: "preserve",
+    htmlWhitespaceSensitivity: "css",
+    singleAttributePerLine: false
+  };
+}
+async function promptCommitlintOptions() {
+  logger.newline();
+  logger.subtitle("Commitlint Options");
+  const useDefaults = await confirm({
+    message: "Use conventional commits defaults?",
+    default: true
+  });
+  if (useDefaults) {
+    const huskyIntegration2 = await confirm({
+      message: "Enable Husky integration (git hooks)?",
+      default: true
+    });
+    return {
+      ...DEFAULT_COMMITLINT_OPTIONS,
+      huskyIntegration: huskyIntegration2
+    };
+  }
+  const typesInput = await input({
+    message: "Commit types (comma-separated):",
+    default: DEFAULT_COMMITLINT_OPTIONS.types.join(", ")
+  });
+  const types = typesInput.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  const scopesInput = await input({
+    message: "Allowed scopes (comma-separated, empty for any):",
+    default: ""
+  });
+  const scopes = scopesInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  const headerMaxLengthStr = await input({
+    message: "Maximum header length:",
+    default: String(DEFAULT_COMMITLINT_OPTIONS.headerMaxLength),
+    validate: (v) => {
+      const num = Number(v);
+      if (Number.isNaN(num) || num < 20 || num > 200) return "Enter a number between 20 and 200";
+      return true;
+    }
+  });
+  const headerMaxLength = Number(headerMaxLengthStr);
+  const scopeRequired = await confirm({
+    message: "Require scope in commit messages?",
+    default: false
+  });
+  const huskyIntegration = await confirm({
+    message: "Enable Husky integration (git hooks)?",
+    default: true
+  });
+  return {
+    extends: ["@commitlint/config-conventional"],
+    types,
+    scopes,
+    headerMaxLength,
+    scopeRequired,
+    bodyRequired: false,
+    bodyMaxLineLength: 100,
+    huskyIntegration
+  };
+}
+
+// src/cli/prompts/folder-preferences.ts
+init_esm_shims();
+
+// src/constants/folder-preferences.ts
+init_esm_shims();
+var DEFAULT_FOLDER_PREFERENCES = {
+  tests: {
+    location: "test-folder-root",
+    pattern: "*.test.ts"
+  },
+  planning: {
+    location: "claude-sessions",
+    commitToGit: false
+  },
+  docs: {
+    location: "docs-root"
+  },
+  cicd: {
+    location: "github-workflows",
+    workflows: []
+  }
+};
+var TEST_LOCATION_OPTIONS = [
+  {
+    value: "colocated",
+    name: "Colocated with source files",
+    description: "Tests next to source files (e.g., src/utils/foo.ts \u2192 src/utils/foo.test.ts). Good for small projects."
+  },
+  {
+    value: "test-folder-root",
+    name: "Root test/ folder (Recommended)",
+    description: "Tests in test/ folder mirroring src structure (e.g., test/utils/foo.test.ts). Best for medium-large projects."
+  },
+  {
+    value: "test-folder-src",
+    name: "Inside src/__tests__/",
+    description: "Tests in src/__tests__/ folder (e.g., src/__tests__/utils/foo.test.ts). Common in Create React App."
+  }
+];
+var PLANNING_LOCATION_OPTIONS = [
+  {
+    value: "claude-sessions",
+    name: ".claude/sessions/planning/ (Recommended)",
+    description: "Planning files in .claude/sessions/planning/. Keeps Claude-specific files organized."
+  },
+  {
+    value: "docs-planning",
+    name: "docs/planning/",
+    description: "Planning files in docs/planning/. Good if you want planning docs alongside other docs."
+  },
+  {
+    value: "root-planning",
+    name: "planning/ at root",
+    description: "Planning files in planning/ at project root. Maximum visibility."
+  }
+];
+var DOCS_LOCATION_OPTIONS = [
+  {
+    value: "docs-root",
+    name: "docs/ at project root (Recommended)",
+    description: "Documentation in docs/ folder. Standard location for most projects."
+  },
+  {
+    value: "claude-docs",
+    name: ".claude/docs/",
+    description: "Documentation in .claude/docs/. Keeps all Claude-related files together."
+  },
+  {
+    value: "readme-only",
+    name: "README files only",
+    description: "Only README.md files, no separate docs folder. Good for simple projects."
+  }
+];
+var TEST_PATTERN_OPTIONS = [
+  {
+    value: "*.test.ts",
+    name: "*.test.ts (Recommended)",
+    description: "Standard test pattern (foo.test.ts)"
+  },
+  {
+    value: "*.spec.ts",
+    name: "*.spec.ts",
+    description: "Spec pattern common in Angular (foo.spec.ts)"
+  },
+  {
+    value: "*.test.tsx",
+    name: "*.test.tsx",
+    description: "For React component tests (Component.test.tsx)"
+  }
+];
+var GITHUB_WORKFLOW_TEMPLATES = [
+  // CI Workflows
+  {
+    id: "ci-node",
+    name: "Node.js CI",
+    description: "Run tests, lint, and type-check on push and PR",
+    filename: "ci.yml",
+    category: "ci",
+    suitedFor: ["node", "typescript", "javascript"],
+    recommended: true
+  },
+  {
+    id: "ci-node-matrix",
+    name: "Node.js CI (Matrix)",
+    description: "Test across multiple Node.js versions (18, 20, 22)",
     filename: "ci-matrix.yml",
     category: "ci",
     suitedFor: ["node", "typescript", "library"]
@@ -8591,429 +9319,204 @@ async function promptFolderPreferences(options) {
   }
   const setupCiCd = hasCiCdBundle || await confirm({
     message: "Would you like to set up GitHub Actions workflows?",
-    default: true
-  });
-  if (setupCiCd) {
-    const workflows = await promptGithubWorkflows({
-      recommended: mergedDefaults.cicd?.workflows,
-      technologies
-    });
-    if (workflows.length > 0) {
-      preferences.cicd = {
-        location: "github-workflows",
-        workflows
-      };
-    }
-  }
-  return preferences;
-}
-function showFolderPreferencesSummary(preferences) {
-  logger.newline();
-  logger.subtitle("Folder Structure Summary");
-  if (preferences.tests) {
-    const testOpt = TEST_LOCATION_OPTIONS.find((o) => o.value === preferences.tests?.location);
-    logger.keyValue("Tests", testOpt?.name || preferences.tests.location);
-    logger.keyValue("Test Pattern", preferences.tests.pattern);
-  }
-  if (preferences.planning) {
-    const planOpt = PLANNING_LOCATION_OPTIONS.find(
-      (o) => o.value === preferences.planning?.location
-    );
-    logger.keyValue("Planning", planOpt?.name || preferences.planning.location);
-    logger.keyValue(
-      "Commit Planning",
-      preferences.planning.commitToGit ? "Yes" : "No (will be in .gitignore)"
-    );
-  }
-  if (preferences.docs) {
-    const docsOpt = DOCS_LOCATION_OPTIONS.find((o) => o.value === preferences.docs?.location);
-    logger.keyValue("Documentation", docsOpt?.name || preferences.docs.location);
-  }
-  if (preferences.cicd && preferences.cicd.workflows.length > 0) {
-    logger.keyValue("CI/CD Location", ".github/workflows/");
-    logger.info(`  ${colors.muted("Workflows:")} ${preferences.cicd.workflows.join(", ")}`);
-  }
-}
-async function promptQuickFolderPreferences(options) {
-  const recommendations = getFolderRecommendationsForBundles(options.selectedBundles);
-  const mergedDefaults = mergeFolderPreferences(recommendations);
-  if (recommendations.length > 0) {
-    logger.section("Folder Structure", "\u{1F4C1}");
-    logger.info(colors.muted("Based on your bundles, we have recommended folder settings."));
-    showFolderPreferencesSummary(mergedDefaults);
-    const customize = await confirm({
-      message: "Would you like to customize these folder preferences?",
-      default: false
-    });
-    if (!customize) {
-      return mergedDefaults;
-    }
-  }
-  return promptFolderPreferences(options);
-}
-
-// src/cli/prompts/index.ts
-init_esm_shims();
-
-// src/cli/prompts/project-info.ts
-init_esm_shims();
-async function promptProjectInfo(options) {
-  logger.section("Project Information", "\u{1F4CB}");
-  const name = await input({
-    message: "Project name:",
-    default: options?.defaults?.name,
-    validate: (value) => {
-      if (!value.trim()) return "Project name is required";
-      if (!/^[a-zA-Z0-9-_\s]+$/.test(value)) {
-        return "Project name can only contain letters, numbers, dashes, underscores, and spaces";
-      }
-      return true;
-    }
-  });
-  const description = await input({
-    message: "Project description:",
-    default: options?.defaults?.description || "",
-    validate: (value) => {
-      if (!value.trim()) return "Description is required";
-      return true;
-    }
-  });
-  const org = await input({
-    message: "GitHub organization/username:",
-    default: options?.defaults?.org || "",
-    validate: (value) => {
-      if (!value.trim()) return "Organization is required";
-      if (!/^[a-zA-Z0-9-]+$/.test(value)) {
-        return "Organization can only contain letters, numbers, and dashes";
-      }
-      return true;
-    }
-  });
-  const repo = await input({
-    message: "Repository name:",
-    default: options?.defaults?.repo || name.toLowerCase().replace(/\s+/g, "-"),
-    validate: (value) => {
-      if (!value.trim()) return "Repository name is required";
-      if (!/^[a-zA-Z0-9-_]+$/.test(value)) {
-        return "Repository name can only contain letters, numbers, dashes, and underscores";
-      }
-      return true;
-    }
-  });
-  const author = await input({
-    message: 'Author (name or "Name <email>"):',
-    default: options?.defaults?.author || ""
-  });
-  let entityType = "item";
-  let entityTypePlural = "items";
-  const wantEntityConfig = await confirm({
-    message: "Configure primary entity type? (Used for code examples and templates)",
-    default: false
-  });
-  if (wantEntityConfig) {
-    logger.info("The entity type is used in code examples and templates throughout the project.");
-    logger.info(
-      'For example, if your project manages "products", code examples will use product-related names.'
-    );
-    logger.newline();
-    entityType = await input({
-      message: "Primary entity type (e.g., product, article, user, listing):",
-      default: options?.defaults?.entityType || "item",
-      validate: (value) => {
-        if (!value.trim()) return "Entity type is required";
-        return true;
-      }
-    });
-    entityTypePlural = await input({
-      message: "Entity type plural:",
-      default: options?.defaults?.entityTypePlural || pluralize(entityType)
-    });
-  } else if (options?.defaults?.entityType) {
-    entityType = options.defaults.entityType;
-    entityTypePlural = options.defaults.entityTypePlural || pluralize(entityType);
-  }
-  let domain;
-  let location;
-  if (!options?.skipOptional) {
-    const wantDomain = await confirm({
-      message: "Do you want to specify a domain?",
-      default: false
-    });
-    if (wantDomain) {
-      domain = await input({
-        message: "Domain (e.g., myproject.com):",
-        default: options?.defaults?.domain || "",
-        validate: (value) => {
-          if (value && !/^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(value)) {
-            return "Please enter a valid domain";
-          }
-          return true;
-        }
-      });
-    }
-    const wantLocation = await confirm({
-      message: "Do you want to specify a location/region?",
-      default: false
+    default: true
+  });
+  if (setupCiCd) {
+    const workflows = await promptGithubWorkflows({
+      recommended: mergedDefaults.cicd?.workflows,
+      technologies
     });
-    if (wantLocation) {
-      location = await input({
-        message: "Location/Region:",
-        default: options?.defaults?.location || ""
-      });
+    if (workflows.length > 0) {
+      preferences.cicd = {
+        location: "github-workflows",
+        workflows
+      };
     }
   }
-  return {
-    name: name.trim(),
-    description: description.trim(),
-    org: org.trim(),
-    repo: repo.trim(),
-    domain,
-    entityType: entityType.trim().toLowerCase(),
-    entityTypePlural: entityTypePlural.trim().toLowerCase(),
-    location,
-    author: author.trim() || void 0
-  };
+  return preferences;
 }
-function pluralize(word) {
-  const lower = word.toLowerCase();
-  if (lower.endsWith("y")) {
-    return `${lower.slice(0, -1)}ies`;
+function showFolderPreferencesSummary(preferences) {
+  logger.newline();
+  logger.subtitle("Folder Structure Summary");
+  if (preferences.tests) {
+    const testOpt = TEST_LOCATION_OPTIONS.find((o) => o.value === preferences.tests?.location);
+    logger.keyValue("Tests", testOpt?.name || preferences.tests.location);
+    logger.keyValue("Test Pattern", preferences.tests.pattern);
   }
-  if (lower.endsWith("s") || lower.endsWith("x") || lower.endsWith("ch") || lower.endsWith("sh")) {
-    return `${lower}es`;
+  if (preferences.planning) {
+    const planOpt = PLANNING_LOCATION_OPTIONS.find(
+      (o) => o.value === preferences.planning?.location
+    );
+    logger.keyValue("Planning", planOpt?.name || preferences.planning.location);
+    logger.keyValue(
+      "Commit Planning",
+      preferences.planning.commitToGit ? "Yes" : "No (will be in .gitignore)"
+    );
+  }
+  if (preferences.docs) {
+    const docsOpt = DOCS_LOCATION_OPTIONS.find((o) => o.value === preferences.docs?.location);
+    logger.keyValue("Documentation", docsOpt?.name || preferences.docs.location);
+  }
+  if (preferences.cicd && preferences.cicd.workflows.length > 0) {
+    logger.keyValue("CI/CD Location", ".github/workflows/");
+    logger.info(`  ${colors.muted("Workflows:")} ${preferences.cicd.workflows.join(", ")}`);
   }
-  return `${lower}s`;
 }
-async function confirmProjectInfo(info) {
-  logger.newline();
-  logger.subtitle("Project Summary");
-  logger.keyValue("Name", info.name);
-  logger.keyValue("Description", info.description);
-  logger.keyValue("GitHub", `${info.org}/${info.repo}`);
-  if (info.author) logger.keyValue("Author", info.author);
-  logger.keyValue("Entity", `${info.entityType} / ${info.entityTypePlural}`);
-  if (info.domain) logger.keyValue("Domain", info.domain);
-  if (info.location) logger.keyValue("Location", info.location);
-  logger.newline();
-  return confirm({
-    message: "Is this information correct?",
-    default: true
-  });
+async function promptQuickFolderPreferences(options) {
+  const recommendations = getFolderRecommendationsForBundles(options.selectedBundles);
+  const mergedDefaults = mergeFolderPreferences(recommendations);
+  if (recommendations.length > 0) {
+    logger.section("Folder Structure", "\u{1F4C1}");
+    logger.info(colors.muted("Based on your bundles, we have recommended folder settings."));
+    showFolderPreferencesSummary(mergedDefaults);
+    const customize = await confirm({
+      message: "Would you like to customize these folder preferences?",
+      default: false
+    });
+    if (!customize) {
+      return mergedDefaults;
+    }
+  }
+  return promptFolderPreferences(options);
 }
 
-// src/cli/prompts/preferences.ts
+// src/cli/prompts/hook-config.ts
 init_esm_shims();
-async function promptPreferences(options) {
-  logger.section("Preferences", "\u2699\uFE0F");
-  const language = await select({
-    message: "Working language (for documentation and comments):",
-    choices: [
-      { name: "English", value: "en" },
-      { name: "Espa\xF1ol", value: "es" }
-    ],
-    default: options?.defaults?.language || "en"
+async function promptHookConfig(options) {
+  logger.section("Hook Configuration", "\u{1FA9D}");
+  const enableHooks = await confirm({
+    message: "Do you want to configure hooks?",
+    default: true
   });
-  const responseLanguage = await select({
-    message: "Claude response language:",
+  if (!enableHooks) {
+    return {
+      enabled: false
+    };
+  }
+  const selectedHooks = await checkbox({
+    message: "Which hooks do you want to configure?",
     choices: [
-      { name: "English", value: "en" },
-      { name: "Espa\xF1ol", value: "es" }
-    ],
-    default: options?.defaults?.responseLanguage || language
-  });
-  const includeCoAuthor = await confirm({
-    message: "Include Claude as commit co-author?",
-    default: options?.defaults?.includeCoAuthor ?? true
+      {
+        name: "Notification hook (alerts when Claude needs attention)",
+        value: "notification",
+        checked: true
+      },
+      {
+        name: "Stop hook (plays sound when Claude stops)",
+        value: "stop",
+        checked: false
+      },
+      {
+        name: "Subagent stop hook (plays sound when subagent completes)",
+        value: "subagentStop",
+        checked: false
+      }
+    ]
   });
-  const packageManager = await promptPackageManagerPreference(options?.detectedPackageManager);
-  return {
-    language,
-    responseLanguage,
-    includeCoAuthor,
-    packageManager
+  const config = {
+    enabled: true
   };
-}
-async function promptPackageManagerPreference(detected) {
-  const choices = [
-    {
-      name: "pnpm (recommended)",
-      value: "pnpm",
-      description: "Fast, disk space efficient package manager"
-    },
-    {
-      name: "npm",
-      value: "npm",
-      description: "Node.js default package manager"
-    },
-    {
-      name: "yarn",
-      value: "yarn",
-      description: "Fast, reliable dependency management"
-    },
-    {
-      name: "bun",
-      value: "bun",
-      description: "All-in-one JavaScript runtime & toolkit"
-    }
-  ];
-  if (detected) {
-    const detectedChoice = choices.find((c) => c.value === detected);
-    if (detectedChoice) {
-      detectedChoice.name = `${detectedChoice.name} (detected)`;
-    }
+  if (selectedHooks.includes("notification")) {
+    config.notification = await promptNotificationHook(options?.defaults?.notification);
   }
-  return select({
-    message: "Preferred package manager:",
-    choices,
-    default: detected || "pnpm"
-  });
+  if (selectedHooks.includes("stop")) {
+    config.stop = await promptStopHook();
+  }
+  if (selectedHooks.includes("subagentStop")) {
+    config.subagentStop = await promptSubagentStopHook();
+  }
+  return config;
 }
-
-// src/cli/prompts/scaffold.ts
-init_esm_shims();
-async function promptScaffoldType(options) {
-  logger.section("Configuration Scope", "\u{1F3D7}\uFE0F");
-  if (options?.existingProject) {
-    logger.info("Existing project detected");
-    logger.newline();
-    const choice = await select({
-      message: "What would you like to do?",
-      choices: [
-        {
-          name: "Add Claude config only (recommended)",
-          value: "claude-only",
-          description: "Creates .claude/ folder without touching existing files"
-        },
-        {
-          name: "Full project setup (\u26A0\uFE0F may overwrite files)",
-          value: "full-project",
-          description: "Includes project scaffolding - use with caution"
-        }
-      ],
-      default: "claude-only"
-    });
-    if (choice === "full-project") {
-      const confirmed = await confirm({
-        message: "\u26A0\uFE0F  This may overwrite existing files. Are you sure?",
-        default: false
-      });
-      if (!confirmed) {
-        return "claude-only";
+async function promptNotificationHook(defaults) {
+  logger.newline();
+  logger.info("Notification Hook Configuration");
+  const notificationTypes = await checkbox({
+    message: "Select notification types:",
+    choices: [
+      {
+        name: "Desktop notifications (notify-send / terminal-notifier)",
+        value: "desktop",
+        checked: defaults?.desktop ?? true
+      },
+      {
+        name: "Audio notifications (text-to-speech)",
+        value: "audio",
+        checked: defaults?.audio ?? false
       }
-    }
-    return choice;
+    ]
+  });
+  let customCommand;
+  const wantCustom = await confirm({
+    message: "Do you want to add a custom notification command?",
+    default: false
+  });
+  if (wantCustom) {
+    customCommand = await input({
+      message: "Custom command (receives notification text as argument):",
+      default: defaults?.customCommand
+    });
   }
-  return select({
-    message: "What would you like to configure?",
+  return {
+    desktop: notificationTypes.includes("desktop"),
+    audio: notificationTypes.includes("audio"),
+    customCommand: customCommand || void 0
+  };
+}
+async function promptStopHook() {
+  logger.newline();
+  logger.info("Stop Hook Configuration");
+  const soundType = await select({
+    message: "What should happen when Claude stops?",
     choices: [
-      {
-        name: "Claude configuration only",
-        value: "claude-only",
-        description: "Only creates .claude/ folder with agents, commands, skills, docs"
-      },
-      {
-        name: "Full project setup",
-        value: "full-project",
-        description: "Creates project structure + Claude configuration"
-      }
+      { name: "Play beep sound", value: "beep" },
+      { name: "Play custom sound", value: "custom" },
+      { name: "Run custom command", value: "command" }
     ],
-    default: "claude-only"
+    default: "beep"
   });
-}
-async function promptProjectType(detectedType) {
-  const choices = [
-    {
-      name: "Node.js (TypeScript)",
-      value: "node",
-      description: "Basic Node.js project with TypeScript"
-    },
-    {
-      name: "Monorepo (TurboRepo + pnpm)",
-      value: "monorepo",
-      description: "Multi-package monorepo setup"
-    },
-    {
-      name: "Astro",
-      value: "astro",
-      description: "Astro static/SSR site"
-    },
-    {
-      name: "Next.js",
-      value: "nextjs",
-      description: "Next.js full-stack React framework"
-    },
-    {
-      name: "Vite + React",
-      value: "vite-react",
-      description: "Vite bundled React SPA"
-    },
-    {
-      name: "Hono API",
-      value: "hono",
-      description: "Hono lightweight API server"
-    },
-    {
-      name: "Custom",
-      value: "custom",
-      description: "Define your own project structure"
-    }
-  ];
-  if (detectedType) {
-    const detected = choices.find((c) => c.value === detectedType);
-    if (detected) {
-      detected.name = `${detected.name} (detected)`;
-    }
+  if (soundType === "beep") {
+    return { beep: true };
   }
-  return select({
-    message: "Project type:",
-    choices,
-    default: detectedType || "node"
-  });
-}
-async function promptPackageManager(detected) {
-  const choices = [
-    { name: "pnpm (recommended)", value: "pnpm" },
-    { name: "npm", value: "npm" },
-    { name: "yarn", value: "yarn" },
-    { name: "bun", value: "bun" }
-  ];
-  if (detected) {
-    const detectedChoice = choices.find((c) => c.value === detected);
-    if (detectedChoice) {
-      detectedChoice.name = `${detectedChoice.name} (detected)`;
-    }
+  if (soundType === "custom") {
+    const soundPath = await input({
+      message: "Path to sound file:",
+      validate: (v) => v.trim() ? true : "Please enter a valid path"
+    });
+    return { customSound: soundPath };
   }
-  return select({
-    message: "Package manager:",
-    choices,
-    default: detected || "pnpm"
+  const customCommand = await input({
+    message: "Custom command to run:",
+    validate: (v) => v.trim() ? true : "Please enter a command"
   });
+  return { customCommand };
 }
-async function promptScaffoldOptions(options) {
-  const type = await promptScaffoldType(options);
-  if (type === "claude-only") {
-    return { type };
-  }
-  const projectType = await promptProjectType(options?.detectedType);
-  const packageManager = await promptPackageManager(options?.detectedPackageManager);
+async function promptSubagentStopHook() {
   logger.newline();
-  logger.subtitle("Additional Options");
-  const additionalOptions = await checkbox({
-    message: "Select additional options:",
+  logger.info("Subagent Stop Hook Configuration");
+  const soundType = await select({
+    message: "What should happen when a subagent completes?",
     choices: [
-      { name: "Initialize git repository", value: "initGit", checked: true },
-      { name: "Create README.md", value: "createReadme", checked: true },
-      { name: "Create .gitignore", value: "createGitignore", checked: true }
-    ]
+      { name: "Play short beep", value: "beep" },
+      { name: "Play custom sound", value: "custom" },
+      { name: "Run custom command", value: "command" }
+    ],
+    default: "beep"
   });
-  return {
-    type,
-    projectType,
-    packageManager,
-    initGit: additionalOptions.includes("initGit"),
-    createReadme: additionalOptions.includes("createReadme"),
-    createGitignore: additionalOptions.includes("createGitignore")
-  };
+  if (soundType === "beep") {
+    return { beep: true };
+  }
+  if (soundType === "custom") {
+    const soundPath = await input({
+      message: "Path to sound file:",
+      validate: (v) => v.trim() ? true : "Please enter a valid path"
+    });
+    return { customSound: soundPath };
+  }
+  const customCommand = await input({
+    message: "Custom command to run:",
+    validate: (v) => v.trim() ? true : "Please enter a command"
+  });
+  return { customCommand };
 }
 
 // src/cli/prompts/item-select.ts
@@ -9127,173 +9630,34 @@ ${progress} ${colors.bold(item.name)}`);
   return {
     category,
     selectedItems,
-    skippedItems
-  };
-}
-async function promptItemWithShortcuts(item, options) {
-  const choices = [
-    { name: "Yes, install", value: "install" },
-    { name: "No, skip", value: "skip" }
-  ];
-  if (options.remainingCount > 0) {
-    choices.push(
-      {
-        name: `Install all remaining (${options.remainingCount + 1} items)`,
-        value: "install-rest"
-      },
-      {
-        name: `Skip all remaining (${options.remainingCount + 1} items)`,
-        value: "skip-rest"
-      }
-    );
-  }
-  return select({
-    message: `Install ${item.name}?`,
-    choices,
-    default: options.defaultInstall !== false ? "install" : "skip"
-  });
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-// src/cli/prompts/hook-config.ts
-init_esm_shims();
-async function promptHookConfig(options) {
-  logger.section("Hook Configuration", "\u{1FA9D}");
-  const enableHooks = await confirm({
-    message: "Do you want to configure hooks?",
-    default: true
-  });
-  if (!enableHooks) {
-    return {
-      enabled: false
-    };
-  }
-  const selectedHooks = await checkbox({
-    message: "Which hooks do you want to configure?",
-    choices: [
-      {
-        name: "Notification hook (alerts when Claude needs attention)",
-        value: "notification",
-        checked: true
-      },
-      {
-        name: "Stop hook (plays sound when Claude stops)",
-        value: "stop",
-        checked: false
-      },
-      {
-        name: "Subagent stop hook (plays sound when subagent completes)",
-        value: "subagentStop",
-        checked: false
-      }
-    ]
-  });
-  const config = {
-    enabled: true
-  };
-  if (selectedHooks.includes("notification")) {
-    config.notification = await promptNotificationHook(options?.defaults?.notification);
-  }
-  if (selectedHooks.includes("stop")) {
-    config.stop = await promptStopHook();
-  }
-  if (selectedHooks.includes("subagentStop")) {
-    config.subagentStop = await promptSubagentStopHook();
-  }
-  return config;
-}
-async function promptNotificationHook(defaults) {
-  logger.newline();
-  logger.info("Notification Hook Configuration");
-  const notificationTypes = await checkbox({
-    message: "Select notification types:",
-    choices: [
-      {
-        name: "Desktop notifications (notify-send / terminal-notifier)",
-        value: "desktop",
-        checked: defaults?.desktop ?? true
-      },
-      {
-        name: "Audio notifications (text-to-speech)",
-        value: "audio",
-        checked: defaults?.audio ?? false
-      }
-    ]
-  });
-  let customCommand;
-  const wantCustom = await confirm({
-    message: "Do you want to add a custom notification command?",
-    default: false
-  });
-  if (wantCustom) {
-    customCommand = await input({
-      message: "Custom command (receives notification text as argument):",
-      default: defaults?.customCommand
-    });
-  }
-  return {
-    desktop: notificationTypes.includes("desktop"),
-    audio: notificationTypes.includes("audio"),
-    customCommand: customCommand || void 0
+    skippedItems
   };
 }
-async function promptStopHook() {
-  logger.newline();
-  logger.info("Stop Hook Configuration");
-  const soundType = await select({
-    message: "What should happen when Claude stops?",
-    choices: [
-      { name: "Play beep sound", value: "beep" },
-      { name: "Play custom sound", value: "custom" },
-      { name: "Run custom command", value: "command" }
-    ],
-    default: "beep"
-  });
-  if (soundType === "beep") {
-    return { beep: true };
-  }
-  if (soundType === "custom") {
-    const soundPath = await input({
-      message: "Path to sound file:",
-      validate: (v) => v.trim() ? true : "Please enter a valid path"
-    });
-    return { customSound: soundPath };
+async function promptItemWithShortcuts(item, options) {
+  const choices = [
+    { name: "Yes, install", value: "install" },
+    { name: "No, skip", value: "skip" }
+  ];
+  if (options.remainingCount > 0) {
+    choices.push(
+      {
+        name: `Install all remaining (${options.remainingCount + 1} items)`,
+        value: "install-rest"
+      },
+      {
+        name: `Skip all remaining (${options.remainingCount + 1} items)`,
+        value: "skip-rest"
+      }
+    );
   }
-  const customCommand = await input({
-    message: "Custom command to run:",
-    validate: (v) => v.trim() ? true : "Please enter a command"
+  return select({
+    message: `Install ${item.name}?`,
+    choices,
+    default: options.defaultInstall !== false ? "install" : "skip"
   });
-  return { customCommand };
 }
-async function promptSubagentStopHook() {
-  logger.newline();
-  logger.info("Subagent Stop Hook Configuration");
-  const soundType = await select({
-    message: "What should happen when a subagent completes?",
-    choices: [
-      { name: "Play short beep", value: "beep" },
-      { name: "Play custom sound", value: "custom" },
-      { name: "Run custom command", value: "command" }
-    ],
-    default: "beep"
-  });
-  if (soundType === "beep") {
-    return { beep: true };
-  }
-  if (soundType === "custom") {
-    const soundPath = await input({
-      message: "Path to sound file:",
-      validate: (v) => v.trim() ? true : "Please enter a valid path"
-    });
-    return { customSound: soundPath };
-  }
-  const customCommand = await input({
-    message: "Custom command to run:",
-    validate: (v) => v.trim() ? true : "Please enter a command"
-  });
-  return { customCommand };
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
 // src/cli/prompts/mcp-config.ts
@@ -9798,1178 +10162,1480 @@ async function promptCustomPermissions(defaults) {
     if (rule.trim()) {
       deny.push(rule.trim());
     }
-    addMoreDeny = await confirm({
-      message: "Add another deny rule?",
-      default: false
-    });
+    addMoreDeny = await confirm({
+      message: "Add another deny rule?",
+      default: false
+    });
+  }
+  return { allow, deny };
+}
+
+// src/cli/prompts/preferences.ts
+init_esm_shims();
+async function promptPreferences(options) {
+  logger.section("Preferences", "\u2699\uFE0F");
+  const language = await select({
+    message: "Working language (for documentation and comments):",
+    choices: [
+      { name: "English", value: "en" },
+      { name: "Espa\xF1ol", value: "es" }
+    ],
+    default: options?.defaults?.language || "en"
+  });
+  const responseLanguage = await select({
+    message: "Claude response language:",
+    choices: [
+      { name: "English", value: "en" },
+      { name: "Espa\xF1ol", value: "es" }
+    ],
+    default: options?.defaults?.responseLanguage || language
+  });
+  const includeCoAuthor = await confirm({
+    message: "Include Claude as commit co-author?",
+    default: options?.defaults?.includeCoAuthor ?? true
+  });
+  const packageManager = await promptPackageManagerPreference(options?.detectedPackageManager);
+  return {
+    language,
+    responseLanguage,
+    includeCoAuthor,
+    packageManager
+  };
+}
+async function promptPackageManagerPreference(detected) {
+  const choices = [
+    {
+      name: "pnpm (recommended)",
+      value: "pnpm",
+      description: "Fast, disk space efficient package manager"
+    },
+    {
+      name: "npm",
+      value: "npm",
+      description: "Node.js default package manager"
+    },
+    {
+      name: "yarn",
+      value: "yarn",
+      description: "Fast, reliable dependency management"
+    },
+    {
+      name: "bun",
+      value: "bun",
+      description: "All-in-one JavaScript runtime & toolkit"
+    }
+  ];
+  if (detected) {
+    const detectedChoice = choices.find((c) => c.value === detected);
+    if (detectedChoice) {
+      detectedChoice.name = `${detectedChoice.name} (detected)`;
+    }
+  }
+  return select({
+    message: "Preferred package manager:",
+    choices,
+    default: detected || "pnpm"
+  });
+}
+
+// src/cli/prompts/project-info.ts
+init_esm_shims();
+async function promptProjectInfo(options) {
+  logger.section("Project Information", "\u{1F4CB}");
+  const name = await input({
+    message: "Project name:",
+    default: options?.defaults?.name,
+    validate: (value) => {
+      if (!value.trim()) return "Project name is required";
+      if (!/^[a-zA-Z0-9-_\s]+$/.test(value)) {
+        return "Project name can only contain letters, numbers, dashes, underscores, and spaces";
+      }
+      return true;
+    }
+  });
+  const description = await input({
+    message: "Project description:",
+    default: options?.defaults?.description || "",
+    validate: (value) => {
+      if (!value.trim()) return "Description is required";
+      return true;
+    }
+  });
+  const org = await input({
+    message: "GitHub organization/username:",
+    default: options?.defaults?.org || "",
+    validate: (value) => {
+      if (!value.trim()) return "Organization is required";
+      if (!/^[a-zA-Z0-9-]+$/.test(value)) {
+        return "Organization can only contain letters, numbers, and dashes";
+      }
+      return true;
+    }
+  });
+  const repo = await input({
+    message: "Repository name:",
+    default: options?.defaults?.repo || name.toLowerCase().replace(/\s+/g, "-"),
+    validate: (value) => {
+      if (!value.trim()) return "Repository name is required";
+      if (!/^[a-zA-Z0-9-_]+$/.test(value)) {
+        return "Repository name can only contain letters, numbers, dashes, and underscores";
+      }
+      return true;
+    }
+  });
+  const author = await input({
+    message: 'Author (name or "Name <email>"):',
+    default: options?.defaults?.author || ""
+  });
+  let entityType = "item";
+  let entityTypePlural = "items";
+  const wantEntityConfig = await confirm({
+    message: "Configure primary entity type? (Used for code examples and templates)",
+    default: false
+  });
+  if (wantEntityConfig) {
+    logger.info("The entity type is used in code examples and templates throughout the project.");
+    logger.info(
+      'For example, if your project manages "products", code examples will use product-related names.'
+    );
+    logger.newline();
+    entityType = await input({
+      message: "Primary entity type (e.g., product, article, user, listing):",
+      default: options?.defaults?.entityType || "item",
+      validate: (value) => {
+        if (!value.trim()) return "Entity type is required";
+        return true;
+      }
+    });
+    entityTypePlural = await input({
+      message: "Entity type plural:",
+      default: options?.defaults?.entityTypePlural || pluralize(entityType)
+    });
+  } else if (options?.defaults?.entityType) {
+    entityType = options.defaults.entityType;
+    entityTypePlural = options.defaults.entityTypePlural || pluralize(entityType);
+  }
+  let domain;
+  let location;
+  if (!options?.skipOptional) {
+    const wantDomain = await confirm({
+      message: "Do you want to specify a domain?",
+      default: false
+    });
+    if (wantDomain) {
+      domain = await input({
+        message: "Domain (e.g., myproject.com):",
+        default: options?.defaults?.domain || "",
+        validate: (value) => {
+          if (value && !/^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(value)) {
+            return "Please enter a valid domain";
+          }
+          return true;
+        }
+      });
+    }
+    const wantLocation = await confirm({
+      message: "Do you want to specify a location/region?",
+      default: false
+    });
+    if (wantLocation) {
+      location = await input({
+        message: "Location/Region:",
+        default: options?.defaults?.location || ""
+      });
+    }
   }
-  return { allow, deny };
+  return {
+    name: name.trim(),
+    description: description.trim(),
+    org: org.trim(),
+    repo: repo.trim(),
+    domain,
+    entityType: entityType.trim().toLowerCase(),
+    entityTypePlural: entityTypePlural.trim().toLowerCase(),
+    location,
+    author: author.trim() || void 0
+  };
+}
+function pluralize(word) {
+  const lower = word.toLowerCase();
+  if (lower.endsWith("y")) {
+    return `${lower.slice(0, -1)}ies`;
+  }
+  if (lower.endsWith("s") || lower.endsWith("x") || lower.endsWith("ch") || lower.endsWith("sh")) {
+    return `${lower}es`;
+  }
+  return `${lower}s`;
+}
+async function confirmProjectInfo(info) {
+  logger.newline();
+  logger.subtitle("Project Summary");
+  logger.keyValue("Name", info.name);
+  logger.keyValue("Description", info.description);
+  logger.keyValue("GitHub", `${info.org}/${info.repo}`);
+  if (info.author) logger.keyValue("Author", info.author);
+  logger.keyValue("Entity", `${info.entityType} / ${info.entityTypePlural}`);
+  if (info.domain) logger.keyValue("Domain", info.domain);
+  if (info.location) logger.keyValue("Location", info.location);
+  logger.newline();
+  return confirm({
+    message: "Is this information correct?",
+    default: true
+  });
 }
 
-// src/cli/prompts/update.ts
+// src/cli/prompts/scaffold.ts
 init_esm_shims();
-async function promptUpdateAction() {
-  logger.subtitle("Update Options");
+async function promptScaffoldType(options) {
+  logger.section("Configuration Scope", "\u{1F3D7}\uFE0F");
+  if (options?.existingProject) {
+    logger.info("Existing project detected");
+    logger.newline();
+    const choice = await select({
+      message: "What would you like to do?",
+      choices: [
+        {
+          name: "Add Claude config only (recommended)",
+          value: "claude-only",
+          description: "Creates .claude/ folder without touching existing files"
+        },
+        {
+          name: "Full project setup (\u26A0\uFE0F may overwrite files)",
+          value: "full-project",
+          description: "Includes project scaffolding - use with caution"
+        }
+      ],
+      default: "claude-only"
+    });
+    if (choice === "full-project") {
+      const confirmed = await confirm({
+        message: "\u26A0\uFE0F  This may overwrite existing files. Are you sure?",
+        default: false
+      });
+      if (!confirmed) {
+        return "claude-only";
+      }
+    }
+    return choice;
+  }
   return select({
-    message: "What would you like to update?",
+    message: "What would you like to configure?",
     choices: [
       {
-        name: "Check for updates",
-        value: "check",
-        description: "Show what has changed without modifying files"
-      },
-      {
-        name: "Update modules only",
-        value: "modules",
-        description: "Update agents, skills, commands, docs"
-      },
-      {
-        name: "Reconfigure settings",
-        value: "config",
-        description: "Re-run configuration for MCP, hooks, preferences"
-      },
-      {
-        name: "Full update",
-        value: "all",
-        description: "Update everything"
+        name: "Claude configuration only",
+        value: "claude-only",
+        description: "Only creates .claude/ folder with agents, commands, skills, docs"
       },
       {
-        name: "Cancel",
-        value: "cancel"
+        name: "Full project setup",
+        value: "full-project",
+        description: "Creates project structure + Claude configuration"
       }
     ],
-    default: "check"
+    default: "claude-only"
   });
 }
-function showUpdateReport(updates) {
-  logger.newline();
-  logger.title("Update Report");
-  if (updates.new.length === 0 && updates.updated.length === 0 && updates.deprecated.length === 0) {
-    logger.success("Everything is up to date!");
-    return;
-  }
-  if (updates.new.length > 0) {
-    logger.newline();
-    logger.info(colors.bold(`\u271A New modules available (${updates.new.length}):`));
-    for (const mod of updates.new) {
-      logger.item(`${mod.category}: ${colors.primary(mod.name)}`);
-    }
-  }
-  if (updates.updated.length > 0) {
-    logger.newline();
-    logger.info(colors.bold(`\u21BB Updated modules (${updates.updated.length}):`));
-    for (const mod of updates.updated) {
-      const conflict = mod.hasLocalChanges ? colors.warning(" (local changes)") : "";
-      logger.item(`${mod.category}: ${colors.primary(mod.name)}${conflict}`);
-    }
-  }
-  if (updates.deprecated.length > 0) {
-    logger.newline();
-    logger.info(colors.bold(`\u2717 Deprecated modules (${updates.deprecated.length}):`));
-    for (const mod of updates.deprecated) {
-      logger.item(`${mod.category}: ${colors.muted(mod.name)}`);
+async function promptProjectType(detectedType) {
+  const choices = [
+    {
+      name: "Node.js (TypeScript)",
+      value: "node",
+      description: "Basic Node.js project with TypeScript"
+    },
+    {
+      name: "Monorepo (TurboRepo + pnpm)",
+      value: "monorepo",
+      description: "Multi-package monorepo setup"
+    },
+    {
+      name: "Astro",
+      value: "astro",
+      description: "Astro static/SSR site"
+    },
+    {
+      name: "Next.js",
+      value: "nextjs",
+      description: "Next.js full-stack React framework"
+    },
+    {
+      name: "Vite + React",
+      value: "vite-react",
+      description: "Vite bundled React SPA"
+    },
+    {
+      name: "Hono API",
+      value: "hono",
+      description: "Hono lightweight API server"
+    },
+    {
+      name: "Custom",
+      value: "custom",
+      description: "Define your own project structure"
     }
-  }
-  if (updates.conflicts.length > 0) {
-    logger.newline();
-    logger.warn(`\u26A0 Modules with conflicts (${updates.conflicts.length}):`);
-    for (const mod of updates.conflicts) {
-      logger.item(`${mod.category}: ${colors.warning(mod.name)} - has local modifications`);
+  ];
+  if (detectedType) {
+    const detected = choices.find((c) => c.value === detectedType);
+    if (detected) {
+      detected.name = `${detected.name} (detected)`;
     }
   }
-}
-async function promptNewModules(modules) {
-  if (modules.length === 0) return [];
-  logger.newline();
-  const choices = modules.map((mod) => ({
-    name: `${mod.category}: ${mod.name}`,
-    value: mod.id,
-    checked: false
-  }));
-  return checkbox({
-    message: "Select new modules to install:",
-    choices
-  });
-}
-async function promptUpdatedModules(modules) {
-  if (modules.length === 0) return [];
-  logger.newline();
-  const choices = modules.map((mod) => ({
-    name: `${mod.category}: ${mod.name}${mod.hasLocalChanges ? " \u26A0\uFE0F" : ""}`,
-    value: mod.id,
-    checked: !mod.hasLocalChanges
-    // Don't check by default if has local changes
-  }));
-  return checkbox({
-    message: "Select modules to update:",
-    choices
+  return select({
+    message: "Project type:",
+    choices,
+    default: detectedType || "node"
   });
 }
-async function promptConflictResolution(module) {
-  logger.newline();
-  logger.warn(`Conflict: ${module.category}/${module.name} has local modifications`);
+async function promptPackageManager(detected) {
+  const choices = [
+    { name: "pnpm (recommended)", value: "pnpm" },
+    { name: "npm", value: "npm" },
+    { name: "yarn", value: "yarn" },
+    { name: "bun", value: "bun" }
+  ];
+  if (detected) {
+    const detectedChoice = choices.find((c) => c.value === detected);
+    if (detectedChoice) {
+      detectedChoice.name = `${detectedChoice.name} (detected)`;
+    }
+  }
   return select({
-    message: "How do you want to resolve this conflict?",
-    choices: [
-      {
-        name: "Keep local version",
-        value: "keep",
-        description: "Do not update this module"
-      },
-      {
-        name: "Use updated version",
-        value: "update",
-        description: "Replace with new version (lose local changes)"
-      },
-      {
-        name: "Show diff",
-        value: "diff",
-        description: "See what changed before deciding"
-      }
-    ],
-    default: "keep"
+    message: "Package manager:",
+    choices,
+    default: detected || "pnpm"
   });
 }
-async function promptReconfigureOptions() {
+async function promptScaffoldOptions(options) {
+  const type = await promptScaffoldType(options);
+  if (type === "claude-only") {
+    return { type };
+  }
+  const projectType = await promptProjectType(options?.detectedType);
+  const packageManager = await promptPackageManager(options?.detectedPackageManager);
   logger.newline();
-  return checkbox({
-    message: "What would you like to reconfigure?",
+  logger.subtitle("Additional Options");
+  const additionalOptions = await checkbox({
+    message: "Select additional options:",
     choices: [
-      { name: "MCP servers", value: "mcp", checked: false },
-      { name: "Hooks", value: "hooks", checked: false },
-      { name: "Preferences (language, co-author)", value: "preferences", checked: false },
-      { name: "Permissions", value: "permissions", checked: false },
-      { name: "Add/remove modules", value: "modules", checked: false }
+      { name: "Initialize git repository", value: "initGit", checked: true },
+      { name: "Create README.md", value: "createReadme", checked: true },
+      { name: "Create .gitignore", value: "createGitignore", checked: true }
     ]
   });
+  return {
+    type,
+    projectType,
+    packageManager,
+    initGit: additionalOptions.includes("initGit"),
+    createReadme: additionalOptions.includes("createReadme"),
+    createGitignore: additionalOptions.includes("createGitignore")
+  };
 }
 
-// src/cli/prompts/confirm.ts
+// src/cli/prompts/template-config.ts
 init_esm_shims();
-async function promptExistingProjectAction() {
-  return select({
-    message: "Existing .claude/ folder detected. What would you like to do?",
+var CATEGORY_INFO = {
+  commands: { name: "CLI Commands", order: 1 },
+  paths: { name: "Directory Paths", order: 2 },
+  targets: { name: "Quality Targets", order: 3 },
+  tracking: { name: "Issue Tracking", order: 4 },
+  techStack: { name: "Technology Stack", order: 5 },
+  performance: { name: "Performance Targets", order: 6 },
+  environment: { name: "Environment Variables", order: 7 },
+  brand: { name: "Brand Identity", order: 8 }
+};
+async function promptSetupMode() {
+  const mode = await select({
+    message: "Configuration mode:",
     choices: [
       {
-        name: "Skip (keep existing)",
-        value: "skip",
-        description: "Do not modify existing configuration"
+        name: "Quick Setup (recommended)",
+        value: "quick",
+        description: "Auto-detect values, confirm all at once"
       },
       {
-        name: "Overwrite",
-        value: "overwrite",
-        description: "Replace existing configuration"
+        name: "Guided Setup",
+        value: "guided",
+        description: "Step through each category"
       },
       {
-        name: "Merge",
-        value: "merge",
-        description: "Add new items, keep existing"
+        name: "Advanced Setup",
+        value: "advanced",
+        description: "Configure all options individually"
       }
     ],
-    default: "skip"
-  });
-}
-function showFinalSummary(config) {
-  logger.newline();
-  logger.title("Configuration Summary");
-  logger.subtitle("Project");
-  logger.keyValue("Name", config.project.name);
-  logger.keyValue("GitHub", `${config.project.org}/${config.project.repo}`);
-  if (config.project.domain) {
-    logger.keyValue("Domain", config.project.domain);
-  }
-  logger.newline();
-  logger.subtitle("Preferences");
-  logger.keyValue("Language", config.preferences.language === "en" ? "English" : "Espa\xF1ol");
-  logger.keyValue("Co-author", config.preferences.includeCoAuthor ? "Yes" : "No");
-  logger.newline();
-  logger.subtitle("Modules");
-  const moduleCategories = ["agents", "skills", "commands", "docs"];
-  for (const category of moduleCategories) {
-    const selected = config.modules[category].selected;
-    if (selected.length > 0) {
-      logger.keyValue(capitalize2(category), `${selected.length} selected`);
-      logger.note(selected.join(", "));
-    }
-  }
-  logger.newline();
-  logger.subtitle("Extras");
-  const extras = [];
-  if (config.extras.schemas) extras.push("schemas");
-  if (config.extras.scripts) extras.push("scripts");
-  if (config.extras.hooks.enabled) extras.push("hooks");
-  if (config.extras.sessions) extras.push("sessions");
-  logger.keyValue("Included", extras.join(", ") || "none");
-  if (config.extras.codeStyle?.enabled) {
-    const codeStyleTools = [];
-    if (config.extras.codeStyle.editorconfig) codeStyleTools.push("EditorConfig");
-    if (config.extras.codeStyle.commitlint) codeStyleTools.push("Commitlint");
-    if (config.extras.codeStyle.biome) codeStyleTools.push("Biome");
-    if (config.extras.codeStyle.prettier) codeStyleTools.push("Prettier");
-    logger.keyValue("Code Style", codeStyleTools.join(", "));
-  }
-  if (config.mcp.servers.length > 0) {
-    logger.newline();
-    logger.subtitle("MCP Servers");
-    logger.keyValue("Level", config.mcp.level);
-    logger.keyValue("Servers", config.mcp.servers.map((s) => s.serverId).join(", "));
-  }
-  logger.newline();
-  logger.subtitle("Scaffold");
-  logger.keyValue(
-    "Type",
-    config.scaffold.type === "claude-only" ? "Claude config only" : "Full project"
-  );
-}
-async function confirmFinalConfiguration(config) {
-  showFinalSummary(config);
-  logger.newline();
-  return confirm({
-    message: "Proceed with this configuration?",
-    default: true
+    default: "quick"
   });
+  return mode;
 }
-function showPostInstallInstructions(config) {
-  logger.newline();
-  logger.title("Installation Complete!");
-  const steps = [];
-  if (config.scaffold.type === "full-project") {
-    steps.push("Review the generated project structure");
-  }
-  steps.push("Review .claude/CLAUDE.md for agent instructions");
-  steps.push("Customize agents, commands, and skills as needed");
-  if (config.mcp.servers.length > 0) {
-    const mcpFile = config.mcp.level === "user" ? "~/.claude/settings.json" : ".claude/settings.local.json";
-    steps.push(`Configure MCP server credentials in ${mcpFile}`);
-  }
-  if (config.extras.hooks.enabled) {
-    steps.push("Review hook scripts in .claude/hooks/");
-    if (config.extras.hooks.notification?.audio) {
-      steps.push("Install Piper TTS for audio notifications (see docs)");
-    }
-  }
-  logger.instructions("Next Steps:", steps);
-  logger.subtitle("Useful Commands");
-  logger.raw("");
-  logger.raw(`  ${colors.primary("claude-config status")}     - Show current configuration`);
-  logger.raw(`  ${colors.primary("claude-config list")}       - List available modules`);
-  logger.raw(`  ${colors.primary("claude-config add")}        - Add a module`);
-  logger.raw(`  ${colors.primary("claude-config update")}     - Update configuration`);
-  logger.raw("");
-}
-function capitalize2(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-// 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
+async function buildConfigContext(projectPath) {
+  const context = {
+    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 pkg = JSON.parse(pkgContent);
+    context.scripts = pkg.scripts || {};
+    context.dependencies = {
+      ...pkg.dependencies || {},
+      ...pkg.devDependencies || {}
     };
-  }
-  const selectedTools = await checkbox({
-    message: "Select the tools to configure:",
-    choices: CODE_STYLE_TOOLS.map((tool) => ({
-      name: `${tool.name} - ${tool.description}`,
-      value: tool.value,
-      checked: options?.defaults?.[tool.value] ?? tool.checked
-    }))
-  });
-  if (selectedTools.includes("biome") && selectedTools.includes("prettier")) {
-    logger.warn("Note: Both Biome and Prettier selected. Biome can replace Prettier.");
-    const keepBoth = await confirm({
-      message: "Keep both? (Prettier may conflict with Biome)",
-      default: false
-    });
-    if (!keepBoth) {
-      const preferred = await select({
-        message: "Which formatter would you prefer?",
-        choices: [
-          { name: "Biome (faster, all-in-one)", value: "biome" },
-          { name: "Prettier (more plugins)", value: "prettier" }
-        ]
-      });
-      const indexToRemove = preferred === "biome" ? selectedTools.indexOf("prettier") : selectedTools.indexOf("biome");
-      if (indexToRemove > -1) {
-        selectedTools.splice(indexToRemove, 1);
+    context.hasTypeScript = Boolean(context.dependencies.typescript) || await fileExists(path8.join(projectPath, "tsconfig.json"));
+    if (await fileExists(path8.join(projectPath, "pnpm-lock.yaml"))) {
+      context.packageManager = "pnpm";
+    } else if (await fileExists(path8.join(projectPath, "yarn.lock"))) {
+      context.packageManager = "yarn";
+    } else if (await fileExists(path8.join(projectPath, "bun.lockb"))) {
+      context.packageManager = "bun";
+    } else {
+      context.packageManager = "npm";
+    }
+    context.isGitRepo = await fileExists(path8.join(projectPath, ".git"));
+    if (context.isGitRepo) {
+      try {
+        const { execSync } = await import("child_process");
+        const remotes = execSync("git remote -v", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        });
+        context.hasGitHubRemote = remotes.includes("github.com");
+      } catch {
+        context.hasGitHubRemote = false;
       }
     }
+  } catch {
   }
-  if (selectedTools.length === 0) {
-    return {
-      enabled: false,
-      editorconfig: false,
-      commitlint: false,
-      biome: false,
-      prettier: false
-    };
+  return context;
+}
+async function fileExists(filePath) {
+  try {
+    const fs6 = await import("fs/promises");
+    await fs6.access(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  const customizeSettings = await confirm({
-    message: "Would you like to customize code style settings? (No = use standard defaults)",
-    default: false
-  });
-  let editorconfigOptions;
-  let biomeOptions;
-  let prettierOptions;
-  let commitlintOptions;
-  if (customizeSettings) {
-    const hasFormatter = selectedTools.includes("editorconfig") || selectedTools.includes("biome") || selectedTools.includes("prettier");
-    if (hasFormatter) {
-      const preset = await promptStylePreset();
-      if (preset !== "custom") {
-        const presetConfig = CODE_STYLE_PRESETS[preset];
-        if (selectedTools.includes("editorconfig")) {
-          editorconfigOptions = presetConfig.editorconfig;
-        }
-        if (selectedTools.includes("biome") && presetConfig.biome) {
-          biomeOptions = {
-            ...DEFAULT_BIOME_OPTIONS,
-            formatter: presetConfig.biome
-          };
-        }
-        if (selectedTools.includes("prettier") && presetConfig.prettier) {
-          prettierOptions = presetConfig.prettier;
-        }
-      } else {
-        if (selectedTools.includes("editorconfig")) {
-          editorconfigOptions = await promptEditorConfigOptions();
-        }
-        if (selectedTools.includes("biome")) {
-          biomeOptions = await promptBiomeOptions();
-        }
-        if (selectedTools.includes("prettier")) {
-          prettierOptions = await promptPrettierOptions();
-        }
+}
+async function promptPlaceholder(placeholder, context, detectedValue) {
+  const defaultValue = detectedValue || computeDefaultValue(placeholder, context) || "";
+  switch (placeholder.inputType) {
+    case "select": {
+      if (!placeholder.choices || placeholder.choices.length === 0) {
+        return input({
+          message: `${placeholder.label}:`,
+          default: defaultValue
+        });
       }
+      const choices = placeholder.choices.map((c) => ({
+        name: c.name,
+        value: c.value,
+        description: c.description
+      }));
+      return select({
+        message: `${placeholder.label}:`,
+        choices,
+        default: defaultValue || choices[0].value
+      });
     }
-    if (selectedTools.includes("commitlint")) {
-      commitlintOptions = await promptCommitlintOptions();
-    }
-  } else {
-    if (selectedTools.includes("editorconfig")) {
-      editorconfigOptions = DEFAULT_EDITORCONFIG_OPTIONS;
+    case "number": {
+      const result = await input({
+        message: `${placeholder.label}:`,
+        default: defaultValue,
+        validate: (value) => {
+          if (placeholder.validate) {
+            return placeholder.validate(value, context);
+          }
+          const num = Number(value);
+          if (Number.isNaN(num)) {
+            return "Please enter a valid number";
+          }
+          return true;
+        }
+      });
+      return result;
     }
-    if (selectedTools.includes("biome")) {
-      biomeOptions = DEFAULT_BIOME_OPTIONS;
+    case "path": {
+      return input({
+        message: `${placeholder.label}:`,
+        default: defaultValue,
+        validate: (value) => {
+          if (placeholder.required && !value.trim()) {
+            return "This path is required";
+          }
+          if (placeholder.validate) {
+            return placeholder.validate(value, context);
+          }
+          return true;
+        }
+      });
     }
-    if (selectedTools.includes("prettier")) {
-      prettierOptions = DEFAULT_PRETTIER_OPTIONS;
+    case "envVar": {
+      return input({
+        message: `${placeholder.label}:`,
+        default: defaultValue,
+        validate: (value) => {
+          if (placeholder.required && !value.trim()) {
+            return "This environment variable is required";
+          }
+          if (value && !/^[A-Z][A-Z0-9_]*$/.test(value)) {
+            return "Environment variable should be UPPER_SNAKE_CASE";
+          }
+          return true;
+        }
+      });
     }
-    if (selectedTools.includes("commitlint")) {
-      commitlintOptions = DEFAULT_COMMITLINT_OPTIONS;
+    default: {
+      return input({
+        message: `${placeholder.label}:`,
+        default: defaultValue,
+        validate: (value) => {
+          if (placeholder.required && !value.trim()) {
+            return `${placeholder.label} is required`;
+          }
+          if (placeholder.validate) {
+            return placeholder.validate(value, context);
+          }
+          return true;
+        }
+      });
     }
   }
-  return {
-    enabled: selectedTools.length > 0,
-    editorconfig: selectedTools.includes("editorconfig"),
-    editorconfigOptions,
-    commitlint: selectedTools.includes("commitlint"),
-    commitlintOptions,
-    biome: selectedTools.includes("biome"),
-    biomeOptions,
-    prettier: selectedTools.includes("prettier"),
-    prettierOptions
-  };
-}
-async function promptStylePreset() {
-  logger.newline();
-  logger.info("Choose a code style preset:");
-  return select({
-    message: "Style preset:",
-    choices: Object.entries(CODE_STYLE_PRESETS).map(([key, preset]) => ({
-      name: `${preset.name} - ${preset.description}`,
-      value: key
-    })),
-    default: "standard"
-  });
 }
-async function promptEditorConfigOptions() {
-  logger.newline();
-  logger.subtitle("EditorConfig Options");
-  const indentStyle = await select({
-    message: "Indent style:",
-    choices: [
-      { name: "Spaces", value: "space" },
-      { name: "Tabs", value: "tab" }
-    ],
-    default: DEFAULT_EDITORCONFIG_OPTIONS.indentStyle
-  });
-  const indentSizeStr = await input({
-    message: "Indent size:",
-    default: String(DEFAULT_EDITORCONFIG_OPTIONS.indentSize),
-    validate: (v) => {
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 1 || num > 8) return "Enter a number between 1 and 8";
-      return true;
-    }
-  });
-  const indentSize = Number(indentSizeStr);
-  const endOfLine = await select({
-    message: "Line endings:",
-    choices: [
-      { name: "LF (Unix/Mac)", value: "lf" },
-      { name: "CRLF (Windows)", value: "crlf" },
-      { name: "CR (Old Mac)", value: "cr" }
-    ],
-    default: DEFAULT_EDITORCONFIG_OPTIONS.endOfLine
-  });
-  const maxLineLengthStr = await input({
-    message: 'Max line length (or "off"):',
-    default: String(DEFAULT_EDITORCONFIG_OPTIONS.maxLineLength),
-    validate: (v) => {
-      if (v.toLowerCase() === "off") return true;
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 40 || num > 200)
-        return 'Enter a number between 40 and 200, or "off"';
-      return true;
-    }
-  });
-  const maxLineLength = maxLineLengthStr.toLowerCase() === "off" ? "off" : Number(maxLineLengthStr);
-  return {
-    indentStyle,
-    indentSize,
-    endOfLine,
-    insertFinalNewline: true,
-    trimTrailingWhitespace: true,
-    charset: "utf-8",
-    maxLineLength
+function computeAllDefaults(context, globalDefaults) {
+  const config = {
+    commands: {},
+    paths: {},
+    targets: {},
+    tracking: {},
+    techStack: {},
+    environment: {},
+    brand: {}
   };
+  for (const placeholder of TEMPLATE_PLACEHOLDERS) {
+    const defaultValue = computeDefaultValue(placeholder, context);
+    if (defaultValue) {
+      setConfigValue(config, placeholder, defaultValue);
+    }
+  }
+  if (globalDefaults) {
+    return mergeWithGlobalDefaults(config, globalDefaults);
+  }
+  return config;
+}
+function setConfigValue(config, placeholder, value) {
+  const key = placeholderKeyToConfigKey(placeholder.key, placeholder.category);
+  switch (placeholder.category) {
+    case "commands":
+      if (!config.commands) config.commands = {};
+      config.commands[key] = value;
+      break;
+    case "paths":
+      if (!config.paths) config.paths = {};
+      config.paths[key] = value;
+      break;
+    case "targets":
+    case "performance": {
+      if (!config.targets) config.targets = {};
+      const numValue = Number(value);
+      if (!Number.isNaN(numValue)) {
+        config.targets[key] = numValue;
+      } else {
+        config.targets[key] = value;
+      }
+      break;
+    }
+    case "tracking":
+      if (!config.tracking) config.tracking = {};
+      config.tracking[key] = key.endsWith("Days") ? Number(value) : value;
+      break;
+    case "techStack":
+      if (!config.techStack) config.techStack = {};
+      config.techStack[key] = value;
+      break;
+    case "environment":
+      if (!config.environment) config.environment = {};
+      config.environment[key] = value;
+      break;
+    case "brand":
+      if (!config.brand) config.brand = {};
+      config.brand[key] = value;
+      break;
+  }
 }
-async function promptBiomeOptions() {
+function placeholderKeyToConfigKey(key, category) {
+  let cleanKey = key;
+  if (category === "commands" && key.endsWith("_COMMAND")) {
+    cleanKey = key.slice(0, -8);
+  } else if (category === "environment" && key.endsWith("_ENV")) {
+    cleanKey = key.slice(0, -4);
+  } else if (key.endsWith("_TARGET")) {
+    cleanKey = key.slice(0, -7);
+  }
+  return cleanKey.toLowerCase().replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+}
+async function promptTemplateConfig(options) {
+  const { context, mode = "quick", category, requiredOnly = false } = options;
+  logger.section("Template Configuration", "\u{1F4DD}");
   logger.newline();
-  logger.subtitle("Biome Options");
-  const indentStyle = await select({
-    message: "Indent style:",
-    choices: [
-      { name: "Spaces", value: "space" },
-      { name: "Tabs", value: "tab" }
-    ],
-    default: DEFAULT_BIOME_OPTIONS.formatter.indentStyle
-  });
-  const indentWidthStr = await input({
-    message: "Indent width:",
-    default: String(DEFAULT_BIOME_OPTIONS.formatter.indentWidth),
-    validate: (v) => {
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 1 || num > 8) return "Enter a number between 1 and 8";
-      return true;
-    }
-  });
-  const indentWidth = Number(indentWidthStr);
-  const lineWidthStr = await input({
-    message: "Line width:",
-    default: String(DEFAULT_BIOME_OPTIONS.formatter.lineWidth),
-    validate: (v) => {
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 40 || num > 200) return "Enter a number between 40 and 200";
-      return true;
-    }
-  });
-  const lineWidth = Number(lineWidthStr);
-  const quoteStyle = await select({
-    message: "Quote style:",
-    choices: [
-      { name: "Single quotes", value: "single" },
-      { name: "Double quotes", value: "double" }
-    ],
-    default: DEFAULT_BIOME_OPTIONS.formatter.quoteStyle
-  });
-  const semicolons = await select({
-    message: "Semicolons:",
-    choices: [
-      { name: "Always", value: "always" },
-      { name: "As needed (ASI)", value: "asNeeded" }
-    ],
-    default: DEFAULT_BIOME_OPTIONS.formatter.semicolons
-  });
-  const trailingCommas = await select({
-    message: "Trailing commas:",
-    choices: [
-      { name: "All", value: "all" },
-      { name: "ES5 (only where valid in ES5)", value: "es5" },
-      { name: "None", value: "none" }
-    ],
-    default: DEFAULT_BIOME_OPTIONS.formatter.trailingCommas
-  });
-  const enableRecommended = await confirm({
-    message: "Enable recommended linter rules?",
-    default: true
-  });
-  return {
-    formatter: {
-      indentStyle,
-      indentWidth,
-      lineWidth,
-      quoteStyle,
-      semicolons,
-      trailingCommas,
-      quoteProperties: "asNeeded",
-      bracketSpacing: true,
-      bracketSameLine: false,
-      arrowParentheses: "always"
-    },
-    linter: {
-      recommended: enableRecommended,
-      correctness: enableRecommended,
-      suspicious: enableRecommended,
-      style: enableRecommended,
-      complexity: enableRecommended,
-      security: enableRecommended,
-      performance: enableRecommended,
-      a11y: enableRecommended
-    },
-    organizeImports: true,
-    ignorePatterns: DEFAULT_BIOME_OPTIONS.ignorePatterns
-  };
+  logger.info("This step personalizes all Claude Code configuration files for YOUR project.");
+  logger.info("Your answers will be used to:");
+  logger.newline();
+  logger.item("Replace {{PLACEHOLDERS}} in agents, commands, and skills");
+  logger.item("Configure CLAUDE.md with your tech stack and commands");
+  logger.item("Set up quality targets (coverage, performance, accessibility)");
+  logger.item("Customize code examples to match your project structure");
+  logger.newline();
+  logger.info("Accurate configuration means better AI assistance tailored to your codebase!");
+  logger.newline();
+  const hasDefaults = await hasGlobalDefaults();
+  const globalDefaults = hasDefaults ? await getGlobalTemplateConfig() : void 0;
+  if (mode === "quick") {
+    return promptQuickSetup(context, globalDefaults);
+  }
+  if (category) {
+    return promptCategory(category, context, requiredOnly);
+  }
+  if (mode === "guided") {
+    return promptGuidedSetup(context, requiredOnly);
+  }
+  return promptAdvancedSetup(context);
 }
-async function promptPrettierOptions() {
+async function promptQuickSetup(context, globalDefaults) {
+  logger.info("Auto-detecting configuration from project...");
   logger.newline();
-  logger.subtitle("Prettier Options");
-  const printWidthStr = await input({
-    message: "Print width:",
-    default: String(DEFAULT_PRETTIER_OPTIONS.printWidth),
-    validate: (v) => {
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 40 || num > 200) return "Enter a number between 40 and 200";
-      return true;
-    }
+  const detected = computeAllDefaults(context, globalDefaults);
+  displayDetectedConfig(detected, context);
+  const wantEdit = await confirm({
+    message: "Would you like to modify any values?",
+    default: false
   });
-  const printWidth = Number(printWidthStr);
-  const tabWidthStr = await input({
-    message: "Tab width:",
-    default: String(DEFAULT_PRETTIER_OPTIONS.tabWidth),
-    validate: (v) => {
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 1 || num > 8) return "Enter a number between 1 and 8";
-      return true;
+  let finalConfig = detected;
+  if (wantEdit) {
+    finalConfig = await promptEditConfig(detected, context);
+  }
+  return finalConfig;
+}
+function displayDetectedConfig(config, _context) {
+  const categories = Object.entries(CATEGORY_INFO).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
+  for (const category of categories) {
+    const placeholders = getPlaceholdersByCategory(category);
+    if (placeholders.length === 0) continue;
+    const values = getCategoryValues(config, category);
+    if (Object.keys(values).length === 0) continue;
+    logger.subtitle(CATEGORY_INFO[category].name);
+    for (const [key, value] of Object.entries(values)) {
+      if (value !== void 0) {
+        const placeholder = TEMPLATE_PLACEHOLDERS.find(
+          (p) => placeholderKeyToConfigKey(p.key, p.category) === key
+        );
+        const label = placeholder?.label || key;
+        logger.keyValue(label, String(value));
+      }
     }
-  });
-  const tabWidth = Number(tabWidthStr);
-  const useTabs = await confirm({
-    message: "Use tabs instead of spaces?",
-    default: DEFAULT_PRETTIER_OPTIONS.useTabs
-  });
-  const semi = await confirm({
-    message: "Use semicolons?",
-    default: DEFAULT_PRETTIER_OPTIONS.semi
-  });
-  const singleQuote = await confirm({
-    message: "Use single quotes?",
-    default: DEFAULT_PRETTIER_OPTIONS.singleQuote
-  });
-  const trailingComma = await select({
-    message: "Trailing commas:",
-    choices: [
-      { name: "All", value: "all" },
-      { name: "ES5", value: "es5" },
-      { name: "None", value: "none" }
-    ],
-    default: DEFAULT_PRETTIER_OPTIONS.trailingComma
-  });
-  const bracketSpacing = await confirm({
-    message: "Bracket spacing? ({ foo: bar })",
-    default: DEFAULT_PRETTIER_OPTIONS.bracketSpacing
-  });
-  const arrowParens = await select({
-    message: "Arrow function parentheses:",
-    choices: [
-      { name: "Always (x) => x", value: "always" },
-      { name: "Avoid x => x", value: "avoid" }
-    ],
-    default: DEFAULT_PRETTIER_OPTIONS.arrowParens
-  });
-  return {
-    printWidth,
-    tabWidth,
-    useTabs,
-    semi,
-    singleQuote,
-    jsxSingleQuote: false,
-    trailingComma,
-    bracketSpacing,
-    bracketSameLine: false,
-    arrowParens,
-    endOfLine: "lf",
-    proseWrap: "preserve",
-    htmlWhitespaceSensitivity: "css",
-    singleAttributePerLine: false
-  };
+    logger.newline();
+  }
+}
+function getCategoryValues(config, category) {
+  switch (category) {
+    case "commands":
+      return config.commands || {};
+    case "paths":
+      return config.paths || {};
+    case "targets":
+    case "performance":
+      return config.targets || {};
+    case "tracking":
+      return config.tracking || {};
+    case "techStack":
+      return config.techStack || {};
+    case "environment":
+      return config.environment || {};
+    case "brand":
+      return config.brand || {};
+    default:
+      return {};
+  }
 }
-async function promptCommitlintOptions() {
-  logger.newline();
-  logger.subtitle("Commitlint Options");
-  const useDefaults = await confirm({
-    message: "Use conventional commits defaults?",
-    default: true
+async function promptEditConfig(config, context) {
+  const categories = Object.entries(CATEGORY_INFO).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
+  const categoryToEdit = await select({
+    message: "Which category would you like to edit?",
+    choices: [
+      ...categories.map((cat) => ({
+        name: CATEGORY_INFO[cat].name,
+        value: cat
+      })),
+      { name: "Done editing", value: "done" }
+    ]
   });
-  if (useDefaults) {
-    const huskyIntegration2 = await confirm({
-      message: "Enable Husky integration (git hooks)?",
-      default: true
-    });
-    return {
-      ...DEFAULT_COMMITLINT_OPTIONS,
-      huskyIntegration: huskyIntegration2
-    };
+  if (categoryToEdit === "done") {
+    return config;
   }
-  const typesInput = await input({
-    message: "Commit types (comma-separated):",
-    default: DEFAULT_COMMITLINT_OPTIONS.types.join(", ")
-  });
-  const types = typesInput.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
-  const scopesInput = await input({
-    message: "Allowed scopes (comma-separated, empty for any):",
-    default: ""
-  });
-  const scopes = scopesInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  const headerMaxLengthStr = await input({
-    message: "Maximum header length:",
-    default: String(DEFAULT_COMMITLINT_OPTIONS.headerMaxLength),
-    validate: (v) => {
-      const num = Number(v);
-      if (Number.isNaN(num) || num < 20 || num > 200) return "Enter a number between 20 and 200";
-      return true;
-    }
-  });
-  const headerMaxLength = Number(headerMaxLengthStr);
-  const scopeRequired = await confirm({
-    message: "Require scope in commit messages?",
+  const editedCategory = await promptCategory(categoryToEdit, context, false);
+  const merged = { ...config };
+  switch (categoryToEdit) {
+    case "commands":
+      merged.commands = { ...config.commands, ...editedCategory.commands };
+      break;
+    case "paths":
+      merged.paths = { ...config.paths, ...editedCategory.paths };
+      break;
+    case "targets":
+    case "performance":
+      merged.targets = { ...config.targets, ...editedCategory.targets };
+      break;
+    case "tracking":
+      merged.tracking = { ...config.tracking, ...editedCategory.tracking };
+      break;
+    case "techStack":
+      merged.techStack = { ...config.techStack, ...editedCategory.techStack };
+      break;
+    case "environment":
+      merged.environment = { ...config.environment, ...editedCategory.environment };
+      break;
+    case "brand":
+      merged.brand = { ...config.brand, ...editedCategory.brand };
+      break;
+  }
+  const editMore = await confirm({
+    message: "Edit another category?",
     default: false
   });
-  const huskyIntegration = await confirm({
-    message: "Enable Husky integration (git hooks)?",
-    default: true
-  });
-  return {
-    extends: ["@commitlint/config-conventional"],
-    types,
-    scopes,
-    headerMaxLength,
-    scopeRequired,
-    bodyRequired: false,
-    bodyMaxLineLength: 100,
-    huskyIntegration
-  };
+  if (editMore) {
+    return promptEditConfig(merged, context);
+  }
+  return merged;
 }
-
-// src/cli/prompts/template-config.ts
-init_esm_shims();
-var CATEGORY_INFO = {
-  commands: { name: "CLI Commands", order: 1 },
-  paths: { name: "Directory Paths", order: 2 },
-  targets: { name: "Quality Targets", order: 3 },
-  tracking: { name: "Issue Tracking", order: 4 },
-  techStack: { name: "Technology Stack", order: 5 },
-  performance: { name: "Performance Targets", order: 6 },
-  environment: { name: "Environment Variables", order: 7 },
-  brand: { name: "Brand Identity", order: 8 }
-};
-async function promptSetupMode() {
-  const mode = await select({
-    message: "Configuration mode:",
-    choices: [
-      {
-        name: "Quick Setup (recommended)",
-        value: "quick",
-        description: "Auto-detect values, confirm all at once"
-      },
-      {
-        name: "Guided Setup",
-        value: "guided",
-        description: "Step through each category"
-      },
-      {
-        name: "Advanced Setup",
-        value: "advanced",
-        description: "Configure all options individually"
-      }
-    ],
-    default: "quick"
-  });
-  return mode;
+async function promptCategory(category, context, requiredOnly) {
+  const config = {
+    commands: {},
+    paths: {},
+    targets: {},
+    tracking: {},
+    techStack: {},
+    environment: {},
+    brand: {}
+  };
+  logger.subtitle(CATEGORY_INFO[category].name);
+  let placeholders = getPlaceholdersByCategory(category);
+  if (requiredOnly) {
+    placeholders = placeholders.filter((p) => p.required);
+  }
+  const updatedContext = { ...context };
+  for (const placeholder of placeholders) {
+    const value = await promptPlaceholder(placeholder, updatedContext);
+    if (value) {
+      setConfigValue(config, placeholder, value);
+      updatedContext.values[placeholder.key] = value;
+    }
+  }
+  return config;
 }
-async function buildConfigContext(projectPath) {
-  const context = {
-    projectPath,
-    values: {}
+async function promptGuidedSetup(context, requiredOnly) {
+  const config = {
+    commands: {},
+    paths: {},
+    targets: {},
+    tracking: {},
+    techStack: {},
+    environment: {},
+    brand: {}
   };
-  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 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.packageManager = "pnpm";
-    } else if (await fileExists(path8.join(projectPath, "yarn.lock"))) {
-      context.packageManager = "yarn";
-    } else if (await fileExists(path8.join(projectPath, "bun.lockb"))) {
-      context.packageManager = "bun";
-    } else {
-      context.packageManager = "npm";
+  const categories = Object.entries(CATEGORY_INFO).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
+  const updatedContext = { ...context };
+  for (const category of categories) {
+    const placeholders = getPlaceholdersByCategory(category);
+    const relevantPlaceholders = requiredOnly ? placeholders.filter((p) => p.required) : placeholders;
+    if (relevantPlaceholders.length === 0) continue;
+    const configureCategory = await confirm({
+      message: `Configure ${CATEGORY_INFO[category].name}? (${relevantPlaceholders.length} options)`,
+      default: true
+    });
+    if (!configureCategory) continue;
+    const categoryConfig = await promptCategory(category, updatedContext, requiredOnly);
+    switch (category) {
+      case "commands":
+        config.commands = { ...config.commands, ...categoryConfig.commands };
+        break;
+      case "paths":
+        config.paths = { ...config.paths, ...categoryConfig.paths };
+        break;
+      case "targets":
+      case "performance":
+        config.targets = { ...config.targets, ...categoryConfig.targets };
+        break;
+      case "tracking":
+        config.tracking = { ...config.tracking, ...categoryConfig.tracking };
+        break;
+      case "techStack":
+        config.techStack = { ...config.techStack, ...categoryConfig.techStack };
+        break;
+      case "environment":
+        config.environment = { ...config.environment, ...categoryConfig.environment };
+        break;
+      case "brand":
+        config.brand = { ...config.brand, ...categoryConfig.brand };
+        break;
     }
-    context.isGitRepo = await fileExists(path8.join(projectPath, ".git"));
-    if (context.isGitRepo) {
-      try {
-        const { execSync } = await import("child_process");
-        const remotes = execSync("git remote -v", {
-          cwd: projectPath,
-          encoding: "utf-8"
-        });
-        context.hasGitHubRemote = remotes.includes("github.com");
-      } catch {
-        context.hasGitHubRemote = false;
+    for (const [key, value] of Object.entries(getCategoryValues(categoryConfig, category))) {
+      if (value !== void 0) {
+        updatedContext.values[key.toUpperCase()] = String(value);
       }
     }
-  } catch {
   }
-  return context;
+  return config;
+}
+async function promptAdvancedSetup(context) {
+  return promptGuidedSetup(context, false);
+}
+async function confirmTemplateConfig(config, context) {
+  logger.newline();
+  logger.subtitle("Configuration Summary");
+  displayDetectedConfig(config, context);
+  return confirm({
+    message: "Apply this configuration?",
+    default: true
+  });
+}
+async function promptSaveGlobalDefaults(config) {
+  const save = await confirm({
+    message: "Save these values as global defaults for future projects?",
+    default: false
+  });
+  if (save) {
+    await updateGlobalDefaults(config);
+    logger.success("Global defaults saved to ~/.claude/defaults.json");
+  }
+  return save;
 }
-async function fileExists(filePath) {
-  try {
-    const fs6 = await import("fs/promises");
-    await fs6.access(filePath);
-    return true;
-  } catch {
+
+// src/lib/wizard/init-steps.ts
+function createResult(value, navigation = "next") {
+  return {
+    value,
+    navigation,
+    wasModified: true
+  };
+}
+async function promptBackOption(stepIndex, stepName) {
+  if (stepIndex === 0) {
     return false;
   }
+  const result = await select({
+    message: `${stepName}`,
+    choices: [
+      {
+        name: `${colors.muted("\u2190")} Back to previous step`,
+        value: BACK_OPTION_VALUE,
+        description: "Return to the previous step"
+      },
+      {
+        name: "Continue with this step",
+        value: "continue",
+        description: "Proceed to configure this section"
+      }
+    ],
+    default: "continue"
+  });
+  return result === BACK_OPTION_VALUE;
 }
-async function promptPlaceholder(placeholder, context, detectedValue) {
-  const defaultValue = detectedValue || computeDefaultValue(placeholder, context) || "";
-  switch (placeholder.inputType) {
-    case "select": {
-      if (!placeholder.choices || placeholder.choices.length === 0) {
-        return input({
-          message: `${placeholder.label}:`,
-          default: defaultValue
-        });
+function createProjectInfoStep() {
+  return {
+    metadata: {
+      id: "projectInfo",
+      name: "Project Information",
+      description: "Basic project identification and metadata",
+      required: true
+    },
+    computeDefaults: (ctx) => ctx.projectInfo,
+    execute: async (_ctx, defaults) => {
+      const value = await promptProjectInfo({ defaults });
+      const confirmed = await confirmProjectInfo(value);
+      if (!confirmed) {
+        return createResult(value, "back");
       }
-      const choices = placeholder.choices.map((c) => ({
-        name: c.name,
-        value: c.value,
-        description: c.description
-      }));
-      return select({
-        message: `${placeholder.label}:`,
-        choices,
-        default: defaultValue || choices[0].value
+      return createResult(value, "next");
+    }
+  };
+}
+function createPreferencesStep() {
+  return {
+    metadata: {
+      id: "preferences",
+      name: "Preferences",
+      description: "Language and package manager settings",
+      required: true
+    },
+    computeDefaults: (ctx) => ctx.preferences,
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(1, "Configure preferences or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptPreferences({
+        detectedPackageManager: ctx.detection.packageManager,
+        defaults
       });
+      return createResult(value, "next");
     }
-    case "number": {
-      const result = await input({
-        message: `${placeholder.label}:`,
-        default: defaultValue,
-        validate: (value) => {
-          if (placeholder.validate) {
-            return placeholder.validate(value, context);
-          }
-          const num = Number(value);
-          if (Number.isNaN(num)) {
-            return "Please enter a valid number";
-          }
-          return true;
-        }
+  };
+}
+function createScaffoldStep() {
+  return {
+    metadata: {
+      id: "scaffoldOptions",
+      name: "Scaffold Options",
+      description: "Project structure and scaffolding type",
+      required: true
+    },
+    computeDefaults: (ctx) => ctx.scaffoldOptions,
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(2, "Configure scaffold or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptScaffoldOptions({
+        existingProject: ctx.detection.detected,
+        detectedType: ctx.detection.projectType,
+        detectedPackageManager: ctx.detection.packageManager
       });
-      return result;
+      return createResult(value, "next");
     }
-    case "path": {
-      return input({
-        message: `${placeholder.label}:`,
-        default: defaultValue,
-        validate: (value) => {
-          if (placeholder.required && !value.trim()) {
-            return "This path is required";
-          }
-          if (placeholder.validate) {
-            return placeholder.validate(value, context);
+  };
+}
+function createBundleSelectionStep() {
+  return {
+    metadata: {
+      id: "bundleSelection",
+      name: "Module Bundles",
+      description: "Select pre-configured module bundles",
+      required: true
+    },
+    computeDefaults: (ctx) => ctx.bundleSelection,
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(3, "Select bundles or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      if (ctx.detection.suggestedBundles?.length) {
+        logger.info(
+          colors.muted(
+            `Suggested bundles based on your project: ${ctx.detection.suggestedBundles.join(", ")}`
+          )
+        );
+      }
+      const mode = await promptBundleMode();
+      const result = {
+        selectedBundles: defaults?.selectedBundles || [],
+        additionalModules: defaults?.additionalModules || {
+          agents: [],
+          skills: [],
+          commands: [],
+          docs: []
+        }
+      };
+      if (mode === "bundles" || mode === "both") {
+        result.selectedBundles = await promptQuickBundleSelection();
+        if (result.selectedBundles.length > 0) {
+          showBundlesSummary(result.selectedBundles);
+        }
+      }
+      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 preselected = mode === "both" ? preselectedFromBundles[category] : [];
+            const categoryResult = await selectItemsFromCategory(category, ctx.registry[category], {
+              preselected,
+              showDescriptions: true
+            });
+            if (mode === "both") {
+              result.additionalModules[category] = categoryResult.selectedItems.filter(
+                (id) => !preselected.includes(id)
+              );
+            } else {
+              result.additionalModules[category] = categoryResult.selectedItems;
+            }
           }
-          return true;
         }
+      }
+      return createResult(result, "next");
+    }
+  };
+}
+function createHookConfigStep() {
+  return {
+    metadata: {
+      id: "hookConfig",
+      name: "Notification Hooks",
+      description: "Configure notification and sound hooks",
+      required: false
+    },
+    computeDefaults: (ctx) => {
+      if (ctx.hookConfig) return ctx.hookConfig;
+      const hasTesting = ctx.bundleSelection?.selectedBundles.some((id) => id.includes("testing"));
+      return hasTesting ? { enabled: true } : { enabled: false };
+    },
+    execute: async (_ctx, defaults) => {
+      const goBack = await promptBackOption(4, "Configure hooks or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptHookConfig({ defaults });
+      return createResult(value, "next");
+    }
+  };
+}
+function createMcpConfigStep() {
+  return {
+    metadata: {
+      id: "mcpConfig",
+      name: "MCP Servers",
+      description: "Configure Model Context Protocol servers",
+      required: false
+    },
+    computeDefaults: (ctx) => ctx.mcpConfig,
+    execute: async (_ctx, defaults) => {
+      const goBack = await promptBackOption(5, "Configure MCP servers or go back?");
+      if (goBack) {
+        return createResult(
+          defaults,
+          "back"
+        );
+      }
+      const result = await promptMcpConfig();
+      return createResult(result, "next");
+    }
+  };
+}
+function createPermissionsStep() {
+  return {
+    metadata: {
+      id: "permissionsConfig",
+      name: "Permissions",
+      description: "Configure file, git, and bash permissions",
+      required: true
+    },
+    computeDefaults: (ctx) => ctx.permissionsConfig,
+    execute: async (_ctx, defaults) => {
+      const goBack = await promptBackOption(6, "Configure permissions or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptPermissionsConfig();
+      return createResult(value, "next");
+    }
+  };
+}
+function createCodeStyleStep() {
+  return {
+    metadata: {
+      id: "codeStyleConfig",
+      name: "Code Style",
+      description: "Configure EditorConfig, Biome, Prettier, Commitlint",
+      required: false
+    },
+    computeDefaults: (ctx) => ctx.codeStyleConfig,
+    execute: async (_ctx, defaults) => {
+      const goBack = await promptBackOption(7, "Configure code style or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptCodeStyleConfig({ defaults });
+      return createResult(value, "next");
+    }
+  };
+}
+function createCICDStep() {
+  return {
+    metadata: {
+      id: "cicdConfig",
+      name: "CI/CD",
+      description: "Configure GitHub Actions workflows",
+      required: false
+    },
+    computeDefaults: (ctx) => ctx.cicdConfig,
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(8, "Configure CI/CD or go back?");
+      if (goBack) {
+        return createResult(defaults, "back");
+      }
+      const value = await promptCICDConfig({
+        packageManager: ctx.preferences?.packageManager,
+        defaults
       });
+      return createResult(value, "next");
     }
-    case "envVar": {
-      return input({
-        message: `${placeholder.label}:`,
-        default: defaultValue,
-        validate: (value) => {
-          if (placeholder.required && !value.trim()) {
-            return "This environment variable is required";
-          }
-          if (value && !/^[A-Z][A-Z0-9_]*$/.test(value)) {
-            return "Environment variable should be UPPER_SNAKE_CASE";
-          }
-          return true;
-        }
+  };
+}
+function createFolderPreferencesStep() {
+  return {
+    metadata: {
+      id: "folderPreferences",
+      name: "Folder Structure",
+      description: "Configure test, planning, and documentation locations",
+      required: false,
+      dependsOn: ["bundleSelection"]
+    },
+    computeDefaults: (ctx) => ctx.folderPreferences ?? null,
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(9, "Configure folder preferences or go back?");
+      if (goBack) {
+        return createResult(defaults ?? null, "back");
+      }
+      const value = await promptQuickFolderPreferences({
+        selectedBundles: ctx.bundleSelection?.selectedBundles || [],
+        technologies: ctx.detection.detectedTechnologies || []
       });
+      return createResult(value, "next");
     }
-    default: {
-      return input({
-        message: `${placeholder.label}:`,
-        default: defaultValue,
-        validate: (value) => {
-          if (placeholder.required && !value.trim()) {
-            return `${placeholder.label} is required`;
-          }
-          if (placeholder.validate) {
-            return placeholder.validate(value, context);
-          }
-          return true;
-        }
+  };
+}
+function createTemplateConfigStep() {
+  return {
+    metadata: {
+      id: "templateConfig",
+      name: "Template Placeholders",
+      description: "Configure template placeholder values",
+      required: false
+    },
+    computeDefaults: (ctx) => ctx.templateConfig ?? {},
+    execute: async (ctx, defaults) => {
+      const goBack = await promptBackOption(10, "Configure templates or go back?");
+      if (goBack) {
+        return createResult(defaults ?? {}, "back");
+      }
+      logger.newline();
+      const configContext = await buildConfigContext(ctx.projectPath);
+      const value = await promptTemplateConfig({
+        context: configContext,
+        mode: "quick"
       });
+      return createResult(value ?? {}, "next");
+    }
+  };
+}
+function createInitWizardConfig(projectPath, detection, registry) {
+  void projectPath;
+  void detection;
+  void registry;
+  const steps = [
+    {
+      id: "projectInfo",
+      definition: createProjectInfoStep()
+    },
+    {
+      id: "preferences",
+      definition: createPreferencesStep()
+    },
+    {
+      id: "scaffoldOptions",
+      definition: createScaffoldStep()
+    },
+    {
+      id: "bundleSelection",
+      definition: createBundleSelectionStep()
+    },
+    {
+      id: "hookConfig",
+      definition: createHookConfigStep()
+    },
+    {
+      id: "mcpConfig",
+      definition: createMcpConfigStep()
+    },
+    {
+      id: "permissionsConfig",
+      definition: createPermissionsStep()
+    },
+    {
+      id: "codeStyleConfig",
+      definition: createCodeStyleStep()
+    },
+    {
+      id: "cicdConfig",
+      definition: createCICDStep()
+    },
+    {
+      id: "folderPreferences",
+      definition: createFolderPreferencesStep()
+    },
+    {
+      id: "templateConfig",
+      definition: createTemplateConfigStep()
+    }
+  ];
+  return {
+    id: "init-wizard",
+    title: "Claude Code Configuration",
+    allowSkip: true,
+    showProgress: true,
+    steps
+  };
+}
+
+// src/cli/prompts/index.ts
+init_esm_shims();
+
+// src/cli/prompts/update.ts
+init_esm_shims();
+async function promptUpdateAction() {
+  logger.subtitle("Update Options");
+  return select({
+    message: "What would you like to update?",
+    choices: [
+      {
+        name: "Check for updates",
+        value: "check",
+        description: "Show what has changed without modifying files"
+      },
+      {
+        name: "Update modules only",
+        value: "modules",
+        description: "Update agents, skills, commands, docs"
+      },
+      {
+        name: "Reconfigure settings",
+        value: "config",
+        description: "Re-run configuration for MCP, hooks, preferences"
+      },
+      {
+        name: "Full update",
+        value: "all",
+        description: "Update everything"
+      },
+      {
+        name: "Cancel",
+        value: "cancel"
+      }
+    ],
+    default: "check"
+  });
+}
+function showUpdateReport(updates) {
+  logger.newline();
+  logger.title("Update Report");
+  if (updates.new.length === 0 && updates.updated.length === 0 && updates.deprecated.length === 0) {
+    logger.success("Everything is up to date!");
+    return;
+  }
+  if (updates.new.length > 0) {
+    logger.newline();
+    logger.info(colors.bold(`\u271A New modules available (${updates.new.length}):`));
+    for (const mod of updates.new) {
+      logger.item(`${mod.category}: ${colors.primary(mod.name)}`);
     }
   }
-}
-function computeAllDefaults(context, globalDefaults) {
-  const config = {
-    commands: {},
-    paths: {},
-    targets: {},
-    tracking: {},
-    techStack: {},
-    environment: {},
-    brand: {}
-  };
-  for (const placeholder of TEMPLATE_PLACEHOLDERS) {
-    const defaultValue = computeDefaultValue(placeholder, context);
-    if (defaultValue) {
-      setConfigValue(config, placeholder, defaultValue);
+  if (updates.updated.length > 0) {
+    logger.newline();
+    logger.info(colors.bold(`\u21BB Updated modules (${updates.updated.length}):`));
+    for (const mod of updates.updated) {
+      const conflict = mod.hasLocalChanges ? colors.warning(" (local changes)") : "";
+      logger.item(`${mod.category}: ${colors.primary(mod.name)}${conflict}`);
     }
   }
-  if (globalDefaults) {
-    return mergeWithGlobalDefaults(config, globalDefaults);
-  }
-  return config;
-}
-function setConfigValue(config, placeholder, value) {
-  const key = placeholderKeyToConfigKey(placeholder.key, placeholder.category);
-  switch (placeholder.category) {
-    case "commands":
-      if (!config.commands) config.commands = {};
-      config.commands[key] = value;
-      break;
-    case "paths":
-      if (!config.paths) config.paths = {};
-      config.paths[key] = value;
-      break;
-    case "targets":
-    case "performance": {
-      if (!config.targets) config.targets = {};
-      const numValue = Number(value);
-      if (!Number.isNaN(numValue)) {
-        config.targets[key] = numValue;
-      } else {
-        config.targets[key] = value;
-      }
-      break;
+  if (updates.deprecated.length > 0) {
+    logger.newline();
+    logger.info(colors.bold(`\u2717 Deprecated modules (${updates.deprecated.length}):`));
+    for (const mod of updates.deprecated) {
+      logger.item(`${mod.category}: ${colors.muted(mod.name)}`);
     }
-    case "tracking":
-      if (!config.tracking) config.tracking = {};
-      config.tracking[key] = key.endsWith("Days") ? Number(value) : value;
-      break;
-    case "techStack":
-      if (!config.techStack) config.techStack = {};
-      config.techStack[key] = value;
-      break;
-    case "environment":
-      if (!config.environment) config.environment = {};
-      config.environment[key] = value;
-      break;
-    case "brand":
-      if (!config.brand) config.brand = {};
-      config.brand[key] = value;
-      break;
   }
-}
-function placeholderKeyToConfigKey(key, category) {
-  let cleanKey = key;
-  if (category === "commands" && key.endsWith("_COMMAND")) {
-    cleanKey = key.slice(0, -8);
-  } else if (category === "environment" && key.endsWith("_ENV")) {
-    cleanKey = key.slice(0, -4);
-  } else if (key.endsWith("_TARGET")) {
-    cleanKey = key.slice(0, -7);
+  if (updates.conflicts.length > 0) {
+    logger.newline();
+    logger.warn(`\u26A0 Modules with conflicts (${updates.conflicts.length}):`);
+    for (const mod of updates.conflicts) {
+      logger.item(`${mod.category}: ${colors.warning(mod.name)} - has local modifications`);
+    }
   }
-  return cleanKey.toLowerCase().replace(/_([a-z])/g, (_, char) => char.toUpperCase());
 }
-async function promptTemplateConfig(options) {
-  const { context, mode = "quick", category, requiredOnly = false } = options;
-  logger.section("Template Configuration", "\u{1F4DD}");
-  logger.newline();
-  logger.info("This step personalizes all Claude Code configuration files for YOUR project.");
-  logger.info("Your answers will be used to:");
-  logger.newline();
-  logger.item("Replace {{PLACEHOLDERS}} in agents, commands, and skills");
-  logger.item("Configure CLAUDE.md with your tech stack and commands");
-  logger.item("Set up quality targets (coverage, performance, accessibility)");
-  logger.item("Customize code examples to match your project structure");
-  logger.newline();
-  logger.info("Accurate configuration means better AI assistance tailored to your codebase!");
+async function promptNewModules(modules) {
+  if (modules.length === 0) return [];
   logger.newline();
-  const hasDefaults = await hasGlobalDefaults();
-  const globalDefaults = hasDefaults ? await getGlobalTemplateConfig() : void 0;
-  if (mode === "quick") {
-    return promptQuickSetup(context, globalDefaults);
-  }
-  if (category) {
-    return promptCategory(category, context, requiredOnly);
-  }
-  if (mode === "guided") {
-    return promptGuidedSetup(context, requiredOnly);
-  }
-  return promptAdvancedSetup(context);
+  const choices = modules.map((mod) => ({
+    name: `${mod.category}: ${mod.name}`,
+    value: mod.id,
+    checked: false
+  }));
+  return checkbox({
+    message: "Select new modules to install:",
+    choices
+  });
 }
-async function promptQuickSetup(context, globalDefaults) {
-  logger.info("Auto-detecting configuration from project...");
+async function promptUpdatedModules(modules) {
+  if (modules.length === 0) return [];
   logger.newline();
-  const detected = computeAllDefaults(context, globalDefaults);
-  displayDetectedConfig(detected, context);
-  const wantEdit = await confirm({
-    message: "Would you like to modify any values?",
-    default: false
+  const choices = modules.map((mod) => ({
+    name: `${mod.category}: ${mod.name}${mod.hasLocalChanges ? " \u26A0\uFE0F" : ""}`,
+    value: mod.id,
+    checked: !mod.hasLocalChanges
+    // Don't check by default if has local changes
+  }));
+  return checkbox({
+    message: "Select modules to update:",
+    choices
   });
-  let finalConfig = detected;
-  if (wantEdit) {
-    finalConfig = await promptEditConfig(detected, context);
-  }
-  return finalConfig;
-}
-function displayDetectedConfig(config, _context) {
-  const categories = Object.entries(CATEGORY_INFO).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
-  for (const category of categories) {
-    const placeholders = getPlaceholdersByCategory(category);
-    if (placeholders.length === 0) continue;
-    const values = getCategoryValues(config, category);
-    if (Object.keys(values).length === 0) continue;
-    logger.subtitle(CATEGORY_INFO[category].name);
-    for (const [key, value] of Object.entries(values)) {
-      if (value !== void 0) {
-        const placeholder = TEMPLATE_PLACEHOLDERS.find(
-          (p) => placeholderKeyToConfigKey(p.key, p.category) === key
-        );
-        const label = placeholder?.label || key;
-        logger.keyValue(label, String(value));
-      }
-    }
-    logger.newline();
-  }
-}
-function getCategoryValues(config, category) {
-  switch (category) {
-    case "commands":
-      return config.commands || {};
-    case "paths":
-      return config.paths || {};
-    case "targets":
-    case "performance":
-      return config.targets || {};
-    case "tracking":
-      return config.tracking || {};
-    case "techStack":
-      return config.techStack || {};
-    case "environment":
-      return config.environment || {};
-    case "brand":
-      return config.brand || {};
-    default:
-      return {};
-  }
 }
-async function promptEditConfig(config, context) {
-  const categories = Object.entries(CATEGORY_INFO).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
-  const categoryToEdit = await select({
-    message: "Which category would you like to edit?",
+async function promptConflictResolution(module) {
+  logger.newline();
+  logger.warn(`Conflict: ${module.category}/${module.name} has local modifications`);
+  return select({
+    message: "How do you want to resolve this conflict?",
     choices: [
-      ...categories.map((cat) => ({
-        name: CATEGORY_INFO[cat].name,
-        value: cat
-      })),
-      { name: "Done editing", value: "done" }
-    ]
+      {
+        name: "Keep local version",
+        value: "keep",
+        description: "Do not update this module"
+      },
+      {
+        name: "Use updated version",
+        value: "update",
+        description: "Replace with new version (lose local changes)"
+      },
+      {
+        name: "Show diff",
+        value: "diff",
+        description: "See what changed before deciding"
+      }
+    ],
+    default: "keep"
   });
-  if (categoryToEdit === "done") {
-    return config;
-  }
-  const editedCategory = await promptCategory(categoryToEdit, context, false);
-  const merged = { ...config };
-  switch (categoryToEdit) {
-    case "commands":
-      merged.commands = { ...config.commands, ...editedCategory.commands };
-      break;
-    case "paths":
-      merged.paths = { ...config.paths, ...editedCategory.paths };
-      break;
-    case "targets":
-    case "performance":
-      merged.targets = { ...config.targets, ...editedCategory.targets };
-      break;
-    case "tracking":
-      merged.tracking = { ...config.tracking, ...editedCategory.tracking };
-      break;
-    case "techStack":
-      merged.techStack = { ...config.techStack, ...editedCategory.techStack };
-      break;
-    case "environment":
-      merged.environment = { ...config.environment, ...editedCategory.environment };
-      break;
-    case "brand":
-      merged.brand = { ...config.brand, ...editedCategory.brand };
-      break;
-  }
-  const editMore = await confirm({
-    message: "Edit another category?",
-    default: false
+}
+async function promptReconfigureOptions() {
+  logger.newline();
+  return checkbox({
+    message: "What would you like to reconfigure?",
+    choices: [
+      { name: "MCP servers", value: "mcp", checked: false },
+      { name: "Hooks", value: "hooks", checked: false },
+      { name: "Preferences (language, co-author)", value: "preferences", checked: false },
+      { name: "Permissions", value: "permissions", checked: false },
+      { name: "Add/remove modules", value: "modules", checked: false }
+    ]
   });
-  if (editMore) {
-    return promptEditConfig(merged, context);
-  }
-  return merged;
 }
-async function promptCategory(category, context, requiredOnly) {
-  const config = {
-    commands: {},
-    paths: {},
-    targets: {},
-    tracking: {},
-    techStack: {},
-    environment: {},
-    brand: {}
-  };
-  logger.subtitle(CATEGORY_INFO[category].name);
-  let placeholders = getPlaceholdersByCategory(category);
-  if (requiredOnly) {
-    placeholders = placeholders.filter((p) => p.required);
+
+// src/cli/prompts/confirm.ts
+init_esm_shims();
+async function promptExistingProjectAction() {
+  return select({
+    message: "Existing .claude/ folder detected. What would you like to do?",
+    choices: [
+      {
+        name: "Skip (keep existing)",
+        value: "skip",
+        description: "Do not modify existing configuration"
+      },
+      {
+        name: "Overwrite",
+        value: "overwrite",
+        description: "Replace existing configuration"
+      },
+      {
+        name: "Merge",
+        value: "merge",
+        description: "Add new items, keep existing"
+      }
+    ],
+    default: "skip"
+  });
+}
+function showFinalSummary(config) {
+  logger.newline();
+  logger.title("Configuration Summary");
+  logger.subtitle("Project");
+  logger.keyValue("Name", config.project.name);
+  logger.keyValue("GitHub", `${config.project.org}/${config.project.repo}`);
+  if (config.project.domain) {
+    logger.keyValue("Domain", config.project.domain);
   }
-  const updatedContext = { ...context };
-  for (const placeholder of placeholders) {
-    const value = await promptPlaceholder(placeholder, updatedContext);
-    if (value) {
-      setConfigValue(config, placeholder, value);
-      updatedContext.values[placeholder.key] = value;
+  logger.newline();
+  logger.subtitle("Preferences");
+  logger.keyValue("Language", config.preferences.language === "en" ? "English" : "Espa\xF1ol");
+  logger.keyValue("Co-author", config.preferences.includeCoAuthor ? "Yes" : "No");
+  logger.newline();
+  logger.subtitle("Modules");
+  const moduleCategories = ["agents", "skills", "commands", "docs"];
+  for (const category of moduleCategories) {
+    const selected = config.modules[category].selected;
+    if (selected.length > 0) {
+      logger.keyValue(capitalize2(category), `${selected.length} selected`);
+      logger.note(selected.join(", "));
     }
   }
-  return config;
-}
-async function promptGuidedSetup(context, requiredOnly) {
-  const config = {
-    commands: {},
-    paths: {},
-    targets: {},
-    tracking: {},
-    techStack: {},
-    environment: {},
-    brand: {}
-  };
-  const categories = Object.entries(CATEGORY_INFO).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
-  const updatedContext = { ...context };
-  for (const category of categories) {
-    const placeholders = getPlaceholdersByCategory(category);
-    const relevantPlaceholders = requiredOnly ? placeholders.filter((p) => p.required) : placeholders;
-    if (relevantPlaceholders.length === 0) continue;
-    const configureCategory = await confirm({
-      message: `Configure ${CATEGORY_INFO[category].name}? (${relevantPlaceholders.length} options)`,
-      default: true
-    });
-    if (!configureCategory) continue;
-    const categoryConfig = await promptCategory(category, updatedContext, requiredOnly);
-    switch (category) {
-      case "commands":
-        config.commands = { ...config.commands, ...categoryConfig.commands };
-        break;
-      case "paths":
-        config.paths = { ...config.paths, ...categoryConfig.paths };
-        break;
-      case "targets":
-      case "performance":
-        config.targets = { ...config.targets, ...categoryConfig.targets };
-        break;
-      case "tracking":
-        config.tracking = { ...config.tracking, ...categoryConfig.tracking };
-        break;
-      case "techStack":
-        config.techStack = { ...config.techStack, ...categoryConfig.techStack };
-        break;
-      case "environment":
-        config.environment = { ...config.environment, ...categoryConfig.environment };
-        break;
-      case "brand":
-        config.brand = { ...config.brand, ...categoryConfig.brand };
-        break;
-    }
-    for (const [key, value] of Object.entries(getCategoryValues(categoryConfig, category))) {
-      if (value !== void 0) {
-        updatedContext.values[key.toUpperCase()] = String(value);
-      }
-    }
+  logger.newline();
+  logger.subtitle("Extras");
+  const extras = [];
+  if (config.extras.schemas) extras.push("schemas");
+  if (config.extras.scripts) extras.push("scripts");
+  if (config.extras.hooks.enabled) extras.push("hooks");
+  if (config.extras.sessions) extras.push("sessions");
+  logger.keyValue("Included", extras.join(", ") || "none");
+  if (config.extras.codeStyle?.enabled) {
+    const codeStyleTools = [];
+    if (config.extras.codeStyle.editorconfig) codeStyleTools.push("EditorConfig");
+    if (config.extras.codeStyle.commitlint) codeStyleTools.push("Commitlint");
+    if (config.extras.codeStyle.biome) codeStyleTools.push("Biome");
+    if (config.extras.codeStyle.prettier) codeStyleTools.push("Prettier");
+    logger.keyValue("Code Style", codeStyleTools.join(", "));
   }
-  return config;
-}
-async function promptAdvancedSetup(context) {
-  return promptGuidedSetup(context, false);
+  if (config.mcp.servers.length > 0) {
+    logger.newline();
+    logger.subtitle("MCP Servers");
+    logger.keyValue("Level", config.mcp.level);
+    logger.keyValue("Servers", config.mcp.servers.map((s) => s.serverId).join(", "));
+  }
+  logger.newline();
+  logger.subtitle("Scaffold");
+  logger.keyValue(
+    "Type",
+    config.scaffold.type === "claude-only" ? "Claude config only" : "Full project"
+  );
 }
-async function confirmTemplateConfig(config, context) {
+async function confirmFinalConfiguration(config) {
+  showFinalSummary(config);
   logger.newline();
-  logger.subtitle("Configuration Summary");
-  displayDetectedConfig(config, context);
   return confirm({
-    message: "Apply this configuration?",
+    message: "Proceed with this configuration?",
     default: true
   });
 }
-async function promptSaveGlobalDefaults(config) {
-  const save = await confirm({
-    message: "Save these values as global defaults for future projects?",
-    default: false
-  });
-  if (save) {
-    await updateGlobalDefaults(config);
-    logger.success("Global defaults saved to ~/.claude/defaults.json");
+function showPostInstallInstructions(config) {
+  logger.newline();
+  logger.title("Installation Complete!");
+  const steps = [];
+  if (config.scaffold.type === "full-project") {
+    steps.push("Review the generated project structure");
   }
-  return save;
+  steps.push("Review .claude/CLAUDE.md for agent instructions");
+  steps.push("Customize agents, commands, and skills as needed");
+  if (config.mcp.servers.length > 0) {
+    const mcpFile = config.mcp.level === "user" ? "~/.claude/settings.json" : ".claude/settings.local.json";
+    steps.push(`Configure MCP server credentials in ${mcpFile}`);
+  }
+  if (config.extras.hooks.enabled) {
+    steps.push("Review hook scripts in .claude/hooks/");
+    if (config.extras.hooks.notification?.audio) {
+      steps.push("Install Piper TTS for audio notifications (see docs)");
+    }
+  }
+  logger.instructions("Next Steps:", steps);
+  logger.subtitle("Useful Commands");
+  logger.raw("");
+  logger.raw(`  ${colors.primary("claude-config status")}     - Show current configuration`);
+  logger.raw(`  ${colors.primary("claude-config list")}       - List available modules`);
+  logger.raw(`  ${colors.primary("claude-config add")}        - Add a module`);
+  logger.raw(`  ${colors.primary("claude-config update")}     - Update configuration`);
+  logger.raw("");
+}
+function capitalize2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
 // src/cli/commands/init.ts
@@ -11186,52 +11852,65 @@ async function buildDefaultConfig(projectPath, detection, options) {
 async function buildInteractiveConfig(projectPath, detection, registry, options) {
   const projectName = await getProjectName(projectPath);
   const projectDesc = await getProjectDescription(projectPath);
-  const projectInfo = await promptProjectInfo({
-    defaults: {
-      name: projectName,
-      description: projectDesc || ""
+  const wizardConfig = createInitWizardConfig(
+    projectPath,
+    {
+      detected: detection.detected,
+      projectType: detection.projectType,
+      packageManager: detection.packageManager,
+      suggestedBundles: detection.suggestedBundles,
+      detectedTechnologies: detection.detectedTechnologies
+    },
+    registry
+  );
+  const initialContext = {
+    projectPath,
+    registry,
+    detection: {
+      detected: detection.detected,
+      projectType: detection.projectType,
+      packageManager: detection.packageManager,
+      suggestedBundles: detection.suggestedBundles,
+      detectedTechnologies: detection.detectedTechnologies
+    },
+    projectInfo: {
+      name: projectName || "",
+      description: projectDesc || "",
+      org: "",
+      repo: projectName?.toLowerCase().replace(/\s+/g, "-") || "",
+      entityType: "item",
+      entityTypePlural: "items"
     }
-  });
-  const confirmed = await confirmProjectInfo(projectInfo);
-  if (!confirmed) {
-    return buildInteractiveConfig(projectPath, detection, registry, options);
+  };
+  const wizardResult = await runWizard(
+    wizardConfig,
+    initialContext
+  );
+  if (wizardResult.cancelled) {
+    return null;
   }
-  const preferences = await promptPreferences({
-    detectedPackageManager: detection.packageManager
-  });
-  const scaffoldOptions = await promptScaffoldOptions({
-    existingProject: detection.detected,
-    detectedType: detection.projectType,
-    detectedPackageManager: detection.packageManager
-  });
-  const bundleSelection = await selectModulesWithBundles(registry, detection.suggestedBundles);
-  const hasPlanning = bundleSelection.selectedBundles.some((id) => id.includes("planning"));
-  const hasTesting = bundleSelection.selectedBundles.some((id) => id.includes("testing"));
-  const hookConfig = await promptHookConfig({
-    defaults: hasTesting ? { enabled: true } : void 0
-  });
+  showWizardSummary(wizardResult.state);
+  const {
+    projectInfo,
+    preferences,
+    scaffoldOptions,
+    bundleSelection,
+    hookConfig,
+    mcpConfig: mcpResult,
+    permissionsConfig,
+    codeStyleConfig,
+    cicdConfig,
+    folderPreferences,
+    templateConfig: templateConfigResult
+  } = wizardResult.values;
   let mcpConfig = { level: "project", servers: [] };
   let skippedMcpConfigs = [];
-  if (!options.noMcp) {
-    const mcpResult = await promptMcpConfig();
+  if (!options.noMcp && mcpResult) {
     mcpConfig = mcpResult.config;
     skippedMcpConfigs = mcpResult.skippedConfigs;
   }
-  const permissionsConfig = await promptPermissionsConfig();
-  const codeStyleConfig = await promptCodeStyleConfig();
-  const cicdConfig = await promptCICDConfig({
-    packageManager: preferences.packageManager
-  });
-  const folderPreferences = await promptQuickFolderPreferences({
-    selectedBundles: bundleSelection.selectedBundles,
-    technologies: detection.detectedTechnologies || []
-  });
-  logger.newline();
-  const configContext = await buildConfigContext(projectPath);
-  const templateConfigResult = await promptTemplateConfig({
-    context: configContext,
-    mode: "quick"
-  });
+  const hasPlanning = bundleSelection.selectedBundles.some((id) => id.includes("planning"));
+  const hasTesting = bundleSelection.selectedBundles.some((id) => id.includes("testing"));
   const resolvedModules = resolveBundles(bundleSelection.selectedBundles);
   const modules = {
     agents: [.../* @__PURE__ */ new Set([...resolvedModules.agents, ...bundleSelection.additionalModules.agents])],
@@ -11283,51 +11962,6 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
     cicdConfig
   };
 }
-async function selectModulesWithBundles(registry, suggestedBundles) {
-  const categories = ["agents", "skills", "commands", "docs"];
-  const mode = await promptBundleMode();
-  const result = {
-    selectedBundles: [],
-    additionalModules: {
-      agents: [],
-      skills: [],
-      commands: [],
-      docs: []
-    }
-  };
-  if (mode === "bundles" || mode === "both") {
-    if (suggestedBundles && suggestedBundles.length > 0) {
-      logger.newline();
-      logger.info(
-        colors.muted(`Suggested bundles based on your project: ${suggestedBundles.join(", ")}`)
-      );
-    }
-    result.selectedBundles = await promptQuickBundleSelection();
-    if (result.selectedBundles.length > 0) {
-      showBundlesSummary(result.selectedBundles);
-    }
-  }
-  if (mode === "individual" || mode === "both") {
-    const preselectedFromBundles = resolveBundles(result.selectedBundles);
-    logger.newline();
-    logger.subtitle("Individual Module Selection");
-    for (const category of categories) {
-      const preselected = mode === "both" ? preselectedFromBundles[category] : [];
-      const categoryResult = await selectItemsFromCategory(category, registry[category], {
-        preselected,
-        showDescriptions: true
-      });
-      if (mode === "both") {
-        result.additionalModules[category] = categoryResult.selectedItems.filter(
-          (id) => !preselected.includes(id)
-        );
-      } else {
-        result.additionalModules[category] = categoryResult.selectedItems;
-      }
-    }
-  }
-  return result;
-}
 async function executeInstallation(projectPath, config, registry, templatesPath, options, cicdConfig) {
   logger.newline();
   logger.title("Installing Configuration");