devtronic 1.0.0

package/dist/index.js

@@ -0,0 +1,4214 @@
+#!/usr/bin/env node
+import {
+  ADDONS,
+  BASE_SKILL_COUNT,
+  MANIFEST_DIR,
+  MARKETPLACE_NAME,
+  PLUGIN_DIR,
+  PLUGIN_NAME,
+  PRESETS,
+  calculateChecksum,
+  createManifestEntry,
+  ensureDir,
+  fileExists,
+  generateAgentsMdFromConfig,
+  generateClaudeMd,
+  generateMarketplaceJson,
+  generatePlugin,
+  generatePluginJson,
+  generateQualityCommands,
+  getAllFilesRecursive,
+  readFile,
+  readManifest,
+  writeFile,
+  writeManifest
+} from "./chunk-B6Q6YVID.js";
+
+// src/index.ts
+import { Command } from "commander";
+import * as p15 from "@clack/prompts";
+import chalk16 from "chalk";
+
+// src/commands/init.ts
+import { existsSync as existsSync5, chmodSync } from "fs";
+import { resolve as resolve2, join as join7, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import * as p3 from "@clack/prompts";
+import chalk4 from "chalk";
+
+// src/utils/git.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function hasGitRepo(targetDir) {
+  return existsSync(join(targetDir, ".git"));
+}
+
+// src/analyzers/architecture.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var CLEAN_ARCHITECTURE_DIRS = ["domain", "application", "infrastructure", "presentation"];
+var LAYERED_DIRS = ["routes", "controllers", "services", "repositories", "middleware"];
+var MVC_DIRS = ["models", "views", "controllers"];
+var FEATURE_DIRS = ["features", "modules"];
+var TEST_DIRS = ["tests", "test", "__tests__", "spec", "specs"];
+function detectArchitecture(targetDir) {
+  const srcDir = existsSync2(join2(targetDir, "src")) ? join2(targetDir, "src") : targetDir;
+  const cleanLayers = CLEAN_ARCHITECTURE_DIRS.filter(
+    (dir) => existsSync2(join2(srcDir, dir))
+  );
+  if (cleanLayers.length >= 2) {
+    return {
+      pattern: "clean",
+      layers: cleanLayers,
+      hasTests: hasTests(targetDir)
+    };
+  }
+  const layeredDirs = LAYERED_DIRS.filter(
+    (dir) => existsSync2(join2(srcDir, dir))
+  );
+  if (layeredDirs.length >= 2) {
+    return {
+      pattern: "layered",
+      layers: layeredDirs,
+      hasTests: hasTests(targetDir)
+    };
+  }
+  const mvcLayers = MVC_DIRS.filter(
+    (dir) => existsSync2(join2(srcDir, dir))
+  );
+  if (mvcLayers.length >= 2) {
+    return {
+      pattern: "mvc",
+      layers: mvcLayers,
+      hasTests: hasTests(targetDir)
+    };
+  }
+  const featureDirs = FEATURE_DIRS.filter(
+    (dir) => existsSync2(join2(srcDir, dir))
+  );
+  if (featureDirs.length > 0) {
+    return {
+      pattern: "feature-based",
+      layers: featureDirs,
+      hasTests: hasTests(targetDir)
+    };
+  }
+  return {
+    pattern: "flat",
+    layers: [],
+    hasTests: hasTests(targetDir)
+  };
+}
+function hasTests(targetDir) {
+  for (const dir of TEST_DIRS) {
+    if (existsSync2(join2(targetDir, dir))) {
+      return true;
+    }
+  }
+  const srcDir = join2(targetDir, "src");
+  if (existsSync2(srcDir)) {
+    for (const dir of TEST_DIRS) {
+      if (existsSync2(join2(srcDir, dir))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getArchitectureDescription(pattern) {
+  switch (pattern) {
+    case "clean":
+      return "Clean Architecture (Domain-driven)";
+    case "layered":
+      return "Layered (routes \u2192 services \u2192 data)";
+    case "mvc":
+      return "MVC (Model-View-Controller)";
+    case "feature-based":
+      return "Feature-based (Modular)";
+    case "flat":
+      return "Flat (No specific pattern detected)";
+    case "none":
+      return "None (no architecture rules)";
+  }
+}
+
+// src/analyzers/existingConfigs.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var CONFIG_LOCATIONS = [
+  {
+    ide: "claude-code",
+    paths: [".claude", "CLAUDE.md"]
+  },
+  {
+    ide: "cursor",
+    paths: [".cursor", ".cursorrules"]
+  },
+  {
+    ide: "antigravity",
+    paths: [".agents", ".agent", ".antigravity"]
+  },
+  {
+    ide: "github-copilot",
+    paths: [".github/copilot-instructions.md"]
+  },
+  {
+    ide: "opencode",
+    paths: ["opencode.json"]
+  }
+];
+function detectExistingConfigs(targetDir) {
+  const result = {
+    "claude-code": false,
+    cursor: false,
+    antigravity: false,
+    "github-copilot": false,
+    opencode: false
+  };
+  for (const config of CONFIG_LOCATIONS) {
+    for (const path of config.paths) {
+      if (existsSync3(join3(targetDir, path))) {
+        result[config.ide] = true;
+        break;
+      }
+    }
+  }
+  return result;
+}
+function getExistingConfigsList(configs) {
+  return Object.keys(configs).filter((ide) => configs[ide]);
+}
+
+// src/analyzers/project.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function detectPackageManager(targetDir) {
+  if (existsSync4(join4(targetDir, "bun.lockb"))) return "bun";
+  if (existsSync4(join4(targetDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(join4(targetDir, "yarn.lock"))) return "yarn";
+  if (existsSync4(join4(targetDir, "package-lock.json"))) return "npm";
+  if (existsSync4(join4(targetDir, "package.json"))) return "npm";
+  return null;
+}
+function readPackageJson(targetDir) {
+  const packageJsonPath = join4(targetDir, "package.json");
+  if (!fileExists(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFile(packageJsonPath));
+  } catch {
+    return null;
+  }
+}
+var FRAMEWORK_DETECTORS = [
+  // Meta-frameworks (highest priority)
+  { name: "nextjs", packages: ["next"], priority: 10 },
+  { name: "nuxt", packages: ["nuxt", "nuxt3"], priority: 10 },
+  { name: "sveltekit", packages: ["@sveltejs/kit"], priority: 10 },
+  { name: "remix", packages: ["@remix-run/react", "@remix-run/node"], priority: 10 },
+  { name: "astro", packages: ["astro"], priority: 10 },
+  // Backend frameworks
+  { name: "nestjs", packages: ["@nestjs/core"], priority: 9 },
+  { name: "fastify", packages: ["fastify"], priority: 8 },
+  { name: "hono", packages: ["hono"], priority: 8 },
+  { name: "express", packages: ["express"], priority: 7 },
+  // Frontend frameworks
+  { name: "vue", packages: ["vue"], priority: 5 },
+  { name: "svelte", packages: ["svelte"], priority: 5 },
+  { name: "react", packages: ["react"], priority: 4 }
+];
+function detectFramework(targetDir) {
+  const packageJson = readPackageJson(targetDir);
+  if (!packageJson) {
+    return { name: "unknown", version: null };
+  }
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  const sortedDetectors = [...FRAMEWORK_DETECTORS].sort(
+    (a, b) => b.priority - a.priority
+  );
+  for (const detector of sortedDetectors) {
+    for (const pkg of detector.packages) {
+      if (allDeps[pkg]) {
+        return {
+          name: detector.name,
+          version: allDeps[pkg].replace(/[\^~]/g, "")
+        };
+      }
+    }
+  }
+  return { name: "unknown", version: null };
+}
+function detectScripts(targetDir) {
+  const packageJson = readPackageJson(targetDir);
+  const scripts = packageJson?.scripts || {};
+  return {
+    typecheck: findScript(scripts, ["typecheck", "type-check", "types", "tsc"]),
+    lint: findScript(scripts, ["lint", "eslint"]),
+    test: findScript(scripts, ["test", "test:unit", "vitest", "jest"]),
+    build: findScript(scripts, ["build", "compile"]),
+    dev: findScript(scripts, ["dev", "start", "serve"])
+  };
+}
+function findScript(scripts, candidates) {
+  for (const candidate of candidates) {
+    if (scripts[candidate]) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function hasTypescript(targetDir) {
+  return fileExists(join4(targetDir, "tsconfig.json")) || fileExists(join4(targetDir, "tsconfig.base.json"));
+}
+
+// src/analyzers/stack.ts
+import { join as join5 } from "path";
+var TECH_DETECTORS = [
+  // State Management
+  { name: "Zustand", packages: ["zustand"], category: "stateManagement" },
+  { name: "Redux Toolkit", packages: ["@reduxjs/toolkit"], category: "stateManagement" },
+  { name: "Redux", packages: ["redux", "react-redux"], category: "stateManagement" },
+  { name: "Jotai", packages: ["jotai"], category: "stateManagement" },
+  { name: "Recoil", packages: ["recoil"], category: "stateManagement" },
+  { name: "MobX", packages: ["mobx", "mobx-react"], category: "stateManagement" },
+  { name: "Valtio", packages: ["valtio"], category: "stateManagement" },
+  { name: "XState", packages: ["xstate", "@xstate/react"], category: "stateManagement" },
+  // Data Fetching
+  { name: "React Query", packages: ["@tanstack/react-query", "react-query"], category: "dataFetching" },
+  { name: "SWR", packages: ["swr"], category: "dataFetching" },
+  { name: "Apollo Client", packages: ["@apollo/client"], category: "dataFetching" },
+  { name: "URQL", packages: ["urql", "@urql/core"], category: "dataFetching" },
+  { name: "tRPC", packages: ["@trpc/client", "@trpc/react-query"], category: "dataFetching" },
+  { name: "Axios", packages: ["axios"], category: "dataFetching" },
+  // ORM / Database
+  { name: "Prisma", packages: ["prisma", "@prisma/client"], category: "orm" },
+  { name: "Drizzle", packages: ["drizzle-orm"], category: "orm" },
+  { name: "TypeORM", packages: ["typeorm"], category: "orm" },
+  { name: "Mongoose", packages: ["mongoose"], category: "orm" },
+  { name: "Sequelize", packages: ["sequelize"], category: "orm" },
+  { name: "Kysely", packages: ["kysely"], category: "orm" },
+  // Testing
+  { name: "Vitest", packages: ["vitest"], category: "testing" },
+  { name: "Jest", packages: ["jest"], category: "testing" },
+  { name: "Playwright", packages: ["@playwright/test", "playwright"], category: "testing" },
+  { name: "Cypress", packages: ["cypress"], category: "testing" },
+  { name: "Testing Library", packages: ["@testing-library/react", "@testing-library/vue"], category: "testing" },
+  // UI Libraries
+  { name: "Tailwind CSS", packages: ["tailwindcss"], category: "ui" },
+  { name: "Chakra UI", packages: ["@chakra-ui/react"], category: "ui" },
+  { name: "Material UI", packages: ["@mui/material"], category: "ui" },
+  { name: "Ant Design", packages: ["antd"], category: "ui" },
+  { name: "Radix UI", packages: ["@radix-ui/react-dialog", "@radix-ui/themes"], category: "ui" },
+  { name: "shadcn/ui", packages: ["@radix-ui/react-slot"], category: "ui" },
+  // shadcn uses radix
+  { name: "Styled Components", packages: ["styled-components"], category: "ui" },
+  { name: "Emotion", packages: ["@emotion/react", "@emotion/styled"], category: "ui" },
+  // Validation
+  { name: "Zod", packages: ["zod"], category: "validation" },
+  { name: "Yup", packages: ["yup"], category: "validation" },
+  { name: "Valibot", packages: ["valibot"], category: "validation" },
+  { name: "io-ts", packages: ["io-ts"], category: "validation" },
+  // API
+  { name: "Express", packages: ["express"], category: "api" },
+  { name: "Fastify", packages: ["fastify"], category: "api" },
+  { name: "Hono", packages: ["hono"], category: "api" },
+  { name: "NestJS", packages: ["@nestjs/core"], category: "api" },
+  { name: "tRPC Server", packages: ["@trpc/server"], category: "api" },
+  { name: "GraphQL", packages: ["graphql", "@graphql-tools/schema"], category: "api" }
+];
+function readPackageJson2(targetDir) {
+  const packageJsonPath = join5(targetDir, "package.json");
+  if (!fileExists(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFile(packageJsonPath));
+  } catch {
+    return null;
+  }
+}
+function analyzeStack(targetDir) {
+  const result = {
+    stateManagement: [],
+    dataFetching: [],
+    orm: [],
+    testing: [],
+    ui: [],
+    validation: [],
+    api: []
+  };
+  const packageJson = readPackageJson2(targetDir);
+  if (!packageJson) {
+    return result;
+  }
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  for (const detector of TECH_DETECTORS) {
+    for (const pkg of detector.packages) {
+      if (allDeps[pkg]) {
+        const existing = result[detector.category].find((t) => t.name === detector.name);
+        if (!existing) {
+          result[detector.category].push({
+            name: detector.name,
+            package: pkg,
+            version: allDeps[pkg].replace(/[\^~]/g, ""),
+            confidence: "high"
+          });
+        }
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/analyzers/index.ts
+function analyzeProject(targetDir) {
+  const stackAnalysis = analyzeStack(targetDir);
+  const stack = {
+    stateManagement: stackAnalysis.stateManagement.map((t) => t.name),
+    dataFetching: stackAnalysis.dataFetching.map((t) => t.name),
+    orm: stackAnalysis.orm.map((t) => t.name),
+    testing: stackAnalysis.testing.map((t) => t.name),
+    ui: stackAnalysis.ui.map((t) => t.name),
+    validation: stackAnalysis.validation.map((t) => t.name),
+    api: stackAnalysis.api.map((t) => t.name)
+  };
+  return {
+    packageManager: detectPackageManager(targetDir),
+    framework: detectFramework(targetDir),
+    architecture: detectArchitecture(targetDir),
+    scripts: detectScripts(targetDir),
+    existingConfigs: detectExistingConfigs(targetDir),
+    stack,
+    hasTypescript: hasTypescript(targetDir),
+    hasGit: hasGitRepo(targetDir)
+  };
+}
+
+// src/prompts/init.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+var IDE_OPTIONS = [
+  { value: "claude-code", label: "Claude Code", hint: "CLI + Skills + Agents" },
+  { value: "cursor", label: "Cursor", hint: "Rules (.mdc)" },
+  { value: "opencode", label: "OpenCode", hint: "Rules (.md)" },
+  { value: "antigravity", label: "Google Antigravity", hint: "Rules (.md)" },
+  { value: "github-copilot", label: "GitHub Copilot", hint: "Instructions" }
+];
+async function promptForIDEs(existingConfigs) {
+  const existingList = getExistingConfigsList(existingConfigs);
+  const result = await p.multiselect({
+    message: "Which IDEs do you want to configure?",
+    options: IDE_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: opt.label,
+      hint: existingList.includes(opt.value) ? `${opt.hint} ${chalk.yellow("(exists)")}` : opt.hint
+    })),
+    initialValues: ["claude-code"],
+    required: true
+  });
+  return result;
+}
+async function promptForConflictResolution(ide) {
+  const result = await p.select({
+    message: `${ide} config already exists. How should we handle it?`,
+    options: [
+      {
+        value: "merge",
+        label: "Merge intelligently",
+        hint: "Add new sections, keep existing customizations"
+      },
+      {
+        value: "keep",
+        label: "Keep existing",
+        hint: "Skip files that already exist"
+      },
+      {
+        value: "replace",
+        label: "Replace",
+        hint: "Overwrite with template files"
+      }
+    ]
+  });
+  return result;
+}
+async function promptForThoughtsDir() {
+  return p.confirm({
+    message: "Create thoughts/ directory for AI documents?",
+    initialValue: true
+  });
+}
+async function promptForAgentsMd() {
+  return p.confirm({
+    message: "Create AGENTS.md (universal AI context file)?",
+    initialValue: true
+  });
+}
+async function promptForOrchestration() {
+  return p.confirm({
+    message: "Enable orchestration workflow? (briefing \u2192 execute-plan \u2192 recap \u2192 handoff)",
+    initialValue: false
+  });
+}
+
+// src/prompts/analysis.ts
+import * as p2 from "@clack/prompts";
+import chalk2 from "chalk";
+var ARCHITECTURE_OPTIONS = [
+  { value: "clean", label: "Clean + DDD", hint: "Strict boundaries, domain-driven \u2014 backend APIs, enterprise" },
+  { value: "layered", label: "Layered", hint: "Simple layers (routes \u2192 services \u2192 data) \u2014 backend, full-stack" },
+  { value: "feature-based", label: "Feature-based", hint: "Co-located modules, independent features \u2014 frontend apps" },
+  { value: "mvc", label: "MVC", hint: "Model-View-Controller \u2014 traditional backend, REST APIs" },
+  { value: "flat", label: "Minimal", hint: "Basic guidelines, no strict layers \u2014 prototypes, small projects" },
+  { value: "none", label: "None", hint: "No architecture rules \u2014 bring your own" }
+];
+var LAYER_OPTIONS = [
+  { value: "domain", label: "domain", hint: "Entities, Value Objects, Repository Interfaces" },
+  { value: "application", label: "application", hint: "Use Cases, DTOs, Application Services" },
+  { value: "infrastructure", label: "infrastructure", hint: "Repository Implementations, External Services" },
+  { value: "presentation", label: "presentation", hint: "UI Components, Controllers" },
+  { value: "ui", label: "ui", hint: "User Interface layer" },
+  { value: "api", label: "api", hint: "API routes and handlers" },
+  { value: "core", label: "core", hint: "Core business logic" },
+  { value: "shared", label: "shared", hint: "Shared utilities and types" },
+  { value: "features", label: "features", hint: "Feature modules" },
+  { value: "modules", label: "modules", hint: "Application modules" }
+];
+var STATE_MANAGEMENT_OPTIONS = [
+  { value: "Zustand", label: "Zustand" },
+  { value: "Redux Toolkit", label: "Redux Toolkit" },
+  { value: "Jotai", label: "Jotai" },
+  { value: "Recoil", label: "Recoil" },
+  { value: "MobX", label: "MobX" },
+  { value: "XState", label: "XState" },
+  { value: "Context API", label: "Context API" }
+];
+var DATA_FETCHING_OPTIONS = [
+  { value: "React Query", label: "React Query / TanStack Query" },
+  { value: "SWR", label: "SWR" },
+  { value: "Apollo Client", label: "Apollo Client" },
+  { value: "tRPC", label: "tRPC" },
+  { value: "URQL", label: "URQL" },
+  { value: "Axios", label: "Axios" },
+  { value: "Fetch", label: "Native Fetch" }
+];
+var ORM_OPTIONS = [
+  { value: "Prisma", label: "Prisma" },
+  { value: "Drizzle", label: "Drizzle" },
+  { value: "TypeORM", label: "TypeORM" },
+  { value: "Mongoose", label: "Mongoose" },
+  { value: "Kysely", label: "Kysely" }
+];
+function displayFullAnalysis(analysis) {
+  const lines = [];
+  lines.push(`${chalk2.bold("Framework:")}        ${analysis.framework.name}${analysis.framework.version ? ` v${analysis.framework.version}` : ""}`);
+  lines.push("");
+  lines.push(`${chalk2.bold("Architecture:")}     ${getArchitectureDescription(analysis.architecture.pattern)}`);
+  if (analysis.architecture.layers.length > 0) {
+    lines.push(`${chalk2.bold("Layers found:")}     ${analysis.architecture.layers.map((l) => chalk2.green(l)).join(", ")}`);
+  }
+  lines.push("");
+  lines.push(chalk2.bold("Stack detected:"));
+  if (analysis.stack.stateManagement.length > 0) {
+    lines.push(`  State:       ${analysis.stack.stateManagement.join(", ")}`);
+  }
+  if (analysis.stack.dataFetching.length > 0) {
+    lines.push(`  Data:        ${analysis.stack.dataFetching.join(", ")}`);
+  }
+  if (analysis.stack.orm.length > 0) {
+    lines.push(`  ORM:         ${analysis.stack.orm.join(", ")}`);
+  }
+  if (analysis.stack.testing.length > 0) {
+    lines.push(`  Testing:     ${analysis.stack.testing.join(", ")}`);
+  }
+  if (analysis.stack.ui.length > 0) {
+    lines.push(`  UI:          ${analysis.stack.ui.join(", ")}`);
+  }
+  if (analysis.stack.validation.length > 0) {
+    lines.push(`  Validation:  ${analysis.stack.validation.join(", ")}`);
+  }
+  const hasStack = Object.values(analysis.stack).some((arr) => arr.length > 0);
+  if (!hasStack) {
+    lines.push(`  ${chalk2.dim("(no specific libraries detected)")}`);
+  }
+  lines.push("");
+  lines.push(chalk2.bold("Scripts:"));
+  lines.push(`  typecheck:   ${analysis.scripts.typecheck || chalk2.dim("not found")}`);
+  lines.push(`  lint:        ${analysis.scripts.lint || chalk2.dim("not found")}`);
+  lines.push(`  test:        ${analysis.scripts.test || chalk2.dim("not found")}`);
+  lines.push(`  build:       ${analysis.scripts.build || chalk2.dim("not found")}`);
+  p2.note(lines.join("\n"), "Project Analysis");
+}
+async function promptForAnalysisConfirmation() {
+  return p2.confirm({
+    message: "Is this analysis correct?",
+    initialValue: true
+  });
+}
+async function promptForArchitecture(detected) {
+  const result = await p2.select({
+    message: "What architecture pattern does your project use?",
+    options: ARCHITECTURE_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: opt.label,
+      hint: opt.value === detected ? `${opt.hint} ${chalk2.green("(detected)")}` : opt.hint
+    })),
+    initialValue: detected
+  });
+  return result;
+}
+async function promptForLayers(detected) {
+  const result = await p2.multiselect({
+    message: "What layers does your project have?",
+    options: LAYER_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: opt.label,
+      hint: detected.includes(opt.value) ? `${opt.hint} ${chalk2.green("(detected)")}` : opt.hint
+    })),
+    initialValues: detected.length > 0 ? detected : ["domain", "application", "infrastructure"],
+    required: false
+  });
+  return result;
+}
+async function promptForStateManagement(detected) {
+  const result = await p2.multiselect({
+    message: "What state management do you use?",
+    options: STATE_MANAGEMENT_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: detected.includes(opt.value) ? `${opt.label} ${chalk2.green("(detected)")}` : opt.label
+    })),
+    initialValues: detected,
+    required: false
+  });
+  return result;
+}
+async function promptForDataFetching(detected) {
+  const result = await p2.multiselect({
+    message: "What data fetching libraries do you use?",
+    options: DATA_FETCHING_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: detected.includes(opt.value) ? `${opt.label} ${chalk2.green("(detected)")}` : opt.label
+    })),
+    initialValues: detected,
+    required: false
+  });
+  return result;
+}
+async function promptForOrm(detected) {
+  const result = await p2.multiselect({
+    message: "What ORM/database library do you use?",
+    options: ORM_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: detected.includes(opt.value) ? `${opt.label} ${chalk2.green("(detected)")}` : opt.label
+    })),
+    initialValues: detected,
+    required: false
+  });
+  return result;
+}
+async function promptForProjectConfig(analysis, skipPrompts) {
+  if (skipPrompts) {
+    return {
+      architecture: analysis.architecture.pattern,
+      layers: analysis.architecture.layers,
+      stateManagement: analysis.stack.stateManagement,
+      dataFetching: analysis.stack.dataFetching,
+      orm: analysis.stack.orm,
+      testing: analysis.stack.testing,
+      ui: analysis.stack.ui,
+      validation: analysis.stack.validation,
+      framework: analysis.framework.name,
+      qualityCommand: generateQualityCommands(analysis.scripts, analysis.packageManager)
+    };
+  }
+  displayFullAnalysis(analysis);
+  const isCorrect = await promptForAnalysisConfirmation();
+  if (p2.isCancel(isCorrect)) return isCorrect;
+  if (isCorrect) {
+    return {
+      architecture: analysis.architecture.pattern,
+      layers: analysis.architecture.layers,
+      stateManagement: analysis.stack.stateManagement,
+      dataFetching: analysis.stack.dataFetching,
+      orm: analysis.stack.orm,
+      testing: analysis.stack.testing,
+      ui: analysis.stack.ui,
+      validation: analysis.stack.validation,
+      framework: analysis.framework.name,
+      qualityCommand: generateQualityCommands(analysis.scripts, analysis.packageManager)
+    };
+  }
+  p2.log.info("Let's adjust the configuration...");
+  const architecture = await promptForArchitecture(analysis.architecture.pattern);
+  if (p2.isCancel(architecture)) return architecture;
+  let layers = [];
+  if (architecture !== "none" && architecture !== "flat") {
+    const layersResult = await promptForLayers(analysis.architecture.layers);
+    if (p2.isCancel(layersResult)) return layersResult;
+    layers = layersResult;
+  }
+  const stateManagement = await promptForStateManagement(analysis.stack.stateManagement);
+  if (p2.isCancel(stateManagement)) return stateManagement;
+  const dataFetching = await promptForDataFetching(analysis.stack.dataFetching);
+  if (p2.isCancel(dataFetching)) return dataFetching;
+  const orm = await promptForOrm(analysis.stack.orm);
+  if (p2.isCancel(orm)) return orm;
+  return {
+    architecture,
+    layers,
+    stateManagement,
+    dataFetching,
+    orm,
+    testing: analysis.stack.testing,
+    ui: analysis.stack.ui,
+    validation: analysis.stack.validation,
+    framework: analysis.framework.name,
+    qualityCommand: generateQualityCommands(analysis.scripts, analysis.packageManager)
+  };
+}
+
+// src/utils/merge.ts
+function parseMarkdownSections(markdown) {
+  const sections = [];
+  const lines = markdown.split("\n");
+  let currentSection = null;
+  let contentLines = [];
+  for (const line of lines) {
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+      }
+      currentSection = {
+        level: headerMatch[1].length,
+        title: headerMatch[2].trim(),
+        content: ""
+      };
+      contentLines = [];
+    } else {
+      contentLines.push(line);
+    }
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  if (sections.length === 0 && contentLines.length > 0) {
+    sections.push({
+      level: 0,
+      title: "",
+      content: contentLines.join("\n").trim()
+    });
+  }
+  return sections;
+}
+function sectionToMarkdown(section) {
+  if (section.level === 0) {
+    return section.content;
+  }
+  const header = "#".repeat(section.level) + " " + section.title;
+  if (section.content) {
+    return header + "\n\n" + section.content;
+  }
+  return header;
+}
+function mergeMarkdown(existing, template) {
+  const existingSections = parseMarkdownSections(existing);
+  const templateSections = parseMarkdownSections(template);
+  const existingTitles = new Set(
+    existingSections.map((s) => s.title.toLowerCase())
+  );
+  const mergedSections = [...existingSections];
+  for (const templateSection of templateSections) {
+    if (templateSection.title && !existingTitles.has(templateSection.title.toLowerCase())) {
+      mergedSections.push(templateSection);
+    }
+  }
+  return mergedSections.map(sectionToMarkdown).join("\n\n");
+}
+function mergeJson(existing, template) {
+  const result = { ...existing };
+  for (const key of Object.keys(template)) {
+    const templateValue = template[key];
+    const existingValue = existing[key];
+    if (existingValue === void 0) {
+      result[key] = templateValue;
+    } else if (typeof templateValue === "object" && templateValue !== null && !Array.isArray(templateValue) && typeof existingValue === "object" && existingValue !== null && !Array.isArray(existingValue)) {
+      result[key] = mergeJson(
+        existingValue,
+        templateValue
+      );
+    }
+  }
+  return result;
+}
+function getMergeStrategy(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "md":
+    case "mdc":
+      return "markdown";
+    case "json":
+      return "json";
+    default:
+      return "overwrite";
+  }
+}
+function mergeFile(existingContent, templateContent, strategy) {
+  switch (strategy) {
+    case "markdown":
+      return mergeMarkdown(existingContent, templateContent);
+    case "json":
+      try {
+        const existing = JSON.parse(existingContent);
+        const template = JSON.parse(templateContent);
+        return JSON.stringify(mergeJson(existing, template), null, 2);
+      } catch {
+        return templateContent;
+      }
+    case "skip":
+      return existingContent;
+    case "overwrite":
+    default:
+      return templateContent;
+  }
+}
+
+// src/utils/tty.ts
+function ensureInteractive(commandName) {
+  if (!process.stdout.isTTY) {
+    console.error(
+      `Error: "${commandName}" requires an interactive terminal.
+If running in CI or piped mode, use --yes (and --preset for init).`
+    );
+    process.exit(1);
+  }
+}
+
+// src/generators/architectureRules.ts
+function generateArchitectureRules(config) {
+  if (config.architecture === "none") {
+    return null;
+  }
+  const content = generateRulesContent(config);
+  return {
+    claudeCode: generateClaudeCodeFormat(content),
+    cursor: generateCursorFormat(content),
+    antigravity: generateAntigravityFormat(content),
+    copilot: content,
+    // Copilot uses plain markdown
+    opencode: content
+    // OpenCode uses plain markdown
+  };
+}
+function generateRulesContent(config) {
+  const sections = [];
+  sections.push(generateArchitectureSection(config));
+  if (config.layers.length > 0) {
+    sections.push(generateLayersSection(config));
+  }
+  if (config.stateManagement.length > 0 || config.dataFetching.length > 0) {
+    sections.push(generateStateSection(config));
+  }
+  if (config.orm.length > 0) {
+    sections.push(generateDataAccessSection(config));
+  }
+  sections.push(generateQualitySection(config));
+  return sections.join("\n\n---\n\n");
+}
+function generateArchitectureSection(config) {
+  switch (config.architecture) {
+    case "clean":
+      return `# Architecture: Clean Architecture
+
+## Layer Rule
+
+\`\`\`
+Presentation \u2192 Application \u2192 Domain \u2190 Infrastructure
+\`\`\`
+
+**Dependencies point INWARD only.** Inner layers know nothing about outer layers.
+
+## Dependency Rules
+
+- **Domain** layer has NO external dependencies
+- **Application** can only import from Domain
+- **Infrastructure** implements interfaces defined in Domain
+- **Presentation/UI** orchestrates via Application layer
+
+## Common Violations to Avoid
+
+\`\`\`typescript
+// \u274C Domain importing infrastructure
+import { prisma } from '../infrastructure/db'
+
+// \u274C UI accessing database directly
+const user = await db.user.findUnique(...)
+
+// \u2705 UI calls use case, use case uses repository interface
+const user = await getUserUseCase.execute(id)
+\`\`\``;
+    case "layered":
+      return `# Architecture: Layered
+
+## Layer Rule
+
+\`\`\`
+Routes/Controllers \u2192 Services \u2192 Repositories \u2192 Database
+\`\`\`
+
+**Each layer only calls the one below it.** No skipping layers.
+
+## Responsibilities
+
+- **Routes/Controllers**: Handle HTTP, validate input, delegate to services
+- **Services**: Business logic, orchestrate repositories, enforce rules
+- **Repositories**: Data access, queries, database operations
+- **Middleware**: Cross-cutting concerns (auth, logging, error handling)
+
+## Rules
+
+- Controllers should be thin \u2014 validate input, call service, return response
+- Services contain ALL business logic \u2014 never in controllers or repositories
+- Repositories are the only layer that touches the database
+- Services should NOT know about HTTP (no req/res objects)
+
+## Common Violations to Avoid
+
+\`\`\`typescript
+// \u274C Business logic in controller
+app.post('/users', async (req, res) => {
+  if (await db.user.findByEmail(req.body.email)) throw new Error('exists');
+  const hashed = await hash(req.body.password);
+  await db.user.create({ email: req.body.email, password: hashed });
+});
+
+// \u2705 Controller delegates to service
+app.post('/users', async (req, res) => {
+  const user = await userService.create(req.body);
+  res.json(user);
+});
+\`\`\``;
+    case "mvc":
+      return `# Architecture: MVC
+
+## Layer Rule
+
+\`\`\`
+View \u2192 Controller \u2192 Model
+\`\`\`
+
+## Responsibilities
+
+- **Model**: Data structures, business logic, database access
+- **View**: UI rendering, user interaction
+- **Controller**: Handle requests, coordinate Model and View
+
+## Rules
+
+- Views should NOT contain business logic
+- Controllers should be thin - delegate to Models
+- Models should not know about Views`;
+    case "feature-based":
+      return `# Architecture: Feature-Based
+
+## Structure
+
+Each feature is self-contained with its own:
+- Components
+- Hooks
+- API calls
+- Types
+- Utils
+
+## Rules
+
+- Features should be independent - avoid cross-feature imports
+- Shared code goes in \`shared/\` or \`common/\`
+- Each feature can have its own local state`;
+    case "flat":
+    default:
+      return `# Architecture
+
+Document your architecture patterns and rules here.
+
+## General Guidelines
+
+- Keep related code together
+- Avoid circular dependencies
+- Separate concerns appropriately`;
+  }
+}
+function generateLayersSection(config) {
+  if (config.layers.length === 0) return "";
+  const layerDescriptions = {
+    domain: "Entities, Value Objects, Repository Interfaces",
+    application: "Use Cases, DTOs, Application Services",
+    infrastructure: "Repository Implementations, External Services, Database",
+    presentation: "UI Components, Pages, Controllers",
+    routes: "HTTP Routes and Request Handlers",
+    controllers: "Request Handlers, Input Validation",
+    services: "Business Logic, Orchestration",
+    repositories: "Data Access, Database Queries",
+    middleware: "Auth, Logging, Error Handling",
+    ui: "User Interface Components",
+    api: "API Routes and Handlers",
+    core: "Core Business Logic",
+    shared: "Shared Utilities and Types",
+    features: "Feature Modules",
+    modules: "Application Modules"
+  };
+  const layerRows = config.layers.map((layer) => `| ${layer} | ${layerDescriptions[layer] || "Custom layer"} |`).join("\n");
+  return `## Project Layers
+
+| Layer | Contains |
+|-------|----------|
+${layerRows}
+
+Respect layer boundaries. Import only from allowed layers.`;
+}
+function generateStateSection(config) {
+  const parts = ["## State Management"];
+  if (config.stateManagement.length > 0) {
+    parts.push(`
+**Client State**: ${config.stateManagement.join(", ")}`);
+    if (config.stateManagement.includes("Zustand")) {
+      parts.push("- Create stores in dedicated files");
+      parts.push("- Keep stores focused and small");
+      parts.push("- Use selectors to prevent unnecessary re-renders");
+    }
+    if (config.stateManagement.includes("Redux Toolkit")) {
+      parts.push("- Use createSlice for reducers");
+      parts.push("- Use RTK Query for data fetching when possible");
+      parts.push("- Keep selectors in slice files");
+    }
+    if (config.stateManagement.includes("XState")) {
+      parts.push("- Model complex flows as state machines");
+      parts.push("- Keep machines in separate files");
+    }
+  }
+  if (config.dataFetching.length > 0) {
+    parts.push(`
+**Server State**: ${config.dataFetching.join(", ")}`);
+    if (config.dataFetching.includes("React Query")) {
+      parts.push("- Use query keys consistently");
+      parts.push("- Invalidate queries after mutations");
+      parts.push("- Configure stale time appropriately");
+    }
+    if (config.dataFetching.includes("SWR")) {
+      parts.push("- Use SWR for data that changes frequently");
+      parts.push("- Configure revalidation strategies");
+    }
+    if (config.dataFetching.includes("tRPC")) {
+      parts.push("- Keep procedures organized by domain");
+      parts.push("- Use input validation with Zod");
+    }
+  }
+  return parts.join("\n");
+}
+function generateDataAccessSection(config) {
+  if (config.orm.length === 0) return "";
+  const parts = ["## Data Access"];
+  if (config.orm.includes("Prisma")) {
+    parts.push(`
+**ORM**: Prisma
+
+- Prisma client only in infrastructure layer
+- Use repository pattern to abstract database access
+- Keep queries in repository implementations
+- Use transactions for multi-step operations`);
+  }
+  if (config.orm.includes("Drizzle")) {
+    parts.push(`
+**ORM**: Drizzle
+
+- Keep schema definitions in dedicated files
+- Use repository pattern for data access
+- Leverage type-safe queries`);
+  }
+  if (config.orm.includes("TypeORM")) {
+    parts.push(`
+**ORM**: TypeORM
+
+- Use repository pattern
+- Keep entities in domain layer
+- Repositories in infrastructure layer`);
+  }
+  if (config.orm.includes("Mongoose")) {
+    parts.push(`
+**ODM**: Mongoose
+
+- Keep models in infrastructure layer
+- Use lean() for read-only queries
+- Validate with schema validators`);
+  }
+  return parts.join("\n");
+}
+function generateQualitySection(config) {
+  return `## Quality Checks
+
+Run after every change:
+
+\`\`\`bash
+${config.qualityCommand}
+\`\`\`
+
+### Rules
+
+- All code must pass type checking
+- All code must pass linting
+- Tests must pass before committing
+- No \`any\` types without explicit reason`;
+}
+function generateClaudeCodeFormat(content) {
+  return content;
+}
+function generateCursorFormat(content) {
+  return `---
+description: Architecture rules and patterns for this project
+alwaysApply: true
+---
+
+${content}
+`;
+}
+function generateAntigravityFormat(content) {
+  return content;
+}
+
+// src/utils/rules.ts
+function getRuleContentForIDE(ide, rules) {
+  switch (ide) {
+    case "claude-code":
+      return rules.claudeCode;
+    case "cursor":
+      return rules.cursor;
+    case "antigravity":
+      return rules.antigravity;
+    case "github-copilot":
+      return rules.copilot;
+    case "opencode":
+      return rules.opencode;
+    default:
+      return null;
+  }
+}
+
+// src/utils/settings.ts
+import { join as join6 } from "path";
+var SETTINGS_FILE = ".claude/settings.json";
+function readClaudeSettings(targetDir) {
+  const settingsPath = join6(targetDir, SETTINGS_FILE);
+  if (!fileExists(settingsPath)) return {};
+  try {
+    return JSON.parse(readFile(settingsPath));
+  } catch {
+    return {};
+  }
+}
+function writeClaudeSettings(targetDir, settings) {
+  const settingsPath = join6(targetDir, SETTINGS_FILE);
+  ensureDir(join6(targetDir, ".claude"));
+  writeFile(settingsPath, JSON.stringify(settings, null, 2));
+}
+function registerPlugin(targetDir, pluginName, marketplaceName, marketplacePath) {
+  const settings = readClaudeSettings(targetDir);
+  if (!settings.extraKnownMarketplaces) {
+    settings.extraKnownMarketplaces = {};
+  }
+  if (!settings.extraKnownMarketplaces[marketplaceName]) {
+    settings.extraKnownMarketplaces[marketplaceName] = {
+      source: { source: "directory", path: marketplacePath }
+    };
+  }
+  if (!settings.enabledPlugins) {
+    settings.enabledPlugins = {};
+  }
+  const pluginKey = `${pluginName}@${marketplaceName}`;
+  if (settings.enabledPlugins[pluginKey] === void 0) {
+    settings.enabledPlugins[pluginKey] = true;
+  }
+  writeClaudeSettings(targetDir, settings);
+}
+function unregisterPlugin(targetDir, pluginName, marketplaceName) {
+  const settings = readClaudeSettings(targetDir);
+  const pluginKey = `${pluginName}@${marketplaceName}`;
+  if (settings.enabledPlugins) {
+    delete settings.enabledPlugins[pluginKey];
+  }
+  writeClaudeSettings(targetDir, settings);
+}
+
+// src/utils/ui.ts
+import chalk3 from "chalk";
+var GRAYS = [
+  "\x1B[38;5;250m",
+  // lightest
+  "\x1B[38;5;248m",
+  "\x1B[38;5;245m",
+  "\x1B[38;5;243m",
+  "\x1B[38;5;240m",
+  "\x1B[38;5;238m"
+  // darkest
+];
+var RESET = "\x1B[0m";
+var LOGO_LINES = [
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551     ",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551     ",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u255A\u2588\u2588\u2588\u2588\u2554\u255D    \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+function showLogo() {
+  console.log();
+  for (let i = 0; i < LOGO_LINES.length; i++) {
+    console.log(`  ${GRAYS[i]}${LOGO_LINES[i]}${RESET}`);
+  }
+  console.log();
+}
+var symbols = {
+  pass: chalk3.green("\u2713"),
+  fail: chalk3.red("\u2717"),
+  warn: chalk3.yellow("\u26A0"),
+  info: chalk3.cyan("\u25CF"),
+  bullet: chalk3.dim("-"),
+  star: chalk3.magenta("\u2605"),
+  arrow: chalk3.dim("\u2192"),
+  merged: chalk3.blue("\u26A1"),
+  updated: chalk3.blue("\u2191"),
+  skipped: chalk3.yellow("\u23ED")
+};
+function introTitle(suffix) {
+  const text = suffix ? ` devtronic ${suffix} ` : " devtronic ";
+  return chalk3.bgCyan.black(text);
+}
+function formatKV(key, value, keyWidth = 15) {
+  return `${chalk3.bold(key.padEnd(keyWidth))}${value}`;
+}
+
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getCliVersion() {
+  const paths = [
+    resolve(__dirname, "../package.json"),
+    resolve(__dirname, "../../package.json")
+  ];
+  for (const p16 of paths) {
+    try {
+      const pkg = JSON.parse(readFileSync(p16, "utf-8"));
+      if (pkg.name === "devtronic" && pkg.version) {
+        return pkg.version;
+      }
+    } catch {
+    }
+  }
+  return "1.0.0";
+}
+async function getLatestVersion(packageName) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseSegment(s) {
+  const n = parseInt(s, 10);
+  return isNaN(n) ? 0 : n;
+}
+function compareSemver(a, b) {
+  const pa = a.split(".").map(parseSegment);
+  const pb = b.split(".").map(parseSegment);
+  for (let i = 0; i < 3; i++) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va > vb) return 1;
+    if (va < vb) return -1;
+  }
+  return 0;
+}
+
+// src/commands/init.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var TEMPLATES_DIR = existsSync5(resolve2(__dirname2, "../templates")) ? resolve2(__dirname2, "../templates") : resolve2(__dirname2, "../../templates");
+var IDE_TEMPLATE_MAP = {
+  "claude-code": "claude-code",
+  cursor: "cursor",
+  antigravity: "antigravity",
+  "github-copilot": "github-copilot",
+  opencode: "opencode"
+};
+var DYNAMIC_RULE_FILES = {
+  "claude-code": [".claude/rules/architecture.md"],
+  cursor: [".cursor/rules/architecture.mdc"],
+  antigravity: [".agents/rules/architecture.md"],
+  "github-copilot": [],
+  // Copilot uses single file, handled separately
+  opencode: []
+  // OpenCode reads AGENTS.md natively — no separate rules directory needed
+};
+var THOUGHTS_DIRS = [
+  "thoughts/specs",
+  "thoughts/research",
+  "thoughts/plans",
+  "thoughts/checkpoints",
+  "thoughts/notes",
+  "thoughts/debug",
+  "thoughts/audit",
+  "thoughts/archive/backlog"
+];
+async function initCommand(options) {
+  if (!options.yes && !options.preview) {
+    ensureInteractive("init");
+  }
+  const targetDir = resolve2(options.path || ".");
+  showLogo();
+  p3.intro(introTitle());
+  if (!existsSync5(targetDir)) {
+    p3.cancel(`Directory does not exist: ${targetDir}`);
+    process.exit(1);
+  }
+  const existingManifest = readManifest(targetDir);
+  if (existingManifest && !options.preview) {
+    p3.note(
+      `Version ${existingManifest.version} installed on ${existingManifest.implantedAt}`,
+      "Already Configured"
+    );
+    if (!options.yes) {
+      const proceed = await p3.confirm({
+        message: "Re-run initialization?",
+        initialValue: false
+      });
+      if (p3.isCancel(proceed) || !proceed) {
+        p3.cancel("Initialization cancelled");
+        process.exit(0);
+      }
+    }
+  }
+  const spinner8 = p3.spinner();
+  spinner8.start("Analyzing project...");
+  const analysis = analyzeProject(targetDir);
+  spinner8.stop("Project analyzed");
+  let projectConfig;
+  if (options.preset) {
+    const preset = PRESETS[options.preset];
+    if (!preset) {
+      p3.cancel(`Unknown preset: ${options.preset}`);
+      process.exit(1);
+    }
+    p3.log.info(`Using preset: ${chalk4.cyan(preset.description)}`);
+    projectConfig = buildProjectConfigFromPreset(preset.config, analysis);
+  } else {
+    const projectConfigResult = await promptForProjectConfig(analysis, !!options.yes);
+    if (p3.isCancel(projectConfigResult)) {
+      p3.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    projectConfig = projectConfigResult;
+  }
+  let selectedIDEs;
+  let enabledAddons = [];
+  if (options.ide) {
+    const VALID_IDES = ["claude-code", "cursor", "antigravity", "github-copilot", "opencode"];
+    selectedIDEs = options.ide.split(",").map((s) => s.trim());
+    const invalidIDEs = selectedIDEs.filter((ide) => !VALID_IDES.includes(ide));
+    if (invalidIDEs.length > 0) {
+      p3.cancel(`Unknown IDE(s): ${invalidIDEs.join(", ")}
+
+Valid: ${VALID_IDES.join(", ")}`);
+      process.exit(1);
+    }
+    p3.log.info(`IDEs from CLI: ${selectedIDEs.join(", ")}`);
+  } else if (options.yes) {
+    selectedIDEs = ["claude-code"];
+    p3.log.info(`IDEs: claude-code (default)`);
+  } else {
+    const ideSelection = await promptForIDEs(analysis.existingConfigs);
+    if (p3.isCancel(ideSelection)) {
+      p3.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    selectedIDEs = ideSelection;
+  }
+  if (options.addon) {
+    const validAddons = Object.keys(ADDONS);
+    if (!validAddons.includes(options.addon)) {
+      p3.cancel(`Unknown addon: ${options.addon}
+
+Valid addons: ${validAddons.join(", ")}`);
+      process.exit(1);
+    }
+    if (selectedIDEs.includes("claude-code")) {
+      enabledAddons = [options.addon];
+      p3.log.info(`Addon: ${options.addon}`);
+    } else {
+      p3.log.warn(`Addon "${options.addon}" requires claude-code IDE. Skipping.`);
+    }
+  }
+  if (selectedIDEs.includes("claude-code") && !options.addon && !options.yes && !options.preset && !options.preview) {
+    const wantOrchestration = await promptForOrchestration();
+    if (p3.isCancel(wantOrchestration)) {
+      p3.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    if (wantOrchestration) {
+      enabledAddons = ["orchestration"];
+    }
+  }
+  if (enabledAddons.length > 0) {
+    projectConfig.enabledAddons = enabledAddons;
+  }
+  if (options.preview) {
+    await showPreview(targetDir, selectedIDEs, projectConfig, analysis);
+    return;
+  }
+  const existingIDEs = getExistingConfigsList(analysis.existingConfigs);
+  const conflictResolutions = /* @__PURE__ */ new Map();
+  for (const ide of selectedIDEs) {
+    if (existingIDEs.includes(ide)) {
+      if (options.yes) {
+        conflictResolutions.set(ide, "merge");
+      } else {
+        const resolution = await promptForConflictResolution(ide);
+        if (p3.isCancel(resolution)) {
+          p3.cancel("Operation cancelled");
+          process.exit(0);
+        }
+        conflictResolutions.set(ide, resolution);
+      }
+    }
+  }
+  const hasAgentsMd = fileExists(join7(targetDir, "AGENTS.md"));
+  let createAgentsMd = !hasAgentsMd;
+  if (!hasAgentsMd && !options.yes) {
+    const agentsMdResponse = await promptForAgentsMd();
+    if (p3.isCancel(agentsMdResponse)) {
+      p3.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    createAgentsMd = agentsMdResponse;
+  }
+  const hasThoughtsDir = existsSync5(join7(targetDir, "thoughts"));
+  let createThoughtsDir = !hasThoughtsDir;
+  if (!hasThoughtsDir && !options.yes) {
+    const thoughtsDirResponse = await promptForThoughtsDir();
+    if (p3.isCancel(thoughtsDirResponse)) {
+      p3.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    createThoughtsDir = thoughtsDirResponse;
+  }
+  spinner8.start("Generating personalized configuration...");
+  try {
+    const generatedRules = generateArchitectureRules(projectConfig);
+    const manifest = {
+      version: getCliVersion(),
+      implantedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      selectedIDEs,
+      projectConfig,
+      files: {}
+    };
+    const appliedFiles = [];
+    const skippedFiles = [];
+    const mergedFiles = [];
+    const generatedFiles = [];
+    const usePluginMode = selectedIDEs.includes("claude-code");
+    if (usePluginMode) {
+      const pluginResult = generatePlugin(
+        targetDir,
+        TEMPLATES_DIR,
+        getCliVersion(),
+        projectConfig,
+        analysis.packageManager
+      );
+      for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
+        const scriptPath = join7(targetDir, pluginResult.pluginPath, "scripts", script);
+        if (existsSync5(scriptPath)) {
+          chmodSync(scriptPath, 493);
+        }
+      }
+      registerPlugin(targetDir, PLUGIN_NAME, MARKETPLACE_NAME, PLUGIN_DIR);
+      Object.assign(manifest.files, pluginResult.files);
+      manifest.installMode = "plugin";
+      manifest.pluginPath = pluginResult.pluginPath;
+      const addonSkillCount = (projectConfig.enabledAddons || []).reduce((sum, a) => sum + (ADDONS[a]?.skills.length ?? 0), 0);
+      const skillLabel = addonSkillCount > 0 ? `${BASE_SKILL_COUNT} + ${addonSkillCount} addon skills` : `${BASE_SKILL_COUNT} skills`;
+      generatedFiles.push(`Plugin ${PLUGIN_NAME} (${skillLabel}, 8 agents, 5 hooks)`);
+    }
+    for (const ide of selectedIDEs) {
+      const templateName = IDE_TEMPLATE_MAP[ide];
+      const templateDir = join7(TEMPLATES_DIR, templateName);
+      if (!existsSync5(templateDir)) {
+        p3.log.warn(`Template not found: ${templateName}`);
+        continue;
+      }
+      const resolution = conflictResolutions.get(ide) || "overwrite";
+      const files = getAllFilesRecursive(templateDir);
+      const dynamicFiles = DYNAMIC_RULE_FILES[ide] || [];
+      for (const file of files) {
+        if (dynamicFiles.includes(file)) {
+          continue;
+        }
+        if (usePluginMode && ide === "claude-code" && (file.startsWith(".claude/skills/") || file.startsWith(".claude/agents/"))) {
+          continue;
+        }
+        const sourcePath = join7(templateDir, file);
+        const destPath = join7(targetDir, file);
+        const sourceContent = readFile(sourcePath);
+        if (fileExists(destPath)) {
+          const existingContent = readFile(destPath);
+          if (resolution === "keep") {
+            skippedFiles.push(file);
+            continue;
+          }
+          if (resolution === "merge") {
+            const strategy = getMergeStrategy(file);
+            const mergedContent = mergeFile(existingContent, sourceContent, strategy);
+            writeFile(destPath, mergedContent);
+            mergedFiles.push(file);
+            manifest.files[file] = createManifestEntry(mergedContent);
+            continue;
+          }
+        }
+        ensureDir(dirname2(destPath));
+        writeFile(destPath, sourceContent);
+        appliedFiles.push(file);
+        manifest.files[file] = createManifestEntry(sourceContent);
+      }
+      const ruleContent = generatedRules ? getRuleContentForIDE(ide, generatedRules) : null;
+      if (ruleContent) {
+        const rulePath = dynamicFiles[0];
+        if (rulePath) {
+          const destPath = join7(targetDir, rulePath);
+          const resolution2 = conflictResolutions.get(ide) || "overwrite";
+          if (fileExists(destPath) && resolution2 === "keep") {
+            skippedFiles.push(rulePath);
+          } else if (fileExists(destPath) && resolution2 === "merge") {
+            const existingContent = readFile(destPath);
+            const strategy = getMergeStrategy(rulePath);
+            const mergedContent = mergeFile(existingContent, ruleContent, strategy);
+            writeFile(destPath, mergedContent);
+            mergedFiles.push(rulePath);
+            manifest.files[rulePath] = createManifestEntry(mergedContent);
+          } else {
+            ensureDir(dirname2(destPath));
+            writeFile(destPath, ruleContent);
+            generatedFiles.push(`${rulePath} (personalized)`);
+            manifest.files[rulePath] = createManifestEntry(ruleContent);
+          }
+        }
+      }
+    }
+    if (selectedIDEs.includes("claude-code")) {
+      const claudeMdPath = join7(targetDir, "CLAUDE.md");
+      if (!fileExists(claudeMdPath)) {
+        const claudeMdContent = generateClaudeMd(
+          projectConfig,
+          analysis.scripts,
+          analysis.packageManager
+        );
+        writeFile(claudeMdPath, claudeMdContent);
+        generatedFiles.push("CLAUDE.md (personalized)");
+        manifest.files["CLAUDE.md"] = createManifestEntry(claudeMdContent);
+      } else {
+        p3.log.info("CLAUDE.md already exists \u2014 preserving your customizations.");
+      }
+    }
+    if (createAgentsMd) {
+      const agentsMdPath = join7(targetDir, "AGENTS.md");
+      const agentsMdContent = generateAgentsMdFromConfig(
+        projectConfig,
+        analysis.scripts,
+        analysis.packageManager
+      );
+      writeFile(agentsMdPath, agentsMdContent);
+      generatedFiles.push("AGENTS.md (personalized)");
+      manifest.files["AGENTS.md"] = createManifestEntry(agentsMdContent);
+    }
+    if (createThoughtsDir) {
+      for (const dir of THOUGHTS_DIRS) {
+        ensureDir(join7(targetDir, dir));
+      }
+      appliedFiles.push("thoughts/ structure");
+    }
+    writeManifest(targetDir, manifest);
+    spinner8.stop("Configuration applied");
+    if (generatedFiles.length > 0) {
+      p3.note(
+        generatedFiles.map((f) => `  ${symbols.star} ${f}`).join("\n"),
+        "Generated (personalized)"
+      );
+    }
+    if (appliedFiles.length > 0) {
+      p3.note(
+        appliedFiles.map((f) => `  ${symbols.pass} ${f}`).join("\n"),
+        "Created/Updated"
+      );
+    }
+    if (mergedFiles.length > 0) {
+      p3.note(
+        mergedFiles.map((f) => `  ${symbols.merged} ${f}`).join("\n"),
+        "Merged"
+      );
+    }
+    if (skippedFiles.length > 0) {
+      p3.note(
+        skippedFiles.map((f) => `  ${symbols.skipped} ${f}`).join("\n"),
+        "Skipped (existing)"
+      );
+    }
+    if (usePluginMode) {
+      p3.note(
+        [
+          `  Name:   ${chalk4.cyan(PLUGIN_NAME)} at ${PLUGIN_DIR}/${PLUGIN_NAME}/`,
+          `  Skills: /devtronic:brief, /devtronic:spec, /devtronic:research, ...`,
+          `  Hooks:  SessionStart, PostToolUse, Stop, SubagentStop, PreCompact`
+        ].join("\n"),
+        "Plugin Installed"
+      );
+    }
+    p3.note(
+      [
+        `  1. Review the generated CLAUDE.md and rules`,
+        `  2. Customize further as needed for your project`,
+        `  3. Add to .gitignore:`,
+        chalk4.dim("     thoughts/checkpoints/"),
+        chalk4.dim("     .claude/settings.local.json"),
+        chalk4.dim("     CLAUDE.local.md"),
+        chalk4.dim("     .ai-template/"),
+        ``,
+        `  To update later: ${chalk4.cyan("npx devtronic update")}`
+      ].join("\n"),
+      "Next Steps"
+    );
+    p3.outro(chalk4.green("Setup complete!"));
+  } catch (err) {
+    spinner8.stop("Configuration failed");
+    const message = err instanceof Error ? err.message : String(err);
+    p3.log.error(message);
+    p3.cancel("Installation aborted due to an error. Check permissions and try again.");
+    process.exit(1);
+  }
+}
+async function showPreview(targetDir, selectedIDEs, projectConfig, analysis) {
+  const configLines = [formatKV("Architecture:", chalk4.cyan(projectConfig.architecture))];
+  if (projectConfig.layers.length > 0) {
+    configLines.push(formatKV("Layers:", chalk4.cyan(projectConfig.layers.join(", "))));
+  }
+  if (projectConfig.stateManagement.length > 0) {
+    configLines.push(formatKV("State:", chalk4.cyan(projectConfig.stateManagement.join(", "))));
+  }
+  if (projectConfig.dataFetching.length > 0) {
+    configLines.push(formatKV("Data:", chalk4.cyan(projectConfig.dataFetching.join(", "))));
+  }
+  if (projectConfig.orm.length > 0) {
+    configLines.push(formatKV("ORM:", chalk4.cyan(projectConfig.orm.join(", "))));
+  }
+  p3.note(configLines.join("\n"), "Configuration");
+  const fileLines = [];
+  const claudeMdContent = generateClaudeMd(
+    projectConfig,
+    analysis.scripts,
+    analysis.packageManager
+  );
+  const claudeMdLines = claudeMdContent.split("\n").length;
+  fileLines.push(`  ${symbols.star} CLAUDE.md ${chalk4.dim(`(${claudeMdLines} lines)`)}`);
+  const agentsMdContent = generateAgentsMdFromConfig(
+    projectConfig,
+    analysis.scripts,
+    analysis.packageManager
+  );
+  const agentsMdLines = agentsMdContent.split("\n").length;
+  fileLines.push(`  ${symbols.star} AGENTS.md ${chalk4.dim(`(${agentsMdLines} lines)`)}`);
+  if (selectedIDEs.includes("claude-code")) {
+    const previewAddonCount = (projectConfig.enabledAddons || []).reduce((sum, a) => sum + (ADDONS[a]?.skills.length ?? 0), 0);
+    const previewSkillLabel = previewAddonCount > 0 ? `${BASE_SKILL_COUNT} + ${previewAddonCount} addon skills` : `${BASE_SKILL_COUNT} skills`;
+    fileLines.push(`  ${symbols.star} Plugin ${chalk4.cyan(PLUGIN_NAME)} ${chalk4.dim(`(${previewSkillLabel}, 8 agents, 5 hooks)`)}`);
+  }
+  const generatedRules = generateArchitectureRules(projectConfig);
+  for (const ide of selectedIDEs) {
+    const ruleContent = generatedRules ? getRuleContentForIDE(ide, generatedRules) : null;
+    const ruleLines = ruleContent ? ruleContent.split("\n").length : 0;
+    const rulePath = DYNAMIC_RULE_FILES[ide]?.[0];
+    if (rulePath && ruleContent) {
+      fileLines.push(`  ${symbols.star} ${rulePath} ${chalk4.dim(`(${ruleLines} lines)`)}`);
+    }
+    const templateDir = join7(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (existsSync5(templateDir)) {
+      const files = getAllFilesRecursive(templateDir);
+      let templateFiles = files.filter((f) => !DYNAMIC_RULE_FILES[ide]?.includes(f));
+      if (ide === "claude-code") {
+        templateFiles = templateFiles.filter(
+          (f) => !f.startsWith(".claude/skills/") && !f.startsWith(".claude/agents/")
+        );
+      }
+      if (templateFiles.length > 0) {
+        fileLines.push(`  ${symbols.pass} ${ide} templates ${chalk4.dim(`(${templateFiles.length} files)`)}`);
+      }
+    }
+  }
+  fileLines.push(`  ${symbols.pass} thoughts/ ${chalk4.dim(`(${THOUGHTS_DIRS.length} directories)`)}`);
+  p3.note(fileLines.join("\n"), "Files to Generate");
+  if (generatedRules) {
+    const previewContent = generatedRules.claudeCode.split("\n").slice(0, 20).map((line) => chalk4.dim(line)).join("\n");
+    p3.note(previewContent + "\n" + chalk4.dim("..."), "Architecture Rules Preview");
+  } else {
+    p3.note(chalk4.dim("No architecture rules \u2014 quality checks only."), "Architecture Rules Preview");
+  }
+  p3.log.warn("This is a preview. No files were created.");
+  p3.log.info(`Run without ${chalk4.cyan("--preview")} to apply changes.`);
+  p3.outro("Preview complete");
+}
+function buildProjectConfigFromPreset(presetConfig, analysis) {
+  const qualityParts = [];
+  const pm = analysis.packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  if (analysis.scripts.typecheck) qualityParts.push(`${run} typecheck`);
+  if (analysis.scripts.lint) qualityParts.push(`${run} lint`);
+  if (analysis.scripts.test) qualityParts.push(`${run} test`);
+  const qualityCommand = qualityParts.length > 0 ? qualityParts.join(" && ") : `${run} typecheck && ${run} lint`;
+  return {
+    architecture: presetConfig.architecture || analysis.architecture.pattern,
+    layers: presetConfig.layers || analysis.architecture.layers,
+    stateManagement: presetConfig.stateManagement || analysis.stack.stateManagement,
+    dataFetching: presetConfig.dataFetching || analysis.stack.dataFetching,
+    orm: presetConfig.orm || analysis.stack.orm,
+    testing: presetConfig.testing || analysis.stack.testing,
+    ui: presetConfig.ui || analysis.stack.ui,
+    validation: presetConfig.validation || analysis.stack.validation,
+    framework: presetConfig.framework || analysis.framework.name,
+    qualityCommand
+  };
+}
+
+// src/commands/update.ts
+import { resolve as resolve3, join as join8, dirname as dirname3 } from "path";
+import { existsSync as existsSync6, unlinkSync, lstatSync, readdirSync, rmdirSync, chmodSync as chmodSync2 } from "fs";
+import * as p4 from "@clack/prompts";
+import chalk5 from "chalk";
+
+// src/data/removals.ts
+var REMOVED_FILES = {
+  ".claude/agents/db-reader.md": {
+    reason: "Replaced by database MCPs",
+    version: "1.6.1",
+    alternative: "Configure a database MCP like postgres-mcp or sqlite-mcp"
+  },
+  ".claude/skills/elegant.md": {
+    reason: "Converted to prompting tip",
+    version: "1.6.0",
+    alternative: 'Use the prompt: "Knowing everything you know now, implement the elegant solution"'
+  },
+  ".claude/skills/audit.md": {
+    reason: "Converted to directory skill with supporting files",
+    version: "1.7.1",
+    alternative: "Now at .claude/skills/audit/SKILL.md"
+  },
+  ".claude/skills/scaffold.md": {
+    reason: "Converted to directory skill with supporting files",
+    version: "1.7.1",
+    alternative: "Now at .claude/skills/scaffold/SKILL.md"
+  }
+};
+
+// src/commands/update.ts
+async function updateCommand(options) {
+  if (!options.check && !options.dryRun) {
+    ensureInteractive("update");
+  }
+  const targetDir = resolve3(options.path || ".");
+  p4.intro(introTitle("Update"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p4.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  const currentVersion = getCliVersion();
+  const installedVersion = manifest.version;
+  p4.log.info(`Installed version: ${installedVersion}`);
+  p4.log.info(`Current version: ${currentVersion}`);
+  const analysis = analyzeProject(targetDir);
+  const stackChanges = detectStackChanges(manifest.projectConfig, analysis);
+  if (stackChanges.length > 0) {
+    p4.note(
+      stackChanges.map((c) => `  ${symbols.warn} ${c}`).join("\n"),
+      "Stack Changes Detected"
+    );
+    if (!options.check) {
+      const regenerate = await p4.confirm({
+        message: "Regenerate rules with updated stack?",
+        initialValue: true
+      });
+      if (!p4.isCancel(regenerate) && regenerate) {
+        await regenerateWithNewStack(targetDir, manifest, analysis, options.dryRun);
+        return;
+      }
+    }
+  }
+  const shouldMigrate = manifest.selectedIDEs.includes("claude-code") && !manifest.installMode && hasStandaloneSkills(manifest);
+  if (shouldMigrate) {
+    p4.note(
+      "Claude Code skills/agents detected as standalone.\nThe new version uses plugin mode (namespace devtronic:).",
+      "Migration Available"
+    );
+    if (!options.check) {
+      const migrate = await p4.confirm({
+        message: "Migrate to plugin mode? (standalone \u2192 devtronic plugin)",
+        initialValue: true
+      });
+      if (!p4.isCancel(migrate) && migrate) {
+        await migrateToPlugin(targetDir, manifest, analysis, options.dryRun);
+        return;
+      }
+    }
+  }
+  if (options.check) {
+    if (installedVersion === currentVersion && stackChanges.length === 0 && !shouldMigrate) {
+      p4.log.success("Already up to date!");
+    } else if (shouldMigrate) {
+      p4.log.info("Plugin migration available: standalone \u2192 devtronic plugin");
+    } else if (installedVersion !== currentVersion) {
+      p4.log.info(`Update available: ${installedVersion} \u2192 ${currentVersion}`);
+    }
+    p4.outro("Check complete");
+    return;
+  }
+  const modifiedFiles = [];
+  const outdatedFiles = [];
+  for (const [relativePath, fileInfo] of Object.entries(manifest.files)) {
+    const filePath = join8(targetDir, relativePath);
+    if (!fileExists(filePath)) {
+      continue;
+    }
+    const currentContent = readFile(filePath);
+    const currentChecksum = calculateChecksum(currentContent);
+    if (currentChecksum !== fileInfo.originalChecksum) {
+      modifiedFiles.push(relativePath);
+    }
+  }
+  for (const ide of manifest.selectedIDEs) {
+    const templateDir = join8(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (!existsSync6(templateDir)) continue;
+    const files = getAllFilesRecursive(templateDir);
+    for (const file of files) {
+      const templatePath = join8(templateDir, file);
+      const templateContent = readFile(templatePath);
+      const templateChecksum = calculateChecksum(templateContent);
+      const fileInfo = manifest.files[file];
+      if (fileInfo && fileInfo.checksum !== templateChecksum) {
+        outdatedFiles.push(file);
+      }
+    }
+  }
+  const removedFromTemplate = [];
+  for (const [relativePath, fileInfo] of Object.entries(manifest.files)) {
+    if (fileInfo.ignored) continue;
+    let foundInAnyTemplate = false;
+    for (const ide of manifest.selectedIDEs) {
+      const templateDir = join8(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+      if (existsSync6(join8(templateDir, relativePath))) {
+        foundInAnyTemplate = true;
+        break;
+      }
+    }
+    if (!foundInAnyTemplate) {
+      const localPath = join8(targetDir, relativePath);
+      if (fileExists(localPath)) {
+        removedFromTemplate.push({
+          path: relativePath,
+          info: REMOVED_FILES[relativePath]
+        });
+      }
+    }
+  }
+  if (modifiedFiles.length > 0) {
+    p4.note(
+      modifiedFiles.map((f) => `  ${symbols.info} ${f}`).join("\n"),
+      "Locally Modified Files (will be preserved)"
+    );
+  }
+  if (outdatedFiles.length === 0 && removedFromTemplate.length === 0) {
+    p4.log.success("All files are up to date!");
+    p4.outro("No updates needed");
+    return;
+  }
+  const filesToUpdate = outdatedFiles.filter((f) => !modifiedFiles.includes(f));
+  if (filesToUpdate.length > 0) {
+    p4.note(
+      filesToUpdate.map((f) => `  ${symbols.updated} ${f}`).join("\n"),
+      "Files to Update"
+    );
+  }
+  const conflictFiles = outdatedFiles.filter((f) => modifiedFiles.includes(f));
+  if (conflictFiles.length > 0) {
+    p4.note(
+      conflictFiles.map((f) => `  ${symbols.warn} ${f}`).join("\n"),
+      "Conflicts (modified locally + template updated)"
+    );
+  }
+  let filesToDelete = [];
+  let filesToIgnore = [];
+  if (removedFromTemplate.length > 0) {
+    const removalDetails = removedFromTemplate.map((r) => {
+      const icon = symbols.fail;
+      const reason = r.info?.reason ? chalk5.dim(` - ${r.info.reason}`) : "";
+      return `  ${icon} ${r.path}${reason}`;
+    }).join("\n");
+    p4.note(removalDetails, "Files Removed in This Version");
+    if (!options.dryRun) {
+      const action = await p4.select({
+        message: "What do you want to do with removed files?",
+        options: [
+          {
+            value: "delete",
+            label: "Delete them (recommended)",
+            hint: "Clean up obsolete files"
+          },
+          { value: "keep", label: "Keep them", hint: "Files will be ignored in future updates" },
+          { value: "review", label: "Review each file", hint: "Decide file by file" }
+        ]
+      });
+      if (p4.isCancel(action)) {
+        p4.cancel("Update cancelled");
+        process.exit(0);
+      }
+      if (action === "delete") {
+        filesToDelete = removedFromTemplate.map((r) => r.path);
+      } else if (action === "keep") {
+        filesToIgnore = removedFromTemplate.map((r) => r.path);
+      } else if (action === "review") {
+        for (const removed of removedFromTemplate) {
+          const alternative = removed.info?.alternative ? chalk5.dim(`
+  Alternative: ${removed.info.alternative}`) : "";
+          const fileAction = await p4.select({
+            message: `${removed.path}${alternative}`,
+            options: [
+              { value: "delete", label: "Delete" },
+              { value: "keep", label: "Keep (ignore in future)" }
+            ]
+          });
+          if (p4.isCancel(fileAction)) {
+            p4.cancel("Update cancelled");
+            process.exit(0);
+          }
+          if (fileAction === "delete") {
+            filesToDelete.push(removed.path);
+          } else {
+            filesToIgnore.push(removed.path);
+          }
+        }
+      }
+    }
+  }
+  if (options.dryRun) {
+    p4.outro("Dry run complete - no changes made");
+    return;
+  }
+  const hasUpdates = filesToUpdate.length > 0;
+  const hasDeletions = filesToDelete.length > 0;
+  const hasIgnores = filesToIgnore.length > 0;
+  if (!hasUpdates && !hasDeletions && !hasIgnores) {
+    p4.log.success("No changes to apply");
+    p4.outro("Update complete");
+    return;
+  }
+  const actionParts = [];
+  if (hasUpdates) actionParts.push(`update ${filesToUpdate.length} files`);
+  if (hasDeletions) actionParts.push(`delete ${filesToDelete.length} files`);
+  if (hasIgnores) actionParts.push(`ignore ${filesToIgnore.length} files`);
+  const proceed = await p4.confirm({
+    message: `Proceed to ${actionParts.join(", ")}?`,
+    initialValue: true
+  });
+  if (p4.isCancel(proceed) || !proceed) {
+    p4.cancel("Update cancelled");
+    process.exit(0);
+  }
+  const spinner8 = p4.spinner();
+  spinner8.start("Applying updates...");
+  const updatedManifest = {
+    ...manifest,
+    version: currentVersion,
+    implantedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  };
+  for (const ide of manifest.selectedIDEs) {
+    const templateDir = join8(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (!existsSync6(templateDir)) continue;
+    const isPluginMode = ide === "claude-code" && manifest.installMode === "plugin";
+    const files = getAllFilesRecursive(templateDir);
+    for (const file of files) {
+      if (modifiedFiles.includes(file)) {
+        continue;
+      }
+      if (isPluginMode && (file.startsWith(".claude/skills/") || file.startsWith(".claude/agents/"))) {
+        continue;
+      }
+      const templatePath = join8(templateDir, file);
+      const destPath = join8(targetDir, file);
+      const templateContent = readFile(templatePath);
+      ensureDir(dirname3(destPath));
+      writeFile(destPath, templateContent);
+      updatedManifest.files[file] = createManifestEntry(templateContent);
+    }
+  }
+  if (manifest.installMode === "plugin" && manifest.pluginPath) {
+    const userModifiedPluginFiles = /* @__PURE__ */ new Map();
+    for (const [relPath, fileInfo] of Object.entries(updatedManifest.files)) {
+      const filePath = join8(targetDir, relPath);
+      if (!fileExists(filePath)) continue;
+      const diskContent = readFile(filePath);
+      const diskChecksum = calculateChecksum(diskContent);
+      if (diskChecksum !== fileInfo.originalChecksum) {
+        userModifiedPluginFiles.set(relPath, diskContent);
+      }
+    }
+    const config = manifest.projectConfig || buildDefaultConfig(analysis);
+    const pluginResult = generatePlugin(
+      targetDir,
+      TEMPLATES_DIR,
+      currentVersion,
+      config,
+      analysis.packageManager
+    );
+    for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
+      const scriptPath = join8(targetDir, pluginResult.pluginPath, "scripts", script);
+      if (existsSync6(scriptPath)) {
+        chmodSync2(scriptPath, 493);
+      }
+    }
+    for (const [relPath, content] of userModifiedPluginFiles) {
+      writeFile(join8(targetDir, relPath), content);
+    }
+    for (const [relPath, newEntry] of Object.entries(pluginResult.files)) {
+      if (userModifiedPluginFiles.has(relPath)) {
+        continue;
+      }
+      updatedManifest.files[relPath] = newEntry;
+    }
+    updatedManifest.pluginPath = pluginResult.pluginPath;
+  }
+  for (const filePath of filesToDelete) {
+    const localPath = join8(targetDir, filePath);
+    if (fileExists(localPath)) {
+      unlinkSync(localPath);
+    }
+    delete updatedManifest.files[filePath];
+  }
+  for (const filePath of filesToIgnore) {
+    if (updatedManifest.files[filePath]) {
+      updatedManifest.files[filePath].ignored = true;
+    }
+  }
+  const claudeMdPath = join8(targetDir, "CLAUDE.md");
+  if (fileExists(claudeMdPath)) {
+    const stat = lstatSync(claudeMdPath);
+    if (stat.isSymbolicLink()) {
+      const content = readFile(claudeMdPath);
+      unlinkSync(claudeMdPath);
+      writeFile(claudeMdPath, content);
+      updatedManifest.files["CLAUDE.md"] = createManifestEntry(content);
+      p4.log.info("Migrated CLAUDE.md from symlink to independent file.");
+    }
+  }
+  writeManifest(targetDir, updatedManifest);
+  spinner8.stop("Updates applied");
+  p4.outro(chalk5.green(`Updated to version ${currentVersion}`));
+}
+function detectStackChanges(savedConfig, analysis) {
+  if (!savedConfig) return [];
+  const changes = [];
+  const newStateLibs = analysis.stack.stateManagement.filter(
+    (lib) => !savedConfig.stateManagement.includes(lib)
+  );
+  const removedStateLibs = savedConfig.stateManagement.filter(
+    (lib) => !analysis.stack.stateManagement.includes(lib)
+  );
+  if (newStateLibs.length > 0) {
+    changes.push(`Added state management: ${newStateLibs.join(", ")}`);
+  }
+  if (removedStateLibs.length > 0) {
+    changes.push(`Removed state management: ${removedStateLibs.join(", ")}`);
+  }
+  const newDataLibs = analysis.stack.dataFetching.filter(
+    (lib) => !savedConfig.dataFetching.includes(lib)
+  );
+  const removedDataLibs = savedConfig.dataFetching.filter(
+    (lib) => !analysis.stack.dataFetching.includes(lib)
+  );
+  if (newDataLibs.length > 0) {
+    changes.push(`Added data fetching: ${newDataLibs.join(", ")}`);
+  }
+  if (removedDataLibs.length > 0) {
+    changes.push(`Removed data fetching: ${removedDataLibs.join(", ")}`);
+  }
+  const newOrmLibs = analysis.stack.orm.filter((lib) => !savedConfig.orm.includes(lib));
+  const removedOrmLibs = savedConfig.orm.filter((lib) => !analysis.stack.orm.includes(lib));
+  if (newOrmLibs.length > 0) {
+    changes.push(`Added ORM: ${newOrmLibs.join(", ")}`);
+  }
+  if (removedOrmLibs.length > 0) {
+    changes.push(`Removed ORM: ${removedOrmLibs.join(", ")}`);
+  }
+  const newTestLibs = analysis.stack.testing.filter((lib) => !savedConfig.testing.includes(lib));
+  const removedTestLibs = savedConfig.testing.filter(
+    (lib) => !analysis.stack.testing.includes(lib)
+  );
+  if (newTestLibs.length > 0) {
+    changes.push(`Added testing: ${newTestLibs.join(", ")}`);
+  }
+  if (removedTestLibs.length > 0) {
+    changes.push(`Removed testing: ${removedTestLibs.join(", ")}`);
+  }
+  const newUILibs = analysis.stack.ui.filter((lib) => !savedConfig.ui.includes(lib));
+  const removedUILibs = savedConfig.ui.filter((lib) => !analysis.stack.ui.includes(lib));
+  if (newUILibs.length > 0) {
+    changes.push(`Added UI: ${newUILibs.join(", ")}`);
+  }
+  if (removedUILibs.length > 0) {
+    changes.push(`Removed UI: ${removedUILibs.join(", ")}`);
+  }
+  const newValidationLibs = analysis.stack.validation.filter(
+    (lib) => !savedConfig.validation.includes(lib)
+  );
+  const removedValidationLibs = savedConfig.validation.filter(
+    (lib) => !analysis.stack.validation.includes(lib)
+  );
+  if (newValidationLibs.length > 0) {
+    changes.push(`Added validation: ${newValidationLibs.join(", ")}`);
+  }
+  if (removedValidationLibs.length > 0) {
+    changes.push(`Removed validation: ${removedValidationLibs.join(", ")}`);
+  }
+  return changes;
+}
+async function regenerateWithNewStack(targetDir, manifest, analysis, dryRun) {
+  const pm = analysis.packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  const qualityParts = [];
+  if (analysis.scripts.typecheck) qualityParts.push(`${run} typecheck`);
+  if (analysis.scripts.lint) qualityParts.push(`${run} lint`);
+  if (analysis.scripts.test) qualityParts.push(`${run} test`);
+  const newConfig = {
+    architecture: manifest.projectConfig?.architecture || analysis.architecture.pattern,
+    layers: manifest.projectConfig?.layers || analysis.architecture.layers,
+    stateManagement: analysis.stack.stateManagement,
+    dataFetching: analysis.stack.dataFetching,
+    orm: analysis.stack.orm,
+    testing: analysis.stack.testing,
+    ui: analysis.stack.ui,
+    validation: analysis.stack.validation,
+    framework: analysis.framework.name,
+    qualityCommand: qualityParts.length > 0 ? qualityParts.join(" && ") : `${run} typecheck && ${run} lint`,
+    enabledAddons: manifest.projectConfig?.enabledAddons
+  };
+  p4.note(
+    [
+      formatKV("State:", newConfig.stateManagement.join(", ") || chalk5.dim("none")),
+      formatKV("Data:", newConfig.dataFetching.join(", ") || chalk5.dim("none")),
+      formatKV("ORM:", newConfig.orm.join(", ") || chalk5.dim("none")),
+      formatKV("Testing:", newConfig.testing.join(", ") || chalk5.dim("none"))
+    ].join("\n"),
+    "New Configuration"
+  );
+  if (dryRun) {
+    p4.log.info("Dry run - no changes made");
+    p4.outro("Dry run complete");
+    return;
+  }
+  const spinner8 = p4.spinner();
+  spinner8.start("Regenerating with new stack...");
+  const regeneratedFiles = [];
+  const agentsMdPath = join8(targetDir, "AGENTS.md");
+  if (fileExists(agentsMdPath)) {
+    const agentsMdContent = generateAgentsMdFromConfig(
+      newConfig,
+      analysis.scripts,
+      analysis.packageManager
+    );
+    writeFile(agentsMdPath, agentsMdContent);
+    regeneratedFiles.push("AGENTS.md");
+    manifest.files["AGENTS.md"] = createManifestEntry(agentsMdContent);
+  }
+  const claudeMdPath = join8(targetDir, "CLAUDE.md");
+  if (fileExists(claudeMdPath)) {
+    const stat = lstatSync(claudeMdPath);
+    if (stat.isSymbolicLink()) {
+      const content = readFile(claudeMdPath);
+      unlinkSync(claudeMdPath);
+      writeFile(claudeMdPath, content);
+      manifest.files["CLAUDE.md"] = createManifestEntry(content);
+      p4.log.info("Migrated CLAUDE.md from symlink to independent file.");
+    }
+  }
+  const generatedRules = generateArchitectureRules(newConfig);
+  if (generatedRules) {
+    for (const ide of manifest.selectedIDEs) {
+      const ruleContent = getRuleContentForIDE(ide, generatedRules);
+      const rulePath = DYNAMIC_RULE_FILES[ide]?.[0];
+      if (ruleContent && rulePath) {
+        const destPath = join8(targetDir, rulePath);
+        ensureDir(dirname3(destPath));
+        writeFile(destPath, ruleContent);
+        regeneratedFiles.push(rulePath);
+        manifest.files[rulePath] = createManifestEntry(ruleContent);
+      }
+    }
+  }
+  if (manifest.installMode === "plugin" && manifest.pluginPath) {
+    const userModifiedPluginFiles = /* @__PURE__ */ new Map();
+    for (const [relPath, fileInfo] of Object.entries(manifest.files)) {
+      const filePath = join8(targetDir, relPath);
+      if (!fileExists(filePath)) continue;
+      const diskContent = readFile(filePath);
+      const diskChecksum = calculateChecksum(diskContent);
+      if (diskChecksum !== fileInfo.originalChecksum) {
+        userModifiedPluginFiles.set(relPath, diskContent);
+      }
+    }
+    const pluginResult = generatePlugin(
+      targetDir,
+      TEMPLATES_DIR,
+      getCliVersion(),
+      newConfig,
+      analysis.packageManager
+    );
+    for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
+      const scriptPath = join8(targetDir, pluginResult.pluginPath, "scripts", script);
+      if (existsSync6(scriptPath)) {
+        chmodSync2(scriptPath, 493);
+      }
+    }
+    for (const [relPath, content] of userModifiedPluginFiles) {
+      writeFile(join8(targetDir, relPath), content);
+    }
+    for (const [relPath, newEntry] of Object.entries(pluginResult.files)) {
+      if (userModifiedPluginFiles.has(relPath)) {
+        continue;
+      }
+      manifest.files[relPath] = newEntry;
+    }
+    regeneratedFiles.push("Plugin hooks & scripts (devtronic)");
+  }
+  manifest.projectConfig = newConfig;
+  manifest.version = getCliVersion();
+  manifest.implantedAt = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  writeManifest(targetDir, manifest);
+  spinner8.stop("Regeneration complete");
+  p4.note(
+    regeneratedFiles.map((f) => `  ${symbols.star} ${f}`).join("\n"),
+    "Regenerated"
+  );
+  p4.outro(chalk5.green("Updated with new stack!"));
+}
+function hasStandaloneSkills(manifest) {
+  return Object.keys(manifest.files).some(
+    (f) => f.startsWith(".claude/skills/") || f.startsWith(".claude/agents/")
+  );
+}
+async function migrateToPlugin(targetDir, manifest, analysis, dryRun) {
+  if (dryRun) {
+    p4.log.info("Would migrate standalone skills/agents to devtronic plugin.");
+    p4.outro("Dry run complete \u2014 no changes made");
+    return;
+  }
+  const spinner8 = p4.spinner();
+  spinner8.start("Migrating to plugin mode...");
+  const config = manifest.projectConfig || buildDefaultConfig(analysis);
+  const pluginResult = generatePlugin(
+    targetDir,
+    TEMPLATES_DIR,
+    getCliVersion(),
+    config,
+    analysis.packageManager
+  );
+  for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
+    const scriptPath = join8(targetDir, pluginResult.pluginPath, "scripts", script);
+    if (existsSync6(scriptPath)) {
+      chmodSync2(scriptPath, 493);
+    }
+  }
+  registerPlugin(targetDir, PLUGIN_NAME, MARKETPLACE_NAME, PLUGIN_DIR);
+  const removed = [];
+  const preserved = [];
+  for (const [path, fileInfo] of Object.entries(manifest.files)) {
+    if (!path.startsWith(".claude/skills/") && !path.startsWith(".claude/agents/")) continue;
+    const filePath = join8(targetDir, path);
+    if (!fileExists(filePath)) continue;
+    const current = calculateChecksum(readFile(filePath));
+    if (current === fileInfo.originalChecksum) {
+      unlinkSync(filePath);
+      delete manifest.files[path];
+      removed.push(path);
+    } else {
+      preserved.push(path);
+    }
+  }
+  cleanEmptyDirs(join8(targetDir, ".claude", "skills"));
+  cleanEmptyDirs(join8(targetDir, ".claude", "agents"));
+  Object.assign(manifest.files, pluginResult.files);
+  manifest.installMode = "plugin";
+  manifest.pluginPath = pluginResult.pluginPath;
+  manifest.version = getCliVersion();
+  manifest.implantedAt = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  writeManifest(targetDir, manifest);
+  spinner8.stop("Migration complete");
+  if (removed.length > 0) {
+    p4.note(
+      removed.map((f) => `  ${symbols.fail} ${f}`).join("\n"),
+      "Standalone files removed"
+    );
+  }
+  if (preserved.length > 0) {
+    p4.note(
+      preserved.map((f) => `  ${symbols.info} ${f} (modified \u2014 preserved)`).join("\n"),
+      "User-modified files preserved"
+    );
+  }
+  p4.note(
+    `  Plugin: ${chalk5.cyan("devtronic")} at .claude-plugins/devtronic/
+  Skills: /devtronic:brief, /devtronic:spec, ...
+  Hooks: 5 workflow hooks enabled`,
+    "Plugin Generated"
+  );
+  p4.outro(chalk5.green("Migrated to plugin mode!"));
+}
+function buildDefaultConfig(analysis) {
+  const pm = analysis.packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  const qualityParts = [];
+  if (analysis.scripts.typecheck) qualityParts.push(`${run} typecheck`);
+  if (analysis.scripts.lint) qualityParts.push(`${run} lint`);
+  if (analysis.scripts.test) qualityParts.push(`${run} test`);
+  return {
+    architecture: analysis.architecture.pattern,
+    layers: analysis.architecture.layers,
+    stateManagement: analysis.stack.stateManagement,
+    dataFetching: analysis.stack.dataFetching,
+    orm: analysis.stack.orm,
+    testing: analysis.stack.testing,
+    ui: analysis.stack.ui,
+    validation: analysis.stack.validation,
+    framework: analysis.framework.name,
+    qualityCommand: qualityParts.length > 0 ? qualityParts.join(" && ") : `${run} typecheck && ${run} lint`
+  };
+}
+function cleanEmptyDirs(dirPath) {
+  if (!existsSync6(dirPath)) return;
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join8(dirPath, entry);
+    if (existsSync6(fullPath) && lstatSync(fullPath).isDirectory()) {
+      cleanEmptyDirs(fullPath);
+    }
+  }
+  const remaining = readdirSync(dirPath);
+  if (remaining.length === 0) {
+    rmdirSync(dirPath);
+  }
+}
+
+// src/commands/status.ts
+import { resolve as resolve4, join as join9 } from "path";
+import * as p5 from "@clack/prompts";
+import chalk6 from "chalk";
+async function statusCommand(options = {}) {
+  const targetDir = resolve4(options.path || ".");
+  p5.intro(introTitle("Status"));
+  const manifest = readManifest(targetDir);
+  const latestPromise = getLatestVersion("devtronic");
+  if (!manifest) {
+    p5.log.warn("No installation found in this directory.");
+    p5.log.info("Run `npx devtronic init` to set up.");
+    p5.outro("");
+    return;
+  }
+  p5.note(
+    [
+      formatKV("Version:", manifest.version),
+      formatKV("Installed:", manifest.implantedAt),
+      formatKV("IDEs:", manifest.selectedIDEs.join(", "))
+    ].join("\n"),
+    "Installation Info"
+  );
+  const fileStatuses = [];
+  for (const [relativePath, fileInfo] of Object.entries(manifest.files)) {
+    const filePath = join9(targetDir, relativePath);
+    if (!fileExists(filePath)) {
+      fileStatuses.push({ path: relativePath, status: "missing" });
+      continue;
+    }
+    const currentContent = readFile(filePath);
+    const currentChecksum = calculateChecksum(currentContent);
+    if (currentChecksum !== fileInfo.originalChecksum) {
+      fileStatuses.push({ path: relativePath, status: "modified" });
+    } else {
+      fileStatuses.push({ path: relativePath, status: "ok" });
+    }
+  }
+  const okFiles = fileStatuses.filter((f) => f.status === "ok");
+  const modifiedFiles = fileStatuses.filter((f) => f.status === "modified");
+  const missingFiles = fileStatuses.filter((f) => f.status === "missing");
+  const summaryLines = [
+    `${symbols.pass} ${okFiles.length} unchanged`,
+    `${symbols.warn} ${modifiedFiles.length} modified`,
+    `${symbols.fail} ${missingFiles.length} missing`
+  ];
+  p5.note(summaryLines.join("\n"), "File Status");
+  if (modifiedFiles.length > 0) {
+    p5.note(
+      modifiedFiles.map((f) => `  ${symbols.warn} ${f.path}`).join("\n"),
+      "Modified Files"
+    );
+  }
+  if (missingFiles.length > 0) {
+    p5.note(
+      missingFiles.map((f) => `  ${symbols.fail} ${f.path}`).join("\n"),
+      "Missing Files"
+    );
+  }
+  const currentVersion = getCliVersion();
+  const latest = await latestPromise;
+  if (latest && compareSemver(currentVersion, latest) < 0) {
+    p5.log.warn(
+      `Update available: ${currentVersion} ${chalk6.dim("\u2192")} ${chalk6.cyan(latest)}
+  Run ${chalk6.cyan("npx devtronic@latest init")} to upgrade.`
+    );
+  }
+  p5.outro("");
+}
+
+// src/commands/diff.ts
+import { resolve as resolve5, join as join10 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import * as p6 from "@clack/prompts";
+import chalk7 from "chalk";
+async function diffCommand(options = {}) {
+  const targetDir = resolve5(options.path || ".");
+  p6.intro(introTitle("Diff"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p6.log.warn("No installation found in this directory.");
+    p6.log.info("Run `npx devtronic init` to set up.");
+    p6.outro("");
+    return;
+  }
+  const diffs = [];
+  for (const ide of manifest.selectedIDEs) {
+    const templateDir = join10(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (!existsSync7(templateDir)) continue;
+    const templateFiles = getAllFilesRecursive(templateDir);
+    for (const file of templateFiles) {
+      const templatePath = join10(templateDir, file);
+      const localPath = join10(targetDir, file);
+      const templateContent = readFile(templatePath);
+      const templateChecksum = calculateChecksum(templateContent);
+      const manifestEntry = manifest.files[file];
+      if (!fileExists(localPath)) {
+        diffs.push({ path: file, type: "removed" });
+      } else {
+        const localContent = readFile(localPath);
+        const localChecksum = calculateChecksum(localContent);
+        const localModified = manifestEntry ? localChecksum !== manifestEntry.originalChecksum : false;
+        if (manifestEntry && manifestEntry.checksum !== templateChecksum) {
+          diffs.push({ path: file, type: "modified", localModified });
+        } else if (!manifestEntry) {
+          diffs.push({ path: file, type: "added" });
+        }
+      }
+    }
+  }
+  if (diffs.length === 0) {
+    p6.log.success("No differences with template.");
+    p6.outro("");
+    return;
+  }
+  const added = diffs.filter((d) => d.type === "added");
+  const removed = diffs.filter((d) => d.type === "removed");
+  const modified = diffs.filter((d) => d.type === "modified");
+  if (added.length > 0) {
+    p6.note(
+      added.map((d) => `  ${chalk7.green("+")} ${d.path}`).join("\n"),
+      "New in Template"
+    );
+  }
+  if (removed.length > 0) {
+    p6.note(
+      removed.map((d) => `  ${chalk7.red("-")} ${d.path}`).join("\n"),
+      "Removed Locally"
+    );
+  }
+  if (modified.length > 0) {
+    p6.note(
+      modified.map((d) => {
+        const marker = d.localModified ? symbols.warn : symbols.updated;
+        const suffix = d.localModified ? " (also modified locally)" : "";
+        return `  ${marker} ${d.path}${chalk7.dim(suffix)}`;
+      }).join("\n"),
+      "Template Updated"
+    );
+  }
+  p6.log.info(`Run ${chalk7.cyan("npx devtronic update")} to apply changes.`);
+  p6.outro("");
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve6, join as join11, dirname as dirname4 } from "path";
+import * as p7 from "@clack/prompts";
+import chalk8 from "chalk";
+var ALL_IDES = [
+  { value: "claude-code", label: "Claude Code" },
+  { value: "cursor", label: "Cursor" },
+  { value: "opencode", label: "OpenCode" },
+  { value: "antigravity", label: "Google Antigravity" },
+  { value: "github-copilot", label: "GitHub Copilot" }
+];
+async function addCommand(ide, options) {
+  if (!options.yes) {
+    ensureInteractive("add");
+  }
+  const targetDir = resolve6(options.path || ".");
+  p7.intro(introTitle("Add IDE"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p7.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  if (!manifest.projectConfig) {
+    p7.cancel(
+      "Manifest is missing project configuration. Run `npx devtronic init` to reconfigure."
+    );
+    process.exit(1);
+  }
+  let selectedIDE;
+  if (ide) {
+    const validIDE = ALL_IDES.find((i) => i.value === ide);
+    if (!validIDE) {
+      p7.cancel(
+        `Unknown IDE: ${ide}
+
+Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
+      );
+      process.exit(1);
+    }
+    selectedIDE = validIDE.value;
+  } else {
+    const alreadyInstalled = manifest.selectedIDEs;
+    const availableIDEs = ALL_IDES.filter((i) => !alreadyInstalled.includes(i.value));
+    if (availableIDEs.length === 0) {
+      p7.log.success("All IDEs are already configured!");
+      p7.outro("Nothing to add");
+      return;
+    }
+    const selection = await p7.select({
+      message: "Which IDE do you want to add?",
+      options: availableIDEs.map((ide2) => ({
+        value: ide2.value,
+        label: ide2.label
+      }))
+    });
+    if (p7.isCancel(selection)) {
+      p7.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    selectedIDE = selection;
+  }
+  if (manifest.selectedIDEs.includes(selectedIDE)) {
+    p7.log.warn(`${selectedIDE} is already configured.`);
+    if (!options.yes) {
+      const proceed = await p7.confirm({
+        message: "Reinstall/update configuration?",
+        initialValue: false
+      });
+      if (p7.isCancel(proceed) || !proceed) {
+        p7.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+  }
+  const analysis = analyzeProject(targetDir);
+  const ideConfigExists = analysis.existingConfigs[selectedIDE];
+  let conflictResolution = "replace";
+  if (ideConfigExists && !options.yes) {
+    const resolution = await promptForConflictResolution(selectedIDE);
+    if (p7.isCancel(resolution)) {
+      p7.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    conflictResolution = resolution;
+  } else if (ideConfigExists) {
+    conflictResolution = "merge";
+  }
+  const spinner8 = p7.spinner();
+  spinner8.start(`Adding ${selectedIDE} configuration...`);
+  const appliedFiles = [];
+  const skippedFiles = [];
+  const mergedFiles = [];
+  const generatedFiles = [];
+  const generatedRules = generateArchitectureRules(manifest.projectConfig);
+  const templateName = IDE_TEMPLATE_MAP[selectedIDE];
+  const templateDir = join11(TEMPLATES_DIR, templateName);
+  if (!existsSync8(templateDir)) {
+    spinner8.stop("Error");
+    p7.cancel(`Template not found: ${templateName}`);
+    process.exit(1);
+  }
+  const files = getAllFilesRecursive(templateDir);
+  const dynamicFiles = DYNAMIC_RULE_FILES[selectedIDE] || [];
+  for (const file of files) {
+    if (dynamicFiles.includes(file)) {
+      continue;
+    }
+    const sourcePath = join11(templateDir, file);
+    const destPath = join11(targetDir, file);
+    const sourceContent = readFile(sourcePath);
+    if (fileExists(destPath)) {
+      if (conflictResolution === "keep") {
+        skippedFiles.push(file);
+        continue;
+      }
+      if (conflictResolution === "merge") {
+        const existingContent = readFile(destPath);
+        const strategy = getMergeStrategy(file);
+        const mergedContent = mergeFile(existingContent, sourceContent, strategy);
+        writeFile(destPath, mergedContent);
+        mergedFiles.push(file);
+        manifest.files[file] = createManifestEntry(mergedContent);
+        continue;
+      }
+    }
+    ensureDir(dirname4(destPath));
+    writeFile(destPath, sourceContent);
+    appliedFiles.push(file);
+    manifest.files[file] = createManifestEntry(sourceContent);
+  }
+  const ruleContent = generatedRules ? getRuleContentForIDE(selectedIDE, generatedRules) : null;
+  if (ruleContent) {
+    const rulePath = dynamicFiles[0];
+    if (rulePath) {
+      const destPath = join11(targetDir, rulePath);
+      if (fileExists(destPath) && conflictResolution === "keep") {
+        skippedFiles.push(rulePath);
+      } else if (fileExists(destPath) && conflictResolution === "merge") {
+        const existingContent = readFile(destPath);
+        const strategy = getMergeStrategy(rulePath);
+        const mergedContent = mergeFile(existingContent, ruleContent, strategy);
+        writeFile(destPath, mergedContent);
+        mergedFiles.push(rulePath);
+        manifest.files[rulePath] = createManifestEntry(mergedContent);
+      } else {
+        ensureDir(dirname4(destPath));
+        writeFile(destPath, ruleContent);
+        generatedFiles.push(`${rulePath} (personalized)`);
+        manifest.files[rulePath] = createManifestEntry(ruleContent);
+      }
+    }
+  }
+  if (!manifest.selectedIDEs.includes(selectedIDE)) {
+    manifest.selectedIDEs.push(selectedIDE);
+  }
+  manifest.version = getCliVersion();
+  writeManifest(targetDir, manifest);
+  spinner8.stop("Configuration added");
+  if (generatedFiles.length > 0) {
+    p7.note(
+      generatedFiles.map((f) => `  ${symbols.star} ${f}`).join("\n"),
+      "Generated (personalized)"
+    );
+  }
+  if (appliedFiles.length > 0) {
+    p7.note(
+      appliedFiles.map((f) => `  ${symbols.pass} ${f}`).join("\n"),
+      "Created/Updated"
+    );
+  }
+  if (mergedFiles.length > 0) {
+    p7.note(
+      mergedFiles.map((f) => `  ${symbols.merged} ${f}`).join("\n"),
+      "Merged"
+    );
+  }
+  if (skippedFiles.length > 0) {
+    p7.note(
+      skippedFiles.map((f) => `  ${symbols.skipped} ${f}`).join("\n"),
+      "Skipped (existing)"
+    );
+  }
+  p7.outro(chalk8.green(`${selectedIDE} configuration added!`));
+}
+
+// src/commands/regenerate.ts
+import { existsSync as existsSync9 } from "fs";
+import { resolve as resolve7, join as join12, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import * as p8 from "@clack/prompts";
+import chalk9 from "chalk";
+var __filename = fileURLToPath3(import.meta.url);
+var __regen_dirname = dirname5(__filename);
+var TEMPLATES_DIR2 = existsSync9(resolve7(__regen_dirname, "../templates")) ? resolve7(__regen_dirname, "../templates") : resolve7(__regen_dirname, "../../templates");
+async function regenerateCommand(target, options) {
+  ensureInteractive("regenerate");
+  const targetDir = resolve7(options.path || ".");
+  p8.intro(introTitle("Regenerate"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p8.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  let regenerateAgentsMd = false;
+  let regenerateClaudeMd = false;
+  let regenerateRules = false;
+  let regeneratePlugin = false;
+  if (target === "CLAUDE.md" || target === "claude") {
+    regenerateClaudeMd = true;
+  } else if (target === "AGENTS.md" || target === "agents") {
+    regenerateAgentsMd = true;
+  } else if (options.claude) {
+    regenerateClaudeMd = true;
+  } else if (options.rules) {
+    regenerateRules = true;
+  } else if (options.agents || target === "agents-md") {
+    regenerateAgentsMd = true;
+  } else if (options.plugin) {
+    regeneratePlugin = true;
+  } else if (options.all) {
+    regenerateAgentsMd = true;
+    regenerateClaudeMd = true;
+    regenerateRules = true;
+    regeneratePlugin = true;
+  } else if (target) {
+    if (target.includes("architecture") || target.includes("rules")) {
+      regenerateRules = true;
+    } else {
+      p8.cancel(
+        `Unknown target: ${target}
+
+Valid options:
+  CLAUDE.md       Regenerate CLAUDE.md (overwrites self-improvements)
+  AGENTS.md       Regenerate AGENTS.md
+  --rules         Regenerate architecture rules for all IDEs
+  --plugin        Regenerate Claude Code plugin (skills, agents, hooks)
+  --all           Regenerate everything`
+      );
+      process.exit(1);
+    }
+  } else {
+    const selection = await p8.multiselect({
+      message: "What do you want to regenerate?",
+      options: [
+        {
+          value: "claude",
+          label: "CLAUDE.md",
+          hint: "WARNING: overwrites self-improvements"
+        },
+        { value: "agents", label: "AGENTS.md", hint: "Universal AI context" },
+        { value: "rules", label: "Architecture rules", hint: "For all configured IDEs" },
+        { value: "plugin", label: "Plugin", hint: "Skills, agents, hooks (Claude Code only)" }
+      ],
+      required: true
+    });
+    if (p8.isCancel(selection)) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    regenerateClaudeMd = selection.includes("claude");
+    regenerateAgentsMd = selection.includes("agents");
+    regenerateRules = selection.includes("rules");
+    regeneratePlugin = selection.includes("plugin");
+  }
+  if (!regenerateAgentsMd && !regenerateRules && !regenerateClaudeMd && !regeneratePlugin) {
+    p8.log.warn("Nothing selected to regenerate.");
+    p8.outro("No changes made");
+    return;
+  }
+  if (regenerateClaudeMd) {
+    const claudeMdPath = join12(targetDir, "CLAUDE.md");
+    if (fileExists(claudeMdPath)) {
+      p8.log.warn(
+        "Regenerating CLAUDE.md will overwrite any self-improvements (Gotchas section)."
+      );
+      const confirm9 = await p8.confirm({
+        message: "Are you sure you want to regenerate CLAUDE.md?",
+        initialValue: false
+      });
+      if (p8.isCancel(confirm9) || !confirm9) {
+        regenerateClaudeMd = false;
+        p8.log.info("Skipping CLAUDE.md regeneration.");
+        if (!regenerateAgentsMd && !regenerateRules && !regeneratePlugin) {
+          p8.outro("No changes made");
+          return;
+        }
+      }
+    }
+  }
+  const spinner8 = p8.spinner();
+  spinner8.start("Re-analyzing project...");
+  const analysis = analyzeProject(targetDir);
+  spinner8.stop("Project analyzed");
+  p8.log.info("The project will be re-analyzed. Confirm the configuration:");
+  const projectConfigResult = await promptForProjectConfig(analysis, false);
+  if (p8.isCancel(projectConfigResult)) {
+    p8.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const projectConfig = projectConfigResult;
+  const fullProjectConfig = {
+    ...projectConfig,
+    enabledAddons: manifest.projectConfig?.enabledAddons
+  };
+  spinner8.start("Regenerating files...");
+  const regeneratedFiles = [];
+  if (regenerateClaudeMd) {
+    const claudeMdPath = join12(targetDir, "CLAUDE.md");
+    const claudeMdContent = generateClaudeMd(
+      fullProjectConfig,
+      analysis.scripts,
+      analysis.packageManager
+    );
+    writeFile(claudeMdPath, claudeMdContent);
+    regeneratedFiles.push("CLAUDE.md");
+    manifest.files["CLAUDE.md"] = createManifestEntry(claudeMdContent);
+  }
+  if (regenerateAgentsMd) {
+    const agentsMdPath = join12(targetDir, "AGENTS.md");
+    const agentsMdContent = generateAgentsMdFromConfig(
+      fullProjectConfig,
+      analysis.scripts,
+      analysis.packageManager
+    );
+    writeFile(agentsMdPath, agentsMdContent);
+    regeneratedFiles.push("AGENTS.md");
+    manifest.files["AGENTS.md"] = createManifestEntry(agentsMdContent);
+  }
+  if (regenerateRules) {
+    const generatedRules = generateArchitectureRules(fullProjectConfig);
+    if (generatedRules) {
+      for (const ide of manifest.selectedIDEs) {
+        const ruleContent = getRuleContentForIDE(ide, generatedRules);
+        const rulePath = DYNAMIC_RULE_FILES[ide]?.[0];
+        if (ruleContent && rulePath) {
+          const destPath = join12(targetDir, rulePath);
+          ensureDir(dirname5(destPath));
+          writeFile(destPath, ruleContent);
+          regeneratedFiles.push(rulePath);
+          manifest.files[rulePath] = createManifestEntry(ruleContent);
+        }
+      }
+    } else {
+      p8.log.info('Architecture is set to "none" \u2014 skipping rule generation.');
+    }
+  }
+  if (regeneratePlugin) {
+    if (!manifest.selectedIDEs.includes("claude-code") || manifest.installMode !== "plugin") {
+      p8.log.warn("Plugin regeneration only applies to Claude Code in plugin mode. Skipping.");
+    } else {
+      const { generatePlugin: generatePlugin2 } = await import("./plugin-JTDPHWUF.js");
+      const pluginResult = generatePlugin2(
+        targetDir,
+        TEMPLATES_DIR2,
+        getCliVersion(),
+        fullProjectConfig,
+        analysis.packageManager
+      );
+      Object.assign(manifest.files, pluginResult.files);
+      regeneratedFiles.push("plugin (skills, agents, hooks)");
+    }
+  }
+  manifest.projectConfig = fullProjectConfig;
+  manifest.version = getCliVersion();
+  writeManifest(targetDir, manifest);
+  spinner8.stop("Regeneration complete");
+  p8.note(
+    regeneratedFiles.map((f) => `  ${symbols.star} ${f}`).join("\n"),
+    "Regenerated"
+  );
+  const summaryLines = [`  Architecture: ${chalk9.cyan(projectConfig.architecture)}`];
+  if (projectConfig.layers.length > 0) {
+    summaryLines.push(`  Layers:       ${chalk9.cyan(projectConfig.layers.join(", "))}`);
+  }
+  if (projectConfig.stateManagement.length > 0) {
+    summaryLines.push(`  State:        ${chalk9.cyan(projectConfig.stateManagement.join(", "))}`);
+  }
+  if (projectConfig.orm.length > 0) {
+    summaryLines.push(`  ORM:          ${chalk9.cyan(projectConfig.orm.join(", "))}`);
+  }
+  p8.note(summaryLines.join("\n"), "Configuration");
+  p8.outro(chalk9.green("Regeneration complete!"));
+}
+
+// src/commands/info.ts
+import { resolve as resolve8, join as join13 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
+import * as p9 from "@clack/prompts";
+import chalk10 from "chalk";
+async function infoCommand() {
+  const targetDir = resolve8(".");
+  p9.intro(introTitle("Info"));
+  const manifest = readManifest(targetDir);
+  const currentVersion = getCliVersion();
+  const latestPromise = getLatestVersion("devtronic");
+  let versionLine = currentVersion;
+  let skillCount = 0;
+  let agentCount = 0;
+  if (manifest) {
+    const pluginDir = manifest.pluginPath ? join13(targetDir, manifest.pluginPath) : null;
+    if (pluginDir && existsSync10(pluginDir)) {
+      const skillsDir = join13(pluginDir, "skills");
+      const agentsDir = join13(pluginDir, "agents");
+      if (existsSync10(skillsDir)) {
+        skillCount = readdirSync2(skillsDir, { withFileTypes: true }).filter(
+          (e) => e.isDirectory() || e.isFile() && e.name.endsWith(".md")
+        ).length;
+      }
+      if (existsSync10(agentsDir)) {
+        agentCount = readdirSync2(agentsDir, { withFileTypes: true }).filter(
+          (e) => e.isFile() && e.name.endsWith(".md")
+        ).length;
+      }
+    }
+    if (skillCount === 0) {
+      const claudeSkills = join13(targetDir, ".claude", "skills");
+      if (existsSync10(claudeSkills)) {
+        skillCount = readdirSync2(claudeSkills, { withFileTypes: true }).filter(
+          (e) => e.isDirectory() || e.isFile() && e.name.endsWith(".md")
+        ).length;
+      }
+    }
+    if (agentCount === 0) {
+      const claudeAgents = join13(targetDir, ".claude", "agents");
+      if (existsSync10(claudeAgents)) {
+        agentCount = readdirSync2(claudeAgents, { withFileTypes: true }).filter(
+          (e) => e.isFile() && e.name.endsWith(".md")
+        ).length;
+      }
+    }
+  }
+  const latest = await latestPromise;
+  if (latest) {
+    const cmp = compareSemver(currentVersion, latest);
+    if (cmp === 0) {
+      versionLine = `${currentVersion} ${chalk10.green("(latest)")}`;
+    } else if (cmp < 0) {
+      versionLine = `${currentVersion} ${chalk10.yellow(`\u2192 ${latest} available`)}`;
+    } else {
+      versionLine = `${currentVersion} ${chalk10.dim("(pre-release)")}`;
+    }
+  }
+  const lines = [formatKV("Version:", versionLine)];
+  if (manifest) {
+    lines.push(formatKV("Installed:", manifest.implantedAt));
+    lines.push(formatKV("IDEs:", manifest.selectedIDEs.join(", ")));
+    lines.push(formatKV("Mode:", manifest.installMode || "standalone"));
+    lines.push(formatKV("Skills:", String(skillCount)));
+    lines.push(formatKV("Agents:", String(agentCount)));
+    if (manifest.projectConfig) {
+      lines.push(formatKV("Framework:", manifest.projectConfig.framework));
+      lines.push(formatKV("Architecture:", manifest.projectConfig.architecture));
+    }
+  } else {
+    lines.push(chalk10.dim("  Not installed in this directory."));
+    lines.push(chalk10.dim(`  Run ${chalk10.cyan("npx devtronic init")} to set up.`));
+  }
+  p9.note(lines.join("\n"), "devtronic");
+  if (latest && compareSemver(currentVersion, latest) < 0) {
+    p9.log.warn(
+      `Update available: ${currentVersion} ${chalk10.dim("\u2192")} ${chalk10.cyan(latest)}
+  Run ${chalk10.cyan("npx devtronic@latest init")} to upgrade.`
+    );
+  }
+  p9.outro("");
+}
+
+// src/commands/list.ts
+import { resolve as resolve9, join as join14 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync2 } from "fs";
+import * as p10 from "@clack/prompts";
+import chalk11 from "chalk";
+async function listCommand(filter, options) {
+  const targetDir = resolve9(options.path || ".");
+  p10.intro(introTitle("List"));
+  const manifest = readManifest(targetDir);
+  const showSkills = !filter || filter === "skills";
+  const showAgents = !filter || filter === "agents";
+  if (filter && filter !== "skills" && filter !== "agents") {
+    p10.cancel(`Unknown filter: ${filter}
+
+Valid options: skills, agents`);
+    process.exit(1);
+  }
+  const skills = [];
+  const agents = [];
+  const pluginDir = manifest?.pluginPath ? join14(targetDir, manifest.pluginPath) : null;
+  if (pluginDir && existsSync11(pluginDir)) {
+    if (showSkills) {
+      const skillsDir = join14(pluginDir, "skills");
+      if (existsSync11(skillsDir)) {
+        skills.push(...discoverSkills(skillsDir));
+      }
+    }
+    if (showAgents) {
+      const agentsDir = join14(pluginDir, "agents");
+      if (existsSync11(agentsDir)) {
+        agents.push(...discoverAgents(agentsDir));
+      }
+    }
+  }
+  if (showSkills && skills.length === 0) {
+    const claudeSkills = join14(targetDir, ".claude", "skills");
+    if (existsSync11(claudeSkills)) {
+      skills.push(...discoverSkills(claudeSkills));
+    }
+  }
+  if (showAgents && agents.length === 0) {
+    const claudeAgents = join14(targetDir, ".claude", "agents");
+    if (existsSync11(claudeAgents)) {
+      agents.push(...discoverAgents(claudeAgents));
+    }
+  }
+  if (showSkills) {
+    if (skills.length > 0) {
+      const skillLines = skills.sort((a, b) => a.name.localeCompare(b.name)).map((s) => `  ${symbols.bullet} ${chalk11.bold(s.name.padEnd(18))}${chalk11.dim(s.description)}`);
+      p10.note(skillLines.join("\n"), `Skills (${skills.length})`);
+    } else {
+      p10.log.info("No skills found.");
+    }
+  }
+  if (showAgents) {
+    if (agents.length > 0) {
+      const agentLines = agents.sort((a, b) => a.name.localeCompare(b.name)).map((a) => `  ${symbols.bullet} ${chalk11.bold(a.name.padEnd(18))}${chalk11.dim(a.description)}`);
+      p10.note(agentLines.join("\n"), `Agents (${agents.length})`);
+    } else {
+      p10.log.info("No agents found.");
+    }
+  }
+  p10.outro("");
+}
+function discoverSkills(skillsDir) {
+  const items = [];
+  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillMd = join14(skillsDir, entry.name, "SKILL.md");
+      const description = existsSync11(skillMd) ? extractDescription(skillMd) : "";
+      items.push({ name: entry.name, description });
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const name = entry.name.replace(/\.md$/, "");
+      const description = extractDescription(join14(skillsDir, entry.name));
+      items.push({ name, description });
+    }
+  }
+  return items;
+}
+function discoverAgents(agentsDir) {
+  const items = [];
+  const entries = readdirSync3(agentsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      const name = entry.name.replace(/\.md$/, "");
+      const description = extractDescription(join14(agentsDir, entry.name));
+      items.push({ name, description });
+    }
+  }
+  return items;
+}
+function extractDescription(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const lines = content.split("\n");
+    let pastHeading = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) {
+        pastHeading = true;
+        continue;
+      }
+      if (pastHeading && trimmed.length > 0) {
+        const plain = trimmed.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").replace(/\[(.+?)\]\(.+?\)/g, "$1");
+        return plain.length > 60 ? plain.slice(0, 57) + "..." : plain;
+      }
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+// src/commands/config.ts
+import { resolve as resolve10 } from "path";
+import * as p11 from "@clack/prompts";
+import chalk12 from "chalk";
+var ARRAY_KEYS = [
+  "layers",
+  "stateManagement",
+  "dataFetching",
+  "orm",
+  "testing",
+  "ui",
+  "validation",
+  "enabledAddons"
+];
+var VALID_KEYS = [
+  "architecture",
+  "framework",
+  "qualityCommand",
+  ...ARRAY_KEYS
+];
+async function configCommand(options) {
+  const targetDir = resolve10(options.path || ".");
+  p11.intro(introTitle("Config"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p11.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  if (!manifest.projectConfig) {
+    p11.cancel("No project configuration found. Run `npx devtronic init` or `npx devtronic update` first.");
+    process.exit(1);
+  }
+  const config = manifest.projectConfig;
+  const none = chalk12.dim("none");
+  const lines = [
+    formatKV("IDEs:", manifest.selectedIDEs.join(", ")),
+    formatKV("Mode:", manifest.installMode || "standalone"),
+    formatKV("Architecture:", config.architecture || none),
+    formatKV("Framework:", config.framework || none),
+    formatKV("Layers:", config.layers?.join(", ") || none),
+    formatKV("State:", config.stateManagement?.join(", ") || none),
+    formatKV("Data:", config.dataFetching?.join(", ") || none),
+    formatKV("ORM:", config.orm?.join(", ") || none),
+    formatKV("Testing:", config.testing?.join(", ") || none),
+    formatKV("UI:", config.ui?.join(", ") || none),
+    formatKV("Validation:", config.validation?.join(", ") || none),
+    formatKV("Quality:", config.qualityCommand || none),
+    formatKV("Addons:", config.enabledAddons?.join(", ") || none)
+  ];
+  p11.note(lines.join("\n"), "Current Configuration");
+  p11.outro("");
+}
+async function configSetCommand(key, value, options) {
+  const targetDir = resolve10(options.path || ".");
+  p11.intro(introTitle("Config Set"));
+  const manifest = readManifest(targetDir);
+  if (!manifest || !manifest.projectConfig) {
+    p11.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  if (!VALID_KEYS.includes(key)) {
+    p11.cancel(
+      `Unknown config key: ${key}
+
+Valid keys: ${VALID_KEYS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const configKey = key;
+  const previousArch = manifest.projectConfig.architecture;
+  if (ARRAY_KEYS.includes(configKey)) {
+    const arrayValue = value.split(",").map((v) => v.trim()).filter(Boolean);
+    if (configKey === "enabledAddons") {
+      const validAddons = Object.keys(ADDONS);
+      const invalid = arrayValue.filter((v) => !validAddons.includes(v));
+      if (invalid.length > 0) {
+        p11.cancel(
+          `Unknown addon(s): ${invalid.join(", ")}
+
+Valid addons: ${validAddons.join(", ")}`
+        );
+        process.exit(1);
+      }
+    }
+    manifest.projectConfig[configKey] = arrayValue;
+    p11.log.success(`${chalk12.bold(key)} set to ${chalk12.cyan(arrayValue.join(", "))}`);
+  } else {
+    manifest.projectConfig[configKey] = value;
+    p11.log.success(`${chalk12.bold(key)} set to ${chalk12.cyan(value)}`);
+  }
+  writeManifest(targetDir, manifest);
+  if (configKey === "enabledAddons") {
+    p11.log.info(
+      `Run ${chalk12.cyan("devtronic regenerate --plugin")} to apply addon changes to the plugin.`
+    );
+  }
+  if (configKey === "architecture" && value !== previousArch) {
+    if (value === "none") {
+      p11.log.info(`Architecture rules will be skipped on next ${chalk12.cyan("devtronic regenerate --rules")}.`);
+    } else if (previousArch === "none") {
+      p11.log.info(`Run ${chalk12.cyan("devtronic regenerate --rules")} to generate architecture rules.`);
+    } else {
+      p11.log.info(`Run ${chalk12.cyan("devtronic regenerate --rules")} to update rules for the new architecture.`);
+    }
+  }
+  p11.outro(chalk12.green("Configuration updated"));
+}
+async function configResetCommand(options) {
+  const targetDir = resolve10(options.path || ".");
+  p11.intro(introTitle("Config Reset"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p11.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  const spinner8 = p11.spinner();
+  spinner8.start("Re-analyzing project...");
+  const analysis = analyzeProject(targetDir);
+  spinner8.stop("Project analyzed");
+  const pm = analysis.packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  const qualityParts = [];
+  if (analysis.scripts.typecheck) qualityParts.push(`${run} typecheck`);
+  if (analysis.scripts.lint) qualityParts.push(`${run} lint`);
+  if (analysis.scripts.test) qualityParts.push(`${run} test`);
+  manifest.projectConfig = {
+    architecture: analysis.architecture.pattern,
+    layers: analysis.architecture.layers,
+    stateManagement: analysis.stack.stateManagement,
+    dataFetching: analysis.stack.dataFetching,
+    orm: analysis.stack.orm,
+    testing: analysis.stack.testing,
+    ui: analysis.stack.ui,
+    validation: analysis.stack.validation,
+    framework: analysis.framework.name,
+    qualityCommand: qualityParts.length > 0 ? qualityParts.join(" && ") : `${run} typecheck && ${run} lint`,
+    enabledAddons: manifest.projectConfig?.enabledAddons
+  };
+  writeManifest(targetDir, manifest);
+  const config = manifest.projectConfig;
+  const none = chalk12.dim("none");
+  const resetLines = [
+    formatKV("Architecture:", config.architecture || none),
+    formatKV("Framework:", config.framework || none),
+    formatKV("Layers:", config.layers?.join(", ") || none),
+    formatKV("State:", config.stateManagement?.join(", ") || none),
+    formatKV("Data:", config.dataFetching?.join(", ") || none),
+    formatKV("ORM:", config.orm?.join(", ") || none),
+    formatKV("Testing:", config.testing?.join(", ") || none),
+    formatKV("UI:", config.ui?.join(", ") || none),
+    formatKV("Validation:", config.validation?.join(", ") || none),
+    formatKV("Quality:", config.qualityCommand || none),
+    formatKV("Addons:", config.enabledAddons?.join(", ") || none)
+  ];
+  p11.note(resetLines.join("\n"), "Re-detected Configuration");
+  p11.outro(chalk12.green("Configuration reset from project analysis"));
+}
+
+// src/commands/doctor.ts
+import { resolve as resolve11, join as join15 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, statSync, chmodSync as chmodSync3, mkdirSync } from "fs";
+import { execSync } from "child_process";
+import * as p12 from "@clack/prompts";
+import chalk13 from "chalk";
+async function doctorCommand(options) {
+  const targetDir = resolve11(options.path || ".");
+  p12.intro(introTitle("Doctor"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p12.cancel("No installation found. Run `npx devtronic init` first.");
+    process.exit(1);
+  }
+  const checks = [];
+  checks.push(checkManifestValid(manifest));
+  checks.push(checkManifestFiles(targetDir, manifest));
+  checks.push(checkScriptPermissions(targetDir, manifest));
+  if (manifest.installMode === "plugin") {
+    checks.push(checkPluginRegistered(targetDir));
+  }
+  checks.push(checkHookScripts(targetDir, manifest));
+  checks.push(checkQualityScripts(targetDir));
+  checks.push(checkThoughtsDir(targetDir));
+  checks.push(checkEslint(targetDir));
+  if (options.fix) {
+    let fixCount = 0;
+    for (const check of checks) {
+      if ((check.status === "fail" || check.status === "warn") && check.fixable && check.fix) {
+        try {
+          check.fix();
+          check.status = "pass";
+          check.message += " (fixed)";
+          fixCount++;
+        } catch {
+        }
+      }
+    }
+    if (fixCount > 0) {
+      p12.log.success(`Auto-fixed ${fixCount} issue${fixCount === 1 ? "" : "s"}`);
+    }
+  }
+  const resultLines = checks.map((check) => {
+    const icon = check.status === "pass" ? symbols.pass : check.status === "warn" ? symbols.warn : symbols.fail;
+    const fixHint = (check.status === "fail" || check.status === "warn") && check.fixable && !options.fix ? chalk13.dim(" (fixable)") : "";
+    return `  ${icon} ${check.message}${fixHint}`;
+  });
+  const passCount = checks.filter((c) => c.status === "pass").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  p12.note(resultLines.join("\n"), "Health Check");
+  const summaryParts = [];
+  summaryParts.push(`${passCount} passed`);
+  if (warnCount > 0) summaryParts.push(`${warnCount} warning${warnCount === 1 ? "" : "s"}`);
+  if (failCount > 0) summaryParts.push(`${failCount} failed`);
+  if (failCount > 0) {
+    p12.log.error(summaryParts.join(", "));
+    if (!options.fix) {
+      const fixable = checks.filter(
+        (c) => (c.status === "fail" || c.status === "warn") && c.fixable
+      ).length;
+      if (fixable > 0) {
+        p12.log.info(`Run ${chalk13.cyan("devtronic doctor --fix")} to auto-fix ${fixable} issue${fixable === 1 ? "" : "s"}.`);
+      }
+    }
+  } else if (warnCount > 0) {
+    p12.log.warn(summaryParts.join(", "));
+    if (!options.fix) {
+      const fixable = checks.filter((c) => c.status === "warn" && c.fixable).length;
+      if (fixable > 0) {
+        p12.log.info(`Run ${chalk13.cyan("devtronic doctor --fix")} to auto-fix ${fixable} issue${fixable === 1 ? "" : "s"}.`);
+      }
+    }
+  } else {
+    p12.log.success(summaryParts.join(", "));
+  }
+  p12.outro(failCount === 0 && warnCount === 0 ? chalk13.green("All clear!") : "");
+}
+function checkManifestValid(manifest) {
+  if (!manifest) {
+    return { name: "manifest", status: "fail", message: "Manifest not found" };
+  }
+  const version = manifest.version || "unknown";
+  const hasIDEs = manifest.selectedIDEs && manifest.selectedIDEs.length > 0;
+  const hasFiles = manifest.files && Object.keys(manifest.files).length > 0;
+  if (!hasIDEs || !hasFiles) {
+    return {
+      name: "manifest",
+      status: "warn",
+      message: `Manifest exists but missing ${!hasIDEs ? "IDEs" : "files"} (v${version})`
+    };
+  }
+  return {
+    name: "manifest",
+    status: "pass",
+    message: `Manifest is valid (v${version})`
+  };
+}
+function checkManifestFiles(targetDir, manifest) {
+  const totalFiles = Object.keys(manifest.files).length;
+  let existCount = 0;
+  const missing = [];
+  for (const relativePath of Object.keys(manifest.files)) {
+    if (fileExists(join15(targetDir, relativePath))) {
+      existCount++;
+    } else {
+      missing.push(relativePath);
+    }
+  }
+  if (missing.length === 0) {
+    return {
+      name: "files",
+      status: "pass",
+      message: `${existCount}/${totalFiles} manifest files exist`
+    };
+  }
+  return {
+    name: "files",
+    status: missing.length > totalFiles / 2 ? "fail" : "warn",
+    message: `${existCount}/${totalFiles} manifest files exist (${missing.length} missing)`
+  };
+}
+function checkScriptPermissions(targetDir, manifest) {
+  const pluginDir = manifest.pluginPath ? join15(targetDir, manifest.pluginPath) : null;
+  const shFiles = [];
+  if (pluginDir && existsSync12(pluginDir)) {
+    const scriptsDir = join15(pluginDir, "scripts");
+    if (existsSync12(scriptsDir)) {
+      const entries = readdirSync4(scriptsDir);
+      for (const entry of entries) {
+        if (entry.endsWith(".sh")) {
+          shFiles.push(join15(scriptsDir, entry));
+        }
+      }
+    }
+  }
+  if (shFiles.length === 0) {
+    return {
+      name: "permissions",
+      status: "pass",
+      message: "No shell scripts to check"
+    };
+  }
+  const nonExecutable = [];
+  for (const file of shFiles) {
+    try {
+      const stat = statSync(file);
+      if (!(stat.mode & 73)) {
+        nonExecutable.push(file);
+      }
+    } catch {
+    }
+  }
+  if (nonExecutable.length === 0) {
+    return {
+      name: "permissions",
+      status: "pass",
+      message: "Scripts have executable permissions"
+    };
+  }
+  return {
+    name: "permissions",
+    status: "warn",
+    message: `${nonExecutable.length} script${nonExecutable.length === 1 ? "" : "s"} missing executable permission`,
+    fixable: true,
+    fix: () => {
+      for (const file of nonExecutable) {
+        chmodSync3(file, 493);
+      }
+    }
+  };
+}
+function checkPluginRegistered(targetDir) {
+  const settings = readClaudeSettings(targetDir);
+  const pluginKey = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+  const isRegistered = settings.enabledPlugins?.[pluginKey] === true;
+  if (isRegistered) {
+    return {
+      name: "plugin",
+      status: "pass",
+      message: "Plugin registered in .claude/settings.json"
+    };
+  }
+  return {
+    name: "plugin",
+    status: "warn",
+    message: "Plugin not registered in .claude/settings.json",
+    fixable: true,
+    fix: () => {
+      registerPlugin(targetDir, PLUGIN_NAME, MARKETPLACE_NAME, PLUGIN_DIR);
+    }
+  };
+}
+function checkHookScripts(targetDir, manifest) {
+  const pluginDir = manifest.pluginPath ? join15(targetDir, manifest.pluginPath) : null;
+  if (!pluginDir || !existsSync12(pluginDir)) {
+    return {
+      name: "hooks",
+      status: "pass",
+      message: "No hooks directory to check"
+    };
+  }
+  const hooksDir = join15(pluginDir, "hooks");
+  if (!existsSync12(hooksDir)) {
+    return {
+      name: "hooks",
+      status: "pass",
+      message: "No hooks directory found"
+    };
+  }
+  const hookFiles = readdirSync4(hooksDir).filter((f) => f.endsWith(".json"));
+  let total = 0;
+  let valid = 0;
+  for (const hookFile of hookFiles) {
+    try {
+      const hookContent = JSON.parse(readFile(join15(hooksDir, hookFile)));
+      const hooks = Array.isArray(hookContent) ? hookContent : [hookContent];
+      for (const hook of hooks) {
+        if (hook.command) {
+          total++;
+          const parts = hook.command.split(" ");
+          const scriptRef = parts.find(
+            (part) => part.endsWith(".sh") || part.endsWith(".js")
+          );
+          if (scriptRef) {
+            const resolved = scriptRef.replace(
+              /\$\{[A-Z_]+\}\//g,
+              ""
+            );
+            const scriptPath = join15(pluginDir, resolved);
+            if (existsSync12(scriptPath)) {
+              valid++;
+            }
+          } else {
+            valid++;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (total === 0) {
+    return { name: "hooks", status: "pass", message: "No hook scripts to verify" };
+  }
+  if (valid === total) {
+    return { name: "hooks", status: "pass", message: "Hook scripts exist" };
+  }
+  return {
+    name: "hooks",
+    status: "warn",
+    message: `${valid}/${total} hook script references are valid`
+  };
+}
+function checkQualityScripts(targetDir) {
+  const pkgPath = join15(targetDir, "package.json");
+  if (!fileExists(pkgPath)) {
+    return { name: "quality", status: "warn", message: "No package.json found" };
+  }
+  try {
+    const pkg = JSON.parse(readFile(pkgPath));
+    const scripts = pkg.scripts || {};
+    const expected = ["typecheck", "lint", "test"];
+    const missing = expected.filter((s) => !scripts[s]);
+    if (missing.length === 0) {
+      return {
+        name: "quality",
+        status: "pass",
+        message: "Quality scripts exist (typecheck, lint, test)"
+      };
+    }
+    return {
+      name: "quality",
+      status: "warn",
+      message: `Missing package.json script${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}`
+    };
+  } catch {
+    return { name: "quality", status: "warn", message: "Could not parse package.json" };
+  }
+}
+function checkThoughtsDir(targetDir) {
+  const thoughtsDir = join15(targetDir, "thoughts");
+  if (existsSync12(thoughtsDir)) {
+    return {
+      name: "thoughts",
+      status: "pass",
+      message: "thoughts/ directory exists"
+    };
+  }
+  return {
+    name: "thoughts",
+    status: "warn",
+    message: "thoughts/ directory missing",
+    fixable: true,
+    fix: () => {
+      const dirs = [
+        "thoughts/specs",
+        "thoughts/research",
+        "thoughts/plans",
+        "thoughts/checkpoints",
+        "thoughts/notes",
+        "thoughts/debug",
+        "thoughts/audit",
+        "thoughts/archive/backlog"
+      ];
+      for (const dir of dirs) {
+        mkdirSync(join15(targetDir, dir), { recursive: true });
+      }
+    }
+  };
+}
+function checkEslint(targetDir) {
+  try {
+    const eslintLocal = join15(targetDir, "node_modules", ".bin", "eslint");
+    if (existsSync12(eslintLocal)) {
+      return { name: "eslint", status: "pass", message: "eslint is available" };
+    }
+    execSync("which eslint", { stdio: "pipe" });
+    return { name: "eslint", status: "pass", message: "eslint is available (global)" };
+  } catch {
+    return {
+      name: "eslint",
+      status: "warn",
+      message: "eslint not found (needed for PostToolUse hook)"
+    };
+  }
+}
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync13, rmSync, readdirSync as readdirSync5 } from "fs";
+import { resolve as resolve12, join as join16, dirname as dirname6 } from "path";
+import * as p13 from "@clack/prompts";
+import chalk14 from "chalk";
+var DEVTRONIC_FILES = ["CLAUDE.md", "AGENTS.md"];
+async function uninstallCommand(options) {
+  ensureInteractive("uninstall");
+  const targetDir = resolve12(options.path || ".");
+  p13.intro(introTitle("Uninstall"));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p13.log.warn("No devtronic installation found in this directory.");
+    p13.log.info(
+      `If you installed in a different directory, use ${chalk14.cyan("devtronic uninstall --path <dir>")}`
+    );
+    p13.outro("Nothing to uninstall");
+    return;
+  }
+  const managedFiles = Object.keys(manifest.files);
+  const existingFiles = managedFiles.filter((f) => fileExists(join16(targetDir, f)));
+  const missingFiles = managedFiles.filter((f) => !fileExists(join16(targetDir, f)));
+  const hasPlugin = manifest.installMode === "plugin" && existsSync13(join16(targetDir, PLUGIN_DIR, PLUGIN_NAME));
+  const hasThoughts = existsSync13(join16(targetDir, "thoughts"));
+  const hasClaudeMd = fileExists(join16(targetDir, "CLAUDE.md"));
+  const hasAgentsMd = fileExists(join16(targetDir, "AGENTS.md"));
+  p13.log.info(`Installation found: v${manifest.version} (${manifest.implantedAt})`);
+  p13.log.info(`IDEs: ${manifest.selectedIDEs.join(", ")}`);
+  p13.log.info(`Mode: ${manifest.installMode || "standalone"}`);
+  const removalLines = [];
+  if (hasPlugin) {
+    removalLines.push(`  ${symbols.fail} Plugin ${chalk14.cyan(PLUGIN_NAME)} (${PLUGIN_DIR}/${PLUGIN_NAME}/)`);
+  }
+  const nonPluginFiles = existingFiles.filter((f) => !f.startsWith(PLUGIN_DIR + "/"));
+  if (nonPluginFiles.length > 0) {
+    removalLines.push(`  ${symbols.fail} ${nonPluginFiles.length} managed files (rules, templates)`);
+  }
+  removalLines.push(`  ${symbols.fail} Installation manifest (${MANIFEST_DIR}/)`);
+  if (hasClaudeMd) {
+    removalLines.push(`  ${symbols.warn} CLAUDE.md ${chalk14.dim("(may contain your customizations)")}`);
+  }
+  if (hasAgentsMd) {
+    removalLines.push(`  ${symbols.warn} AGENTS.md`);
+  }
+  if (hasThoughts) {
+    removalLines.push(`  ${symbols.warn} thoughts/ directory ${chalk14.dim("(checkpoints, notes, specs)")}`);
+  }
+  if (missingFiles.length > 0) {
+    removalLines.push(
+      `  ${symbols.info} ${missingFiles.length} files already removed`
+    );
+  }
+  p13.note(removalLines.join("\n"), "Will be removed");
+  const confirm9 = await p13.confirm({
+    message: "Remove devtronic from this project? This cannot be undone.",
+    initialValue: false
+  });
+  if (p13.isCancel(confirm9) || !confirm9) {
+    p13.cancel("Uninstall cancelled. No files were changed.");
+    return;
+  }
+  let removeClaudeMd = false;
+  let removeAgentsMd = false;
+  let removeThoughts = false;
+  if (hasClaudeMd || hasAgentsMd || hasThoughts) {
+    p13.log.step("Some files may contain your own work. Keep or remove?");
+    if (hasClaudeMd) {
+      const confirmClaude = await p13.confirm({
+        message: "Remove CLAUDE.md? (may contain self-improvements and custom rules)",
+        initialValue: false
+      });
+      removeClaudeMd = !p13.isCancel(confirmClaude) && confirmClaude;
+    }
+    if (hasAgentsMd) {
+      const confirmAgents = await p13.confirm({
+        message: "Remove AGENTS.md?",
+        initialValue: true
+      });
+      removeAgentsMd = !p13.isCancel(confirmAgents) && confirmAgents;
+    }
+    if (hasThoughts) {
+      const confirmThoughts = await p13.confirm({
+        message: "Remove thoughts/ directory? (checkpoints, specs, plans, notes)",
+        initialValue: false
+      });
+      removeThoughts = !p13.isCancel(confirmThoughts) && confirmThoughts;
+    }
+  }
+  const spinner8 = p13.spinner();
+  spinner8.start("Removing devtronic...");
+  const removed = [];
+  const kept = [];
+  const errors = [];
+  if (hasPlugin) {
+    try {
+      unregisterPlugin(targetDir, PLUGIN_NAME, MARKETPLACE_NAME);
+      const settings = readClaudeSettings(targetDir);
+      if (settings.extraKnownMarketplaces?.[MARKETPLACE_NAME]) {
+        delete settings.extraKnownMarketplaces[MARKETPLACE_NAME];
+        if (Object.keys(settings.extraKnownMarketplaces).length === 0) {
+          delete settings.extraKnownMarketplaces;
+        }
+        writeClaudeSettings(targetDir, settings);
+      }
+      removed.push("Plugin unregistered from .claude/settings.json");
+    } catch (err) {
+      errors.push(`Failed to unregister plugin: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (hasPlugin) {
+    try {
+      rmSync(join16(targetDir, PLUGIN_DIR, PLUGIN_NAME), { recursive: true, force: true });
+      removed.push(`${PLUGIN_DIR}/${PLUGIN_NAME}/`);
+      const marketplaceDescDir = join16(targetDir, PLUGIN_DIR, ".claude-plugin");
+      if (existsSync13(marketplaceDescDir)) {
+        rmSync(marketplaceDescDir, { recursive: true, force: true });
+        removed.push(`${PLUGIN_DIR}/.claude-plugin/`);
+      }
+      const pluginsDir = join16(targetDir, PLUGIN_DIR);
+      if (existsSync13(pluginsDir)) {
+        const remaining = readdirSafe(pluginsDir);
+        if (remaining.length === 0) {
+          rmSync(pluginsDir, { recursive: true, force: true });
+          removed.push(`${PLUGIN_DIR}/ (empty)`);
+        }
+      }
+    } catch (err) {
+      errors.push(`Failed to remove plugin: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const file of existingFiles) {
+    if (DEVTRONIC_FILES.includes(file)) continue;
+    if (file.startsWith("thoughts/")) continue;
+    if (file.startsWith(PLUGIN_DIR + "/")) continue;
+    try {
+      const filePath = join16(targetDir, file);
+      if (existsSync13(filePath)) {
+        rmSync(filePath, { force: true });
+        removed.push(file);
+        cleanEmptyParents(targetDir, dirname6(file));
+      }
+    } catch (err) {
+      errors.push(`Failed to remove ${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (hasClaudeMd) {
+    if (removeClaudeMd) {
+      try {
+        rmSync(join16(targetDir, "CLAUDE.md"), { force: true });
+        removed.push("CLAUDE.md");
+      } catch (err) {
+        errors.push(`Failed to remove CLAUDE.md: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      kept.push("CLAUDE.md");
+    }
+  }
+  if (hasAgentsMd) {
+    if (removeAgentsMd) {
+      try {
+        rmSync(join16(targetDir, "AGENTS.md"), { force: true });
+        removed.push("AGENTS.md");
+      } catch (err) {
+        errors.push(`Failed to remove AGENTS.md: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      kept.push("AGENTS.md");
+    }
+  }
+  if (hasThoughts) {
+    if (removeThoughts) {
+      try {
+        rmSync(join16(targetDir, "thoughts"), { recursive: true, force: true });
+        removed.push("thoughts/");
+      } catch (err) {
+        errors.push(`Failed to remove thoughts/: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      kept.push("thoughts/");
+    }
+  }
+  try {
+    const manifestDir = join16(targetDir, MANIFEST_DIR);
+    if (existsSync13(manifestDir)) {
+      rmSync(manifestDir, { recursive: true, force: true });
+      removed.push(`${MANIFEST_DIR}/`);
+    }
+  } catch (err) {
+    errors.push(`Failed to remove manifest: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  spinner8.stop("Removal complete");
+  if (removed.length > 0) {
+    p13.note(
+      removed.map((f) => `  ${symbols.fail} ${f}`).join("\n"),
+      "Removed"
+    );
+  }
+  if (kept.length > 0) {
+    p13.note(
+      kept.map((f) => `  ${symbols.pass} ${f} ${chalk14.dim("(kept)")}`).join("\n"),
+      "Preserved"
+    );
+  }
+  if (errors.length > 0) {
+    p13.note(
+      errors.map((e) => `  ${symbols.warn} ${e}`).join("\n"),
+      "Errors"
+    );
+  }
+  if (errors.length === 0) {
+    p13.note(
+      [
+        `  Thanks for using devtronic.`,
+        `  If something didn't work as expected, we'd love to hear about it:`,
+        `  ${chalk14.cyan("https://github.com/r-bart/devtronic/issues")}`,
+        ``,
+        `  To reinstall anytime: ${chalk14.cyan("npx devtronic init")}`
+      ].join("\n"),
+      "Until next time"
+    );
+    p13.outro(chalk14.green("Clean uninstall complete. See you around!"));
+  } else {
+    p13.log.warn("Some files could not be removed. You may need to delete them manually.");
+    p13.log.info(`To reinstall: ${chalk14.cyan("npx devtronic init")}`);
+    p13.outro(chalk14.yellow("Partial uninstall complete"));
+  }
+}
+function cleanEmptyParents(targetDir, relDir) {
+  if (!relDir || relDir === ".") return;
+  const absDir = join16(targetDir, relDir);
+  if (!existsSync13(absDir)) return;
+  const entries = readdirSafe(absDir);
+  if (entries.length === 0) {
+    try {
+      rmSync(absDir, { recursive: true, force: true });
+      cleanEmptyParents(targetDir, dirname6(relDir));
+    } catch {
+    }
+  }
+}
+function readdirSafe(dir) {
+  try {
+    return readdirSync5(dir);
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/addon.ts
+import { resolve as resolve13, join as join17, dirname as dirname7 } from "path";
+import { existsSync as existsSync14, unlinkSync as unlinkSync2, rmSync as rmSync2 } from "fs";
+import * as p14 from "@clack/prompts";
+import chalk15 from "chalk";
+async function addonCommand(action, addonName, options) {
+  const targetDir = resolve13(options.path || ".");
+  p14.intro(introTitle(`Addon ${action}`));
+  const manifest = readManifest(targetDir);
+  if (!manifest) {
+    p14.log.warn("No devtronic installation found.");
+    p14.log.info("Run `npx devtronic init` first.");
+    p14.outro("");
+    return;
+  }
+  if (manifest.installMode !== "plugin" || !manifest.pluginPath) {
+    p14.log.warn("Addons require Claude Code in plugin mode.");
+    p14.log.info("Run `npx devtronic init` with Claude Code selected.");
+    p14.outro("");
+    return;
+  }
+  const validAddons = Object.keys(ADDONS);
+  if (!validAddons.includes(addonName)) {
+    p14.cancel(`Unknown addon: ${addonName}
+
+Valid addons: ${validAddons.join(", ")}`);
+    process.exit(1);
+  }
+  const addon = ADDONS[addonName];
+  const currentAddons = manifest.projectConfig?.enabledAddons ?? [];
+  if (action === "add") {
+    await addAddon(targetDir, manifest, addon.name, currentAddons);
+  } else {
+    await removeAddon(targetDir, manifest, addon.name, currentAddons);
+  }
+}
+async function addAddon(targetDir, manifest, addonName, currentAddons) {
+  if (currentAddons.includes(addonName)) {
+    p14.log.warn(`Addon "${addonName}" is already enabled.`);
+    p14.outro("");
+    return;
+  }
+  const addon = ADDONS[addonName];
+  const pluginRoot = manifest.pluginPath;
+  const skillsSourceDir = join17(TEMPLATES_DIR, "claude-code", ".claude", "skills");
+  p14.note(
+    [
+      `  ${chalk15.dim("Name:")}        ${addon.label}`,
+      `  ${chalk15.dim("Description:")} ${addon.description}`,
+      `  ${chalk15.dim("Skills:")}      ${addon.skills.map((s) => chalk15.cyan(`/devtronic:${s}`)).join(", ")}`,
+      `  ${chalk15.dim("Subagents:")}   ${addon.agents.length ? addon.agents.join(", ") : chalk15.dim("\u2014")}`
+    ].join("\n"),
+    "Adding addon"
+  );
+  const confirmed = await p14.confirm({ message: "Add this addon?" });
+  if (p14.isCancel(confirmed) || !confirmed) {
+    p14.cancel("Addon installation cancelled.");
+    process.exit(0);
+  }
+  const spinner8 = p14.spinner();
+  spinner8.start(`Adding ${addon.label}...`);
+  const addedFiles = [];
+  for (const skillDir of addon.skills) {
+    const sourceDir = join17(skillsSourceDir, skillDir);
+    if (!existsSync14(sourceDir)) {
+      spinner8.stop(`Template not found for skill: ${skillDir}`);
+      p14.log.warn(`Skipping ${skillDir} \u2014 template not found.`);
+      continue;
+    }
+    const templateFiles = getAllFilesRecursive(sourceDir);
+    for (const file of templateFiles) {
+      const content = readFile(join17(sourceDir, file));
+      const destRelPath = join17(pluginRoot, "skills", skillDir, file);
+      const destAbsPath = join17(targetDir, destRelPath);
+      ensureDir(dirname7(destAbsPath));
+      writeFile(destAbsPath, content);
+      manifest.files[destRelPath] = createManifestEntry(content);
+      addedFiles.push(destRelPath);
+    }
+  }
+  const newAddons = [...currentAddons, addonName];
+  const addonSkillCount = newAddons.flatMap((a) => ADDONS[a]?.skills ?? []).length;
+  updateDescriptors(targetDir, manifest, pluginRoot, addonSkillCount);
+  if (!manifest.projectConfig) {
+    manifest.projectConfig = { architecture: "flat", layers: [], stateManagement: [], dataFetching: [], orm: [], testing: [], ui: [], validation: [], framework: "unknown", qualityCommand: "" };
+  }
+  manifest.projectConfig.enabledAddons = newAddons;
+  writeManifest(targetDir, manifest);
+  spinner8.stop(`${symbols.pass} ${addon.label} added`);
+  p14.note(
+    addon.skills.map((s) => `  ${chalk15.cyan(`/devtronic:${s}`)}`).join("\n"),
+    "New skills available"
+  );
+  p14.outro("Done. Restart Claude Code to load the new skills.");
+}
+async function removeAddon(targetDir, manifest, addonName, currentAddons) {
+  if (!currentAddons.includes(addonName)) {
+    p14.log.warn(`Addon "${addonName}" is not currently enabled.`);
+    p14.outro("");
+    return;
+  }
+  const addon = ADDONS[addonName];
+  const pluginRoot = manifest.pluginPath;
+  p14.note(
+    [
+      `  ${chalk15.dim("Name:")}        ${addon.label}`,
+      `  ${chalk15.dim("Description:")} ${addon.description}`,
+      `  ${chalk15.dim("Skills:")}      ${addon.skills.map((s) => chalk15.dim(`/devtronic:${s}`)).join(", ")}`,
+      `  ${chalk15.dim("Subagents:")}   ${addon.agents.length ? addon.agents.join(", ") : chalk15.dim("\u2014")}`
+    ].join("\n"),
+    "Removing addon"
+  );
+  const confirmed = await p14.confirm({ message: "Remove this addon?" });
+  if (p14.isCancel(confirmed) || !confirmed) {
+    p14.cancel("Addon removal cancelled.");
+    process.exit(0);
+  }
+  const modifiedFiles = [];
+  for (const skillDir of addon.skills) {
+    const skillRelBase = join17(pluginRoot, "skills", skillDir);
+    for (const [filePath, fileInfo] of Object.entries(manifest.files)) {
+      if (!filePath.startsWith(skillRelBase)) continue;
+      const absPath = join17(targetDir, filePath);
+      if (!existsSync14(absPath)) continue;
+      const current = calculateChecksum(readFile(absPath));
+      if (current !== fileInfo.originalChecksum) {
+        modifiedFiles.push(filePath);
+      }
+    }
+  }
+  if (modifiedFiles.length > 0) {
+    p14.log.warn("The following files have been modified:");
+    for (const f of modifiedFiles) {
+      p14.log.message(`  ${chalk15.yellow(f)}`);
+    }
+    const confirm9 = await p14.confirm({
+      message: "Remove them anyway? (changes will be lost)"
+    });
+    if (p14.isCancel(confirm9) || !confirm9) {
+      p14.cancel("Addon removal cancelled.");
+      process.exit(0);
+    }
+  }
+  const spinner8 = p14.spinner();
+  spinner8.start(`Removing ${addon.label}...`);
+  for (const skillDir of addon.skills) {
+    const skillRelBase = join17(pluginRoot, "skills", skillDir);
+    const skillAbsDir = join17(targetDir, skillRelBase);
+    for (const filePath of Object.keys(manifest.files)) {
+      if (filePath.startsWith(skillRelBase)) {
+        const absPath = join17(targetDir, filePath);
+        if (existsSync14(absPath)) unlinkSync2(absPath);
+        delete manifest.files[filePath];
+      }
+    }
+    if (existsSync14(skillAbsDir)) {
+      try {
+        rmSync2(skillAbsDir, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  const newAddons = currentAddons.filter((a) => a !== addonName);
+  const addonSkillCount = newAddons.flatMap((a) => ADDONS[a]?.skills ?? []).length;
+  updateDescriptors(targetDir, manifest, pluginRoot, addonSkillCount);
+  manifest.projectConfig.enabledAddons = newAddons;
+  writeManifest(targetDir, manifest);
+  spinner8.stop(`${symbols.pass} ${addon.label} removed`);
+  p14.note(
+    addon.skills.map((s) => `  ${chalk15.dim(`/devtronic:${s}`)}`).join("\n"),
+    "Skills removed"
+  );
+  p14.outro("Done. Restart Claude Code to apply the changes.");
+}
+function updateDescriptors(targetDir, manifest, pluginRoot, addonSkillCount) {
+  const cliVersion2 = getCliVersion();
+  const pluginJsonContent = generatePluginJson(cliVersion2, addonSkillCount);
+  const pluginJsonRelPath = join17(pluginRoot, ".claude-plugin", "plugin.json");
+  writeFile(join17(targetDir, pluginJsonRelPath), pluginJsonContent);
+  manifest.files[pluginJsonRelPath] = createManifestEntry(pluginJsonContent);
+  const marketplaceContent = generateMarketplaceJson(addonSkillCount);
+  const marketplaceRelPath = join17(PLUGIN_DIR, ".claude-plugin", "marketplace.json");
+  writeFile(join17(targetDir, marketplaceRelPath), marketplaceContent);
+  manifest.files[marketplaceRelPath] = createManifestEntry(marketplaceContent);
+}
+
+// src/index.ts
+var cliVersion = getCliVersion();
+var program = new Command();
+program.name("devtronic").description("AI-assisted development toolkit").version(cliVersion).action(() => {
+  showLogo();
+  console.log(chalk16.dim(`  Agentic development toolkit v${cliVersion}`));
+  console.log();
+  console.log(`  ${chalk16.dim("$")} ${chalk16.white("devtronic init")} ${chalk16.dim("[path]")}              ${chalk16.dim("Initialize in a project")}`);
+  console.log(`  ${chalk16.dim("$")} ${chalk16.white("devtronic info")}                      ${chalk16.dim("Version & config summary")}`);
+  console.log(`  ${chalk16.dim("$")} ${chalk16.white("devtronic doctor")}                    ${chalk16.dim("Health diagnostics")}`);
+  console.log(`  ${chalk16.dim("$")} ${chalk16.white("devtronic status")}                    ${chalk16.dim("File status overview")}`);
+  console.log();
+  console.log(`  ${chalk16.dim("$")} ${chalk16.white("devtronic help")}                      ${chalk16.dim("Show all commands")}`);
+  console.log(`  ${chalk16.dim("$")} ${chalk16.white("devtronic help --all")}                ${chalk16.dim("Full reference with all options")}`);
+  console.log();
+});
+program.command("init").description("Initialize devtronic in your project").argument("[path]", "Target directory (default: current directory)").option("--ide <ides>", "Comma-separated list of IDEs to configure").option("-y, --yes", "Skip prompts and use defaults").option("--preview", "Show what would be generated without making changes").option(
+  "--preset <name>",
+  `Use a preset configuration (${Object.keys(PRESETS).join(", ")})`
+).option("--addon <name>", "Enable an addon (e.g., orchestration)").action(async (path, options) => {
+  await initCommand({
+    path,
+    ide: options.ide,
+    yes: options.yes,
+    preview: options.preview,
+    preset: options.preset,
+    addon: options.addon
+  });
+});
+program.command("update").description("Update to the latest template version").option("--check", "Only check for updates without applying").option("--dry-run", "Show what would be updated without making changes").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await updateCommand({ path: options.path, check: options.check, dryRun: options.dryRun });
+});
+program.command("add").description("Add configuration for an additional IDE").argument("[ide]", "IDE to add (claude-code, cursor, antigravity, github-copilot)").option("-y, --yes", "Skip prompts and use defaults").option("--path <path>", "Target directory (default: current directory)").action(async (ide, options) => {
+  await addCommand(ide, { path: options.path, yes: options.yes });
+});
+program.command("regenerate").description("Regenerate specific files (CLAUDE.md, AGENTS.md, architecture rules)").argument("[target]", "What to regenerate (CLAUDE.md, AGENTS.md, rules)").option("--claude", "Regenerate CLAUDE.md (overwrites self-improvements)").option("--rules", "Regenerate architecture rules for all configured IDEs").option("--agents", "Regenerate AGENTS.md").option("--all", "Regenerate everything").option("--plugin", "Regenerate the Claude Code plugin (skills, agents, hooks)").option("--path <path>", "Target directory (default: current directory)").action(async (target, options) => {
+  await regenerateCommand(target, {
+    path: options.path,
+    claude: options.claude,
+    rules: options.rules,
+    agents: options.agents,
+    all: options.all,
+    plugin: options.plugin
+  });
+});
+program.command("status").description("Show installation status and modified files").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await statusCommand({ path: options.path });
+});
+program.command("diff").description("Show differences between local files and template").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await diffCommand({ path: options.path });
+});
+program.command("info").description("Show version, configuration, and installation summary").action(async () => {
+  await infoCommand();
+});
+program.command("list").description("List installed skills and agents").argument("[filter]", "Filter by type (skills, agents)").option("--path <path>", "Target directory (default: current directory)").action(async (filter, options) => {
+  await listCommand(filter, { path: options.path });
+});
+var configCmd = program.command("config").description("View or manage project configuration").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await configCommand({ path: options.path });
+});
+configCmd.command("set").description("Set a configuration value").argument("<key>", "Configuration key").argument("<value>", "New value (comma-separated for arrays)").option("--path <path>", "Target directory (default: current directory)").action(async (key, value, options) => {
+  await configSetCommand(key, value, { path: options.path });
+});
+configCmd.command("reset").description("Re-detect configuration from project").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await configResetCommand({ path: options.path });
+});
+program.command("doctor").description("Run health checks on your devtronic installation").option("--fix", "Auto-fix fixable issues").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await doctorCommand({ fix: options.fix, path: options.path });
+});
+program.command("uninstall").description("Remove devtronic from your project").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await uninstallCommand({ path: options.path });
+});
+program.command("help").description("Show help (use --all for full reference)").option("-a, --all", "Show all commands with their options").action((options) => {
+  if (!options.all) {
+    program.outputHelp();
+    return;
+  }
+  showLogo();
+  console.log(chalk16.dim(`  Agentic development toolkit v${cliVersion}
+`));
+  const sections = [
+    {
+      title: "Setup",
+      usage: "init [path]",
+      desc: "Initialize devtronic in your project",
+      opts: [
+        "--ide <ides>        Comma-separated list of IDEs",
+        "-y, --yes           Skip prompts and use defaults",
+        "--preview            Show what would be generated",
+        "--preset <name>      Use a preset (nextjs-clean, react-clean, monorepo, feature-based, minimal)",
+        "--addon <name>       Enable an addon (e.g., orchestration)"
+      ]
+    },
+    {
+      title: "",
+      usage: "uninstall",
+      desc: "Remove devtronic from your project",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "Addons",
+      usage: "addon add <name>",
+      desc: "Add an optional skill pack (e.g., orchestration)",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "addon remove <name>",
+      desc: "Remove an addon skill pack",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "Maintenance",
+      usage: "update",
+      desc: "Update to the latest template version",
+      opts: [
+        "--check              Only check for updates",
+        "--dry-run             Show what would change",
+        "--path <path>        Target directory"
+      ]
+    },
+    {
+      title: "",
+      usage: "regenerate [target]",
+      desc: "Regenerate CLAUDE.md, AGENTS.md, rules, or plugin",
+      opts: [
+        "--claude             Regenerate CLAUDE.md",
+        "--agents             Regenerate AGENTS.md",
+        "--rules              Regenerate architecture rules",
+        "--plugin             Regenerate Claude Code plugin",
+        "--all                Regenerate everything",
+        "--path <path>        Target directory"
+      ]
+    },
+    {
+      title: "",
+      usage: "add [ide]",
+      desc: "Add configuration for an additional IDE",
+      opts: [
+        "-y, --yes           Skip prompts",
+        "--path <path>        Target directory"
+      ]
+    },
+    {
+      title: "Configuration",
+      usage: "config",
+      desc: "View current project configuration",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "config set <key> <value>",
+      desc: "Set a configuration value (comma-separated for arrays)"
+    },
+    {
+      title: "",
+      usage: "config reset",
+      desc: "Re-detect configuration from project"
+    },
+    {
+      title: "",
+      usage: "presets",
+      desc: "List available configuration presets"
+    },
+    {
+      title: "Diagnostics",
+      usage: "status",
+      desc: "Show installation status and modified files",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "diff",
+      desc: "Show differences between local files and template",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "info",
+      desc: "Version, configuration, and installation summary"
+    },
+    {
+      title: "",
+      usage: "doctor",
+      desc: "Run health checks on your installation",
+      opts: [
+        "--fix                Auto-fix fixable issues",
+        "--path <path>        Target directory"
+      ]
+    },
+    {
+      title: "",
+      usage: "list [skills|agents]",
+      desc: "List installed skills and agents",
+      opts: ["--path <path>        Target directory"]
+    }
+  ];
+  for (const section of sections) {
+    if (section.title) {
+      console.log(`  ${chalk16.bold.underline(section.title)}
+`);
+    }
+    console.log(`  ${chalk16.white("devtronic " + section.usage)}`);
+    console.log(`  ${chalk16.dim(section.desc)}`);
+    if (section.opts) {
+      for (const opt of section.opts) {
+        console.log(`    ${chalk16.yellow(opt)}`);
+      }
+    }
+    console.log();
+  }
+});
+var addonCmd = program.command("addon").description("Manage addons (add or remove optional skill packs)");
+addonCmd.command("add").description("Add an addon to the devtronic plugin").argument("<name>", "Addon name (e.g., orchestration)").option("--path <path>", "Target directory (default: current directory)").action(async (name, options) => {
+  await addonCommand("add", name, { path: options.path });
+});
+addonCmd.command("remove").description("Remove an addon from the devtronic plugin").argument("<name>", "Addon name (e.g., orchestration)").option("--path <path>", "Target directory (default: current directory)").action(async (name, options) => {
+  await addonCommand("remove", name, { path: options.path });
+});
+program.command("presets").description("List available configuration presets").action(() => {
+  p15.intro(introTitle("Presets"));
+  const lines = Object.entries(PRESETS).map(([name, preset]) => {
+    const parts = [`  ${chalk16.bold(name)}`];
+    parts.push(`    ${preset.description}`);
+    if (preset.config.architecture) {
+      parts.push(`    Architecture: ${chalk16.cyan(preset.config.architecture)}`);
+    }
+    if (preset.config.layers) {
+      parts.push(`    Layers: ${chalk16.cyan(preset.config.layers.join(", "))}`);
+    }
+    return parts.join("\n");
+  });
+  p15.note(lines.join("\n\n"), "Available Presets");
+  p15.outro(`Usage: ${chalk16.cyan("npx devtronic init --preset <name>")}`);
+});
+program.parseAsync().catch((err) => {
+  console.error(`
+Error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});