devtronic 1.1.0 → 1.2.0

package/dist/index.js

@@ -24,12 +24,12 @@ import {
   readManifest,
   writeFile,
   writeManifest
-} from "./chunk-5V4PXTP6.js";
+} from "./chunk-V4QEAL7Y.js";
 
 // src/index.ts
 import { Command } from "commander";
-import * as p15 from "@clack/prompts";
-import chalk16 from "chalk";
+import * as p16 from "@clack/prompts";
+import chalk17 from "chalk";
 
 // src/commands/init.ts
 import { existsSync as existsSync5, chmodSync } from "fs";
@@ -1207,9 +1207,9 @@ function getCliVersion() {
     resolve(__dirname, "../package.json"),
     resolve(__dirname, "../../package.json")
   ];
-  for (const p16 of paths) {
+  for (const p17 of paths) {
     try {
-      const pkg = JSON.parse(readFileSync(p16, "utf-8"));
+      const pkg = JSON.parse(readFileSync(p17, "utf-8"));
       if (pkg.name === "devtronic" && pkg.version) {
         return pkg.version;
       }
@@ -1374,7 +1374,18 @@ Valid addons: ${validAddons.join(", ")}`);
       process.exit(0);
     }
     if (wantOrchestration) {
-      enabledAddons = ["orchestration"];
+      enabledAddons.push("orchestration");
+    }
+    const wantDesign = await p3.confirm({
+      message: "Enable design best practices? (design-init \u2192 design-review \u2192 design-refine \u2192 design-harden)",
+      initialValue: false
+    });
+    if (p3.isCancel(wantDesign)) {
+      p3.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    if (wantDesign) {
+      enabledAddons.push("design-best-practices");
     }
   }
   if (enabledAddons.length > 0) {
@@ -1604,6 +1615,13 @@ Valid addons: ${validAddons.join(", ")}`);
       ].join("\n"),
       "Next Steps"
     );
+    p3.note(
+      [
+        `${chalk4.dim("Execution mode:")} HITL ${chalk4.dim("(default \u2014 safe for unfamiliar codebases)")}`,
+        `${chalk4.dim("Change anytime:")} ${chalk4.cyan("npx devtronic mode afk")}`
+      ].join("\n"),
+      "Autonomous Mode"
+    );
     p3.outro(chalk4.green("Setup complete!"));
   } catch (err) {
     spinner8.stop("Configuration failed");
@@ -1706,8 +1724,8 @@ function buildProjectConfigFromPreset(presetConfig, analysis) {
 }
 
 // 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 { resolve as resolve3, join as join11, dirname as dirname5 } from "path";
+import { existsSync as existsSync8, unlinkSync as unlinkSync2, lstatSync, readdirSync as readdirSync2, rmdirSync as rmdirSync2, chmodSync as chmodSync2 } from "fs";
 import * as p4 from "@clack/prompts";
 import chalk5 from "chalk";
 
@@ -1735,6 +1753,553 @@ var REMOVED_FILES = {
   }
 };
 
+// src/utils/addonConfig.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync, mkdirSync, renameSync } from "fs";
+import { join as join9, dirname as dirname3 } from "path";
+
+// src/addons/registry.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join8 } from "path";
+function getAddonSourceDir(name) {
+  const addonsDir = new URL(".", import.meta.url).pathname;
+  return join8(addonsDir, name);
+}
+function getAddonManifest(name) {
+  const sourceDir = getAddonSourceDir(name);
+  const manifestPath = join8(sourceDir, "manifest.json");
+  const raw = readFileSync2(manifestPath, "utf-8");
+  const manifest = JSON.parse(raw);
+  if (!manifest.name) throw new Error(`Addon manifest missing "name": ${manifestPath}`);
+  if (!manifest.version) throw new Error(`Addon manifest missing "version": ${manifestPath}`);
+  if (!manifest.files?.skills?.length) throw new Error(`Addon manifest has empty skills: ${manifestPath}`);
+  return manifest;
+}
+function getAvailableAddons() {
+  return Object.values(ADDONS);
+}
+
+// src/utils/addonConfig.ts
+var CONFIG_DIR = ".claude";
+var CONFIG_FILE = "devtronic.json";
+function getConfigPath(targetDir) {
+  return join9(targetDir, CONFIG_DIR, CONFIG_FILE);
+}
+function getLegacyConfigPath(targetDir) {
+  return join9(targetDir, CONFIG_FILE);
+}
+function readAddonConfig(targetDir) {
+  const configPath = getConfigPath(targetDir);
+  const legacyPath = getLegacyConfigPath(targetDir);
+  if (!existsSync6(configPath) && existsSync6(legacyPath)) {
+    mkdirSync(dirname3(configPath), { recursive: true });
+    renameSync(legacyPath, configPath);
+  }
+  if (!existsSync6(configPath)) {
+    return { agents: ["claude"], installed: {} };
+  }
+  const raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+  const data = raw.addons ?? raw;
+  return {
+    version: 1,
+    mode: data.mode,
+    agents: data.agents ?? ["claude"],
+    installed: data.installed ?? {}
+  };
+}
+function writeAddonConfig(targetDir, config) {
+  const configPath = getConfigPath(targetDir);
+  mkdirSync(dirname3(configPath), { recursive: true });
+  const payload = { version: 1, ...config };
+  writeFileSync(configPath, JSON.stringify(payload, null, 2) + "\n");
+}
+function writeAddonToConfig(targetDir, name, entry) {
+  const config = readAddonConfig(targetDir);
+  config.installed[name] = entry;
+  writeAddonConfig(targetDir, config);
+}
+function removeAddonFromConfig(targetDir, name) {
+  const config = readAddonConfig(targetDir);
+  delete config.installed[name];
+  writeAddonConfig(targetDir, config);
+}
+function readMode(targetDir) {
+  const config = readAddonConfig(targetDir);
+  return config.mode ?? "hitl";
+}
+function writeMode(targetDir, mode) {
+  const config = readAddonConfig(targetDir);
+  config.mode = mode;
+  writeAddonConfig(targetDir, config);
+}
+function detectOrphanedAddonFiles(targetDir) {
+  const config = readAddonConfig(targetDir);
+  const orphaned = [];
+  for (const addon of getAvailableAddons()) {
+    if (config.installed[addon.name]) continue;
+    const skillDir = join9(targetDir, ".claude", "skills", addon.name);
+    if (existsSync6(skillDir)) {
+      orphaned.push(addon.name);
+    }
+  }
+  return orphaned;
+}
+function registerAddonInConfig(targetDir, addonName) {
+  const manifest = getAddonManifest(addonName);
+  const fileList = [
+    ...(manifest.files.skills ?? []).map((s) => `skills/${s}`),
+    ...(manifest.files.agents ?? []).map((a) => `agents/${a}.md`),
+    ...(manifest.files.rules ?? []).map((r) => `rules/${r}`)
+  ];
+  writeAddonToConfig(targetDir, addonName, {
+    version: manifest.version,
+    files: fileList
+  });
+}
+
+// src/generators/addonFiles.ts
+import {
+  existsSync as existsSync7,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  rmSync,
+  unlinkSync,
+  readdirSync,
+  rmdirSync
+} from "fs";
+import { join as join10, dirname as dirname4 } from "path";
+import { createHash } from "crypto";
+var AGENT_PATHS = {
+  claude: ".claude",
+  cursor: ".cursor",
+  gemini: ".gemini"
+};
+function stripFrontmatterName(content) {
+  return content.replace(/^(---\n)([\s\S]*?)(---)/m, (_match, open, body, close) => {
+    const cleaned = body.split("\n").filter((l) => !l.startsWith("name:")).join("\n");
+    return `${open}${cleaned}${close}`;
+  });
+}
+var RUNTIME_SPECS = {
+  claude: {
+    baseDir: ".claude",
+    skillAdapter: (name, content) => ({
+      relPath: `skills/${name}/SKILL.md`,
+      content
+    }),
+    rulesDir: "rules"
+  },
+  gemini: {
+    baseDir: ".gemini",
+    skillAdapter: (name, content) => ({
+      relPath: `skills/${name}/SKILL.md`,
+      content
+    }),
+    rulesDir: "rules"
+  },
+  opencode: {
+    baseDir: ".opencode",
+    skillAdapter: (name, content) => ({
+      relPath: `command/${name}.md`,
+      content: stripFrontmatterName(content)
+    })
+  },
+  cursor: {
+    baseDir: ".cursor",
+    skillAdapter: (name, content) => ({
+      relPath: `skills/${name}/SKILL.md`,
+      content
+    }),
+    rulesDir: "rules"
+  },
+  codex: {
+    baseDir: ".codex",
+    skillAdapter: (name, content) => ({
+      relPath: `skills/${name}/SKILL.md`,
+      content
+    })
+  }
+};
+function checksum(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function ensureDir2(dir) {
+  if (!existsSync7(dir)) mkdirSync2(dir, { recursive: true });
+}
+function readManifest2(addonSourceDir) {
+  const manifestPath = join10(addonSourceDir, "manifest.json");
+  return JSON.parse(readFileSync4(manifestPath, "utf-8"));
+}
+function buildFileMap(addonSourceDir) {
+  const manifest = readManifest2(addonSourceDir);
+  const files = /* @__PURE__ */ new Map();
+  for (const skill of manifest.files.skills ?? []) {
+    const skillDir = join10(addonSourceDir, "skills", skill);
+    if (!existsSync7(skillDir)) continue;
+    const skillFile = join10(skillDir, "SKILL.md");
+    if (existsSync7(skillFile)) {
+      files.set(`skills/${skill}/SKILL.md`, readFileSync4(skillFile, "utf-8"));
+    }
+  }
+  for (const agent of manifest.files.agents ?? []) {
+    const agentFile = join10(addonSourceDir, "agents", `${agent}.md`);
+    if (existsSync7(agentFile)) {
+      files.set(`agents/${agent}.md`, readFileSync4(agentFile, "utf-8"));
+    }
+  }
+  for (const ref of manifest.files.reference ?? []) {
+    const refPath = join10(addonSourceDir, "reference", ref);
+    if (existsSync7(refPath)) {
+      files.set(`skills/design-harden/reference/${ref}`, readFileSync4(refPath, "utf-8"));
+    }
+  }
+  for (const rule of manifest.files.rules ?? []) {
+    const rulePath = join10(addonSourceDir, "rules", rule);
+    if (existsSync7(rulePath)) {
+      files.set(`rules/${rule}`, readFileSync4(rulePath, "utf-8"));
+    }
+  }
+  return files;
+}
+function generateAddonFiles(projectDir, addonSourceDir, agents) {
+  const fileMap = buildFileMap(addonSourceDir);
+  const manifest = readManifest2(addonSourceDir);
+  const result = { written: 0, skipped: 0, conflicts: [], checksums: {} };
+  for (const agent of agents) {
+    const spec = RUNTIME_SPECS[agent];
+    if (!spec) {
+      const basePath = AGENT_PATHS[agent] ?? `.${agent}`;
+      for (const [relPath, content] of fileMap) {
+        const destPath = join10(projectDir, basePath, relPath);
+        if (existsSync7(destPath)) {
+          result.skipped++;
+          continue;
+        }
+        ensureDir2(dirname4(destPath));
+        writeFileSync2(destPath, content);
+        result.written++;
+        result.checksums[relPath] = checksum(content);
+      }
+      continue;
+    }
+    for (const skillName of manifest.files.skills ?? []) {
+      const skillFile = join10(addonSourceDir, "skills", skillName, "SKILL.md");
+      if (!existsSync7(skillFile)) continue;
+      const rawContent = readFileSync4(skillFile, "utf-8");
+      const { relPath, content } = spec.skillAdapter(skillName, rawContent);
+      const destPath = join10(projectDir, spec.baseDir, relPath);
+      if (existsSync7(destPath)) {
+        const existing = readFileSync4(destPath, "utf-8");
+        if (existing === content) {
+          result.skipped++;
+          continue;
+        }
+        result.skipped++;
+        continue;
+      }
+      ensureDir2(dirname4(destPath));
+      writeFileSync2(destPath, content);
+      result.written++;
+      result.checksums[relPath] = checksum(content);
+    }
+    for (const agentName of manifest.files.agents ?? []) {
+      const agentFile = join10(addonSourceDir, "agents", `${agentName}.md`);
+      if (!existsSync7(agentFile)) continue;
+      const content = readFileSync4(agentFile, "utf-8");
+      const destPath = join10(projectDir, spec.baseDir, "agents", `${agentName}.md`);
+      if (!existsSync7(destPath)) {
+        ensureDir2(dirname4(destPath));
+        writeFileSync2(destPath, content);
+        result.written++;
+        result.checksums[`agents/${agentName}.md`] = checksum(content);
+      } else {
+        result.skipped++;
+      }
+    }
+    if (spec.rulesDir) {
+      for (const rule of manifest.files.rules ?? []) {
+        const ruleSrcPath = join10(addonSourceDir, "rules", rule);
+        if (!existsSync7(ruleSrcPath)) continue;
+        const content = readFileSync4(ruleSrcPath, "utf-8");
+        const destPath = join10(projectDir, spec.baseDir, spec.rulesDir, rule);
+        if (!existsSync7(destPath)) {
+          ensureDir2(dirname4(destPath));
+          writeFileSync2(destPath, content);
+          result.written++;
+          result.checksums[`rules/${rule}`] = checksum(content);
+        } else {
+          result.skipped++;
+        }
+      }
+    }
+    for (const ref of manifest.files.reference ?? []) {
+      const refSrcPath = join10(addonSourceDir, "reference", ref);
+      if (!existsSync7(refSrcPath)) continue;
+      const content = readFileSync4(refSrcPath, "utf-8");
+      const relPath = `skills/design-harden/reference/${ref}`;
+      const destPath = join10(projectDir, spec.baseDir, relPath);
+      if (!existsSync7(destPath)) {
+        ensureDir2(dirname4(destPath));
+        writeFileSync2(destPath, content);
+        result.written++;
+        result.checksums[relPath] = checksum(content);
+      } else {
+        result.skipped++;
+      }
+    }
+  }
+  if (manifest.attribution) {
+    const noticePath = join10(projectDir, "NOTICE.md");
+    const noticeContent = [
+      "# NOTICE",
+      "",
+      "This project includes materials from third-party sources.",
+      "",
+      `## ${manifest.name}`,
+      "",
+      manifest.attribution,
+      "",
+      "Original source: Anthropic frontend-design skill",
+      "License: Apache 2.0 (https://www.apache.org/licenses/LICENSE-2.0)",
+      ""
+    ].join("\n");
+    writeFileSync2(noticePath, noticeContent);
+  }
+  return result;
+}
+function removeAddonFiles(projectDir, addonName, agents, addonSourceDir) {
+  const sourceDir = addonSourceDir ?? getAddonSourceDir(addonName);
+  const manifest = readManifest2(sourceDir);
+  const knownSkills = manifest.files.skills ?? [];
+  const knownAgents = manifest.files.agents ?? [];
+  for (const agent of agents) {
+    const spec = RUNTIME_SPECS[agent];
+    if (!spec) {
+      const basePath = AGENT_PATHS[agent] ?? `.${agent}`;
+      for (const skill of knownSkills) {
+        const skillDir = join10(projectDir, basePath, "skills", skill);
+        if (existsSync7(skillDir)) rmSync(skillDir, { recursive: true, force: true });
+      }
+      for (const agentName of knownAgents) {
+        const agentPath = join10(projectDir, basePath, "agents", `${agentName}.md`);
+        if (existsSync7(agentPath)) unlinkSync(agentPath);
+      }
+      continue;
+    }
+    for (const skillName of knownSkills) {
+      const { relPath } = spec.skillAdapter(skillName, "");
+      const destPath = join10(projectDir, spec.baseDir, relPath);
+      if (existsSync7(destPath)) unlinkSync(destPath);
+      const parentDir = dirname4(destPath);
+      if (existsSync7(parentDir)) {
+        try {
+          const entries = readdirSync(parentDir);
+          if (entries.length === 0) rmdirSync(parentDir);
+        } catch {
+        }
+      }
+    }
+    for (const agentName of knownAgents) {
+      const agentPath = join10(projectDir, spec.baseDir, "agents", `${agentName}.md`);
+      if (existsSync7(agentPath)) unlinkSync(agentPath);
+    }
+    if (spec.rulesDir) {
+      for (const rule of manifest.files.rules ?? []) {
+        const rulePath = join10(projectDir, spec.baseDir, spec.rulesDir, rule);
+        if (existsSync7(rulePath)) unlinkSync(rulePath);
+      }
+    }
+    for (const ref of manifest.files.reference ?? []) {
+      const refPath = join10(projectDir, spec.baseDir, "skills", "design-harden", "reference", ref);
+      if (existsSync7(refPath)) unlinkSync(refPath);
+    }
+    const refDir = join10(projectDir, spec.baseDir, "skills", "design-harden", "reference");
+    if (existsSync7(refDir)) {
+      try {
+        const entries = readdirSync(refDir);
+        if (entries.length === 0) rmdirSync(refDir);
+      } catch {
+      }
+    }
+  }
+  const noticePath = join10(projectDir, "NOTICE.md");
+  if (existsSync7(noticePath)) unlinkSync(noticePath);
+}
+function syncAddonFiles(projectDir, addonSourceDir, agents) {
+  const fileMap = buildFileMap(addonSourceDir);
+  const manifest = readManifest2(addonSourceDir);
+  const addonName = manifest.name;
+  const result = { written: 0, skipped: 0, conflicts: [], updated: 0 };
+  let installedChecksums = {};
+  try {
+    const config = readAddonConfig(projectDir);
+    const installed = config.installed?.[addonName];
+    if (installed?.checksums) {
+      installedChecksums = installed.checksums;
+    }
+  } catch {
+  }
+  for (const agent of agents) {
+    const spec = RUNTIME_SPECS[agent];
+    if (!spec) {
+      const basePath = AGENT_PATHS[agent] ?? `.${agent}`;
+      for (const [relPath, newContent] of fileMap) {
+        const destPath = join10(projectDir, basePath, relPath);
+        if (!existsSync7(destPath)) {
+          ensureDir2(dirname4(destPath));
+          writeFileSync2(destPath, newContent);
+          result.written++;
+          continue;
+        }
+        const existing = readFileSync4(destPath, "utf-8");
+        const existingChecksum = checksum(existing);
+        const originalChecksum = installedChecksums[relPath];
+        if (existing === newContent) {
+          result.skipped++;
+          continue;
+        }
+        if (originalChecksum && existingChecksum !== originalChecksum) {
+          result.conflicts.push(relPath);
+          continue;
+        }
+        writeFileSync2(destPath, newContent);
+        result.updated = (result.updated ?? 0) + 1;
+      }
+      continue;
+    }
+    for (const skillName of manifest.files.skills ?? []) {
+      const skillFile = join10(addonSourceDir, "skills", skillName, "SKILL.md");
+      if (!existsSync7(skillFile)) continue;
+      const rawContent = readFileSync4(skillFile, "utf-8");
+      const { relPath, content: newContent } = spec.skillAdapter(skillName, rawContent);
+      const destPath = join10(projectDir, spec.baseDir, relPath);
+      if (!existsSync7(destPath)) {
+        ensureDir2(dirname4(destPath));
+        writeFileSync2(destPath, newContent);
+        result.written++;
+        continue;
+      }
+      const existing = readFileSync4(destPath, "utf-8");
+      const existingChecksum = checksum(existing);
+      const originalChecksum = installedChecksums[relPath];
+      if (existing === newContent) {
+        result.skipped++;
+        continue;
+      }
+      if (originalChecksum && existingChecksum !== originalChecksum) {
+        result.conflicts.push(relPath);
+        continue;
+      }
+      writeFileSync2(destPath, newContent);
+      result.updated = (result.updated ?? 0) + 1;
+    }
+    for (const agentName of manifest.files.agents ?? []) {
+      const agentFile = join10(addonSourceDir, "agents", `${agentName}.md`);
+      if (!existsSync7(agentFile)) continue;
+      const newContent = readFileSync4(agentFile, "utf-8");
+      const destPath = join10(projectDir, spec.baseDir, "agents", `${agentName}.md`);
+      const relPath = `agents/${agentName}.md`;
+      if (!existsSync7(destPath)) {
+        ensureDir2(dirname4(destPath));
+        writeFileSync2(destPath, newContent);
+        result.written++;
+        continue;
+      }
+      const existing = readFileSync4(destPath, "utf-8");
+      const existingChecksum = checksum(existing);
+      const originalChecksum = installedChecksums[relPath];
+      if (existing === newContent) {
+        result.skipped++;
+        continue;
+      }
+      if (originalChecksum && existingChecksum !== originalChecksum) {
+        result.conflicts.push(relPath);
+        continue;
+      }
+      writeFileSync2(destPath, newContent);
+      result.updated = (result.updated ?? 0) + 1;
+    }
+    if (spec.rulesDir) {
+      for (const rule of manifest.files.rules ?? []) {
+        const ruleSrcPath = join10(addonSourceDir, "rules", rule);
+        if (!existsSync7(ruleSrcPath)) continue;
+        const newContent = readFileSync4(ruleSrcPath, "utf-8");
+        const destPath = join10(projectDir, spec.baseDir, spec.rulesDir, rule);
+        const relPath = `rules/${rule}`;
+        if (!existsSync7(destPath)) {
+          ensureDir2(dirname4(destPath));
+          writeFileSync2(destPath, newContent);
+          result.written++;
+          continue;
+        }
+        const existing = readFileSync4(destPath, "utf-8");
+        const existingChecksum = checksum(existing);
+        const originalChecksum = installedChecksums[relPath];
+        if (existing === newContent) {
+          result.skipped++;
+          continue;
+        }
+        if (originalChecksum && existingChecksum !== originalChecksum) {
+          result.conflicts.push(relPath);
+          continue;
+        }
+        writeFileSync2(destPath, newContent);
+        result.updated = (result.updated ?? 0) + 1;
+      }
+    }
+    for (const ref of manifest.files.reference ?? []) {
+      const refSrcPath = join10(addonSourceDir, "reference", ref);
+      if (!existsSync7(refSrcPath)) continue;
+      const newContent = readFileSync4(refSrcPath, "utf-8");
+      const relPath = `skills/design-harden/reference/${ref}`;
+      const destPath = join10(projectDir, spec.baseDir, relPath);
+      if (!existsSync7(destPath)) {
+        ensureDir2(dirname4(destPath));
+        writeFileSync2(destPath, newContent);
+        result.written++;
+        continue;
+      }
+      const existing = readFileSync4(destPath, "utf-8");
+      const existingChecksum = checksum(existing);
+      const originalChecksum = installedChecksums[relPath];
+      if (existing === newContent) {
+        result.skipped++;
+        continue;
+      }
+      if (originalChecksum && existingChecksum !== originalChecksum) {
+        result.conflicts.push(relPath);
+        continue;
+      }
+      writeFileSync2(destPath, newContent);
+      result.updated = (result.updated ?? 0) + 1;
+    }
+  }
+  return result;
+}
+function detectModifiedAddonFiles(projectDir, addonName) {
+  let installedChecksums = {};
+  try {
+    const config = readAddonConfig(projectDir);
+    const installed = config.installed?.[addonName];
+    if (!installed?.checksums) return [];
+    installedChecksums = installed.checksums;
+  } catch {
+    return [];
+  }
+  const modified = [];
+  for (const agentDir of Object.values(AGENT_PATHS)) {
+    for (const [relPath, originalHash] of Object.entries(installedChecksums)) {
+      const absPath = join10(projectDir, agentDir, relPath);
+      if (!existsSync7(absPath)) continue;
+      const current = checksum(readFileSync4(absPath, "utf-8"));
+      if (current !== originalHash) {
+        modified.push(relPath);
+      }
+    }
+  }
+  return [...new Set(modified)];
+}
+
 // src/commands/update.ts
 async function updateCommand(options) {
   if (!options.check && !options.dryRun) {
@@ -1800,7 +2365,7 @@ async function updateCommand(options) {
   const modifiedFiles = [];
   const outdatedFiles = [];
   for (const [relativePath, fileInfo] of Object.entries(manifest.files)) {
-    const filePath = join8(targetDir, relativePath);
+    const filePath = join11(targetDir, relativePath);
     if (!fileExists(filePath)) {
       continue;
     }
@@ -1812,11 +2377,11 @@ async function updateCommand(options) {
   }
   const newFiles = [];
   for (const ide of manifest.selectedIDEs) {
-    const templateDir = join8(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
-    if (!existsSync6(templateDir)) continue;
+    const templateDir = join11(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (!existsSync8(templateDir)) continue;
     const files = getAllFilesRecursive(templateDir);
     for (const file of files) {
-      const templatePath = join8(templateDir, file);
+      const templatePath = join11(templateDir, file);
       const templateContent = readFile(templatePath);
       const templateChecksum = calculateChecksum(templateContent);
       const fileInfo = manifest.files[file];
@@ -1832,14 +2397,14 @@ async function updateCommand(options) {
     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))) {
+      const templateDir = join11(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+      if (existsSync8(join11(templateDir, relativePath))) {
         foundInAnyTemplate = true;
         break;
       }
     }
     if (!foundInAnyTemplate) {
-      const localPath = join8(targetDir, relativePath);
+      const localPath = join11(targetDir, relativePath);
       if (fileExists(localPath)) {
         removedFromTemplate.push({
           path: relativePath,
@@ -1967,8 +2532,8 @@ async function updateCommand(options) {
     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 templateDir = join11(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (!existsSync8(templateDir)) continue;
     const isPluginMode = ide === "claude-code" && manifest.installMode === "plugin";
     const files = getAllFilesRecursive(templateDir);
     for (const file of files) {
@@ -1978,10 +2543,10 @@ async function updateCommand(options) {
       if (isPluginMode && (file.startsWith(".claude/skills/") || file.startsWith(".claude/agents/"))) {
         continue;
       }
-      const templatePath = join8(templateDir, file);
-      const destPath = join8(targetDir, file);
+      const templatePath = join11(templateDir, file);
+      const destPath = join11(targetDir, file);
       const templateContent = readFile(templatePath);
-      ensureDir(dirname3(destPath));
+      ensureDir(dirname5(destPath));
       writeFile(destPath, templateContent);
       updatedManifest.files[file] = createManifestEntry(templateContent);
     }
@@ -1989,7 +2554,7 @@ async function updateCommand(options) {
   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);
+      const filePath = join11(targetDir, relPath);
       if (!fileExists(filePath)) continue;
       const diskContent = readFile(filePath);
       const diskChecksum = calculateChecksum(diskContent);
@@ -2006,13 +2571,13 @@ async function updateCommand(options) {
       analysis.packageManager
     );
     for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
-      const scriptPath = join8(targetDir, pluginResult.pluginPath, "scripts", script);
-      if (existsSync6(scriptPath)) {
+      const scriptPath = join11(targetDir, pluginResult.pluginPath, "scripts", script);
+      if (existsSync8(scriptPath)) {
         chmodSync2(scriptPath, 493);
       }
     }
     for (const [relPath, content] of userModifiedPluginFiles) {
-      writeFile(join8(targetDir, relPath), content);
+      writeFile(join11(targetDir, relPath), content);
     }
     for (const [relPath, newEntry] of Object.entries(pluginResult.files)) {
       if (userModifiedPluginFiles.has(relPath)) {
@@ -2023,9 +2588,9 @@ async function updateCommand(options) {
     updatedManifest.pluginPath = pluginResult.pluginPath;
   }
   for (const filePath of filesToDelete) {
-    const localPath = join8(targetDir, filePath);
+    const localPath = join11(targetDir, filePath);
     if (fileExists(localPath)) {
-      unlinkSync(localPath);
+      unlinkSync2(localPath);
     }
     delete updatedManifest.files[filePath];
   }
@@ -2034,12 +2599,12 @@ async function updateCommand(options) {
       updatedManifest.files[filePath].ignored = true;
     }
   }
-  const claudeMdPath = join8(targetDir, "CLAUDE.md");
+  const claudeMdPath = join11(targetDir, "CLAUDE.md");
   if (fileExists(claudeMdPath)) {
     const stat = lstatSync(claudeMdPath);
     if (stat.isSymbolicLink()) {
       const content = readFile(claudeMdPath);
-      unlinkSync(claudeMdPath);
+      unlinkSync2(claudeMdPath);
       writeFile(claudeMdPath, content);
       updatedManifest.files["CLAUDE.md"] = createManifestEntry(content);
       p4.log.info("Migrated CLAUDE.md from symlink to independent file.");
@@ -2047,6 +2612,28 @@ async function updateCommand(options) {
   }
   writeManifest(targetDir, updatedManifest);
   spinner8.stop("Updates applied");
+  const orphaned = detectOrphanedAddonFiles(targetDir);
+  if (orphaned.length > 0) {
+    const migSpinner = p4.spinner();
+    migSpinner.start("Migrating detected addon files to config...");
+    for (const addonName of orphaned) {
+      registerAddonInConfig(targetDir, addonName);
+    }
+    migSpinner.stop(`${symbols.pass} Migrated: ${orphaned.join(", ")}`);
+  }
+  const addonConfig = readAddonConfig(targetDir);
+  const enabledAddons = Object.keys(addonConfig.installed);
+  if (enabledAddons.length > 0 && !options.check) {
+    const syncSpinner = p4.spinner();
+    syncSpinner.start("Updating enabled addon files...");
+    let totalUpdated = 0;
+    for (const name of enabledAddons) {
+      const addonSourceDir = getAddonSourceDir(name);
+      const result = syncAddonFiles(targetDir, addonSourceDir, addonConfig.agents);
+      totalUpdated += (result.updated ?? 0) + result.written;
+    }
+    syncSpinner.stop(`${symbols.pass} Addon files updated (${totalUpdated} files)`);
+  }
   p4.outro(chalk5.green(`Updated to version ${currentVersion}`));
 }
 function detectStackChanges(savedConfig, analysis) {
@@ -2153,7 +2740,7 @@ async function regenerateWithNewStack(targetDir, manifest, analysis, dryRun) {
   const spinner8 = p4.spinner();
   spinner8.start("Regenerating with new stack...");
   const regeneratedFiles = [];
-  const agentsMdPath = join8(targetDir, "AGENTS.md");
+  const agentsMdPath = join11(targetDir, "AGENTS.md");
   if (fileExists(agentsMdPath)) {
     const agentsMdContent = generateAgentsMdFromConfig(
       newConfig,
@@ -2164,12 +2751,12 @@ async function regenerateWithNewStack(targetDir, manifest, analysis, dryRun) {
     regeneratedFiles.push("AGENTS.md");
     manifest.files["AGENTS.md"] = createManifestEntry(agentsMdContent);
   }
-  const claudeMdPath = join8(targetDir, "CLAUDE.md");
+  const claudeMdPath = join11(targetDir, "CLAUDE.md");
   if (fileExists(claudeMdPath)) {
     const stat = lstatSync(claudeMdPath);
     if (stat.isSymbolicLink()) {
       const content = readFile(claudeMdPath);
-      unlinkSync(claudeMdPath);
+      unlinkSync2(claudeMdPath);
       writeFile(claudeMdPath, content);
       manifest.files["CLAUDE.md"] = createManifestEntry(content);
       p4.log.info("Migrated CLAUDE.md from symlink to independent file.");
@@ -2181,8 +2768,8 @@ async function regenerateWithNewStack(targetDir, manifest, analysis, dryRun) {
       const ruleContent = getRuleContentForIDE(ide, generatedRules);
       const rulePath = DYNAMIC_RULE_FILES[ide]?.[0];
       if (ruleContent && rulePath) {
-        const destPath = join8(targetDir, rulePath);
-        ensureDir(dirname3(destPath));
+        const destPath = join11(targetDir, rulePath);
+        ensureDir(dirname5(destPath));
         writeFile(destPath, ruleContent);
         regeneratedFiles.push(rulePath);
         manifest.files[rulePath] = createManifestEntry(ruleContent);
@@ -2192,7 +2779,7 @@ async function regenerateWithNewStack(targetDir, manifest, analysis, dryRun) {
   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);
+      const filePath = join11(targetDir, relPath);
       if (!fileExists(filePath)) continue;
       const diskContent = readFile(filePath);
       const diskChecksum = calculateChecksum(diskContent);
@@ -2208,13 +2795,13 @@ async function regenerateWithNewStack(targetDir, manifest, analysis, dryRun) {
       analysis.packageManager
     );
     for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
-      const scriptPath = join8(targetDir, pluginResult.pluginPath, "scripts", script);
-      if (existsSync6(scriptPath)) {
+      const scriptPath = join11(targetDir, pluginResult.pluginPath, "scripts", script);
+      if (existsSync8(scriptPath)) {
         chmodSync2(scriptPath, 493);
       }
     }
     for (const [relPath, content] of userModifiedPluginFiles) {
-      writeFile(join8(targetDir, relPath), content);
+      writeFile(join11(targetDir, relPath), content);
     }
     for (const [relPath, newEntry] of Object.entries(pluginResult.files)) {
       if (userModifiedPluginFiles.has(relPath)) {
@@ -2257,8 +2844,8 @@ async function migrateToPlugin(targetDir, manifest, analysis, dryRun) {
     analysis.packageManager
   );
   for (const script of ["checkpoint.sh", "stop-guard.sh"]) {
-    const scriptPath = join8(targetDir, pluginResult.pluginPath, "scripts", script);
-    if (existsSync6(scriptPath)) {
+    const scriptPath = join11(targetDir, pluginResult.pluginPath, "scripts", script);
+    if (existsSync8(scriptPath)) {
       chmodSync2(scriptPath, 493);
     }
   }
@@ -2267,19 +2854,19 @@ async function migrateToPlugin(targetDir, manifest, analysis, dryRun) {
   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);
+    const filePath = join11(targetDir, path);
     if (!fileExists(filePath)) continue;
     const current = calculateChecksum(readFile(filePath));
     if (current === fileInfo.originalChecksum) {
-      unlinkSync(filePath);
+      unlinkSync2(filePath);
       delete manifest.files[path];
       removed.push(path);
     } else {
       preserved.push(path);
     }
   }
-  cleanEmptyDirs(join8(targetDir, ".claude", "skills"));
-  cleanEmptyDirs(join8(targetDir, ".claude", "agents"));
+  cleanEmptyDirs(join11(targetDir, ".claude", "skills"));
+  cleanEmptyDirs(join11(targetDir, ".claude", "agents"));
   Object.assign(manifest.files, pluginResult.files);
   manifest.installMode = "plugin";
   manifest.pluginPath = pluginResult.pluginPath;
@@ -2328,22 +2915,22 @@ function buildDefaultConfig(analysis) {
   };
 }
 function cleanEmptyDirs(dirPath) {
-  if (!existsSync6(dirPath)) return;
-  const entries = readdirSync(dirPath);
+  if (!existsSync8(dirPath)) return;
+  const entries = readdirSync2(dirPath);
   for (const entry of entries) {
-    const fullPath = join8(dirPath, entry);
-    if (existsSync6(fullPath) && lstatSync(fullPath).isDirectory()) {
+    const fullPath = join11(dirPath, entry);
+    if (existsSync8(fullPath) && lstatSync(fullPath).isDirectory()) {
       cleanEmptyDirs(fullPath);
     }
   }
-  const remaining = readdirSync(dirPath);
+  const remaining = readdirSync2(dirPath);
   if (remaining.length === 0) {
-    rmdirSync(dirPath);
+    rmdirSync2(dirPath);
   }
 }
 
 // src/commands/status.ts
-import { resolve as resolve4, join as join9 } from "path";
+import { resolve as resolve4, join as join12 } from "path";
 import * as p5 from "@clack/prompts";
 import chalk6 from "chalk";
 async function statusCommand(options = {}) {
@@ -2357,6 +2944,22 @@ async function statusCommand(options = {}) {
     p5.outro("");
     return;
   }
+  const mode = readMode(targetDir);
+  const addonConfig = readAddonConfig(targetDir);
+  const allAddons = getAvailableAddons();
+  p5.note(
+    [
+      `${formatKV("Mode:", chalk6.cyan(mode))}`,
+      `${formatKV("Config:", chalk6.dim(".claude/devtronic.json"))}`
+    ].join("\n"),
+    "Execution Mode"
+  );
+  const addonLines = allAddons.map((addon) => {
+    const isEnabled = !!addonConfig.installed[addon.name];
+    const statusStr = isEnabled ? chalk6.green("enabled") : chalk6.dim("disabled");
+    return `  ${chalk6.bold((addon.name + ":").padEnd(28))} ${statusStr}`;
+  });
+  p5.note(addonLines.join("\n"), "Addons");
   p5.note(
     [
       formatKV("Version:", manifest.version),
@@ -2367,7 +2970,7 @@ async function statusCommand(options = {}) {
   );
   const fileStatuses = [];
   for (const [relativePath, fileInfo] of Object.entries(manifest.files)) {
-    const filePath = join9(targetDir, relativePath);
+    const filePath = join12(targetDir, relativePath);
     if (!fileExists(filePath)) {
       fileStatuses.push({ path: relativePath, status: "missing" });
       continue;
@@ -2413,8 +3016,8 @@ async function statusCommand(options = {}) {
 }
 
 // src/commands/diff.ts
-import { resolve as resolve5, join as join10 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve5, join as join13 } from "path";
+import { existsSync as existsSync9 } from "fs";
 import * as p6 from "@clack/prompts";
 import chalk7 from "chalk";
 async function diffCommand(options = {}) {
@@ -2429,12 +3032,12 @@ async function diffCommand(options = {}) {
   }
   const diffs = [];
   for (const ide of manifest.selectedIDEs) {
-    const templateDir = join10(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
-    if (!existsSync7(templateDir)) continue;
+    const templateDir = join13(TEMPLATES_DIR, IDE_TEMPLATE_MAP[ide]);
+    if (!existsSync9(templateDir)) continue;
     const templateFiles = getAllFilesRecursive(templateDir);
     for (const file of templateFiles) {
-      const templatePath = join10(templateDir, file);
-      const localPath = join10(targetDir, file);
+      const templatePath = join13(templateDir, file);
+      const localPath = join13(targetDir, file);
       const templateContent = readFile(templatePath);
       const templateChecksum = calculateChecksum(templateContent);
       const manifestEntry = manifest.files[file];
@@ -2487,8 +3090,8 @@ async function diffCommand(options = {}) {
 }
 
 // src/commands/add.ts
-import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve6, join as join11, dirname as dirname4 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve6, join as join14, dirname as dirname6 } from "path";
 import * as p7 from "@clack/prompts";
 import chalk8 from "chalk";
 var ALL_IDES = [
@@ -2582,8 +3185,8 @@ Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
   const generatedFiles = [];
   const generatedRules = generateArchitectureRules(manifest.projectConfig);
   const templateName = IDE_TEMPLATE_MAP[selectedIDE];
-  const templateDir = join11(TEMPLATES_DIR, templateName);
-  if (!existsSync8(templateDir)) {
+  const templateDir = join14(TEMPLATES_DIR, templateName);
+  if (!existsSync10(templateDir)) {
     spinner8.stop("Error");
     p7.cancel(`Template not found: ${templateName}`);
     process.exit(1);
@@ -2594,8 +3197,8 @@ Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
     if (dynamicFiles.includes(file)) {
       continue;
     }
-    const sourcePath = join11(templateDir, file);
-    const destPath = join11(targetDir, file);
+    const sourcePath = join14(templateDir, file);
+    const destPath = join14(targetDir, file);
     const sourceContent = readFile(sourcePath);
     if (fileExists(destPath)) {
       if (conflictResolution === "keep") {
@@ -2612,7 +3215,7 @@ Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
         continue;
       }
     }
-    ensureDir(dirname4(destPath));
+    ensureDir(dirname6(destPath));
     writeFile(destPath, sourceContent);
     appliedFiles.push(file);
     manifest.files[file] = createManifestEntry(sourceContent);
@@ -2621,7 +3224,7 @@ Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
   if (ruleContent) {
     const rulePath = dynamicFiles[0];
     if (rulePath) {
-      const destPath = join11(targetDir, rulePath);
+      const destPath = join14(targetDir, rulePath);
       if (fileExists(destPath) && conflictResolution === "keep") {
         skippedFiles.push(rulePath);
       } else if (fileExists(destPath) && conflictResolution === "merge") {
@@ -2632,7 +3235,7 @@ Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
         mergedFiles.push(rulePath);
         manifest.files[rulePath] = createManifestEntry(mergedContent);
       } else {
-        ensureDir(dirname4(destPath));
+        ensureDir(dirname6(destPath));
         writeFile(destPath, ruleContent);
         generatedFiles.push(`${rulePath} (personalized)`);
         manifest.files[rulePath] = createManifestEntry(ruleContent);
@@ -2673,14 +3276,14 @@ Valid options: ${ALL_IDES.map((i) => i.value).join(", ")}`
 }
 
 // src/commands/regenerate.ts
-import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve7, join as join12, dirname as dirname5 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve7, join as join15, dirname as dirname7 } 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");
+var __regen_dirname = dirname7(__filename);
+var TEMPLATES_DIR2 = existsSync11(resolve7(__regen_dirname, "../templates")) ? resolve7(__regen_dirname, "../templates") : resolve7(__regen_dirname, "../../templates");
 async function regenerateCommand(target, options) {
   ensureInteractive("regenerate");
   const targetDir = resolve7(options.path || ".");
@@ -2757,7 +3360,7 @@ Valid options:
     return;
   }
   if (regenerateClaudeMd) {
-    const claudeMdPath = join12(targetDir, "CLAUDE.md");
+    const claudeMdPath = join15(targetDir, "CLAUDE.md");
     if (fileExists(claudeMdPath)) {
       p8.log.warn(
         "Regenerating CLAUDE.md will overwrite any self-improvements (Gotchas section)."
@@ -2794,7 +3397,7 @@ Valid options:
   spinner8.start("Regenerating files...");
   const regeneratedFiles = [];
   if (regenerateClaudeMd) {
-    const claudeMdPath = join12(targetDir, "CLAUDE.md");
+    const claudeMdPath = join15(targetDir, "CLAUDE.md");
     const claudeMdContent = generateClaudeMd(
       fullProjectConfig,
       analysis.scripts,
@@ -2805,7 +3408,7 @@ Valid options:
     manifest.files["CLAUDE.md"] = createManifestEntry(claudeMdContent);
   }
   if (regenerateAgentsMd) {
-    const agentsMdPath = join12(targetDir, "AGENTS.md");
+    const agentsMdPath = join15(targetDir, "AGENTS.md");
     const agentsMdContent = generateAgentsMdFromConfig(
       fullProjectConfig,
       analysis.scripts,
@@ -2822,8 +3425,8 @@ Valid options:
         const ruleContent = getRuleContentForIDE(ide, generatedRules);
         const rulePath = DYNAMIC_RULE_FILES[ide]?.[0];
         if (ruleContent && rulePath) {
-          const destPath = join12(targetDir, rulePath);
-          ensureDir(dirname5(destPath));
+          const destPath = join15(targetDir, rulePath);
+          ensureDir(dirname7(destPath));
           writeFile(destPath, ruleContent);
           regeneratedFiles.push(rulePath);
           manifest.files[rulePath] = createManifestEntry(ruleContent);
@@ -2837,7 +3440,7 @@ Valid options:
     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-5ZMTSRIW.js");
+      const { generatePlugin: generatePlugin2 } = await import("./plugin-SGSFVXPA.js");
       const pluginResult = generatePlugin2(
         targetDir,
         TEMPLATES_DIR2,
@@ -2872,8 +3475,8 @@ Valid options:
 }
 
 // src/commands/info.ts
-import { resolve as resolve8, join as join13 } from "path";
-import { existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve8, join as join16 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync3 } from "fs";
 import * as p9 from "@clack/prompts";
 import chalk10 from "chalk";
 async function infoCommand() {
@@ -2886,33 +3489,33 @@ async function infoCommand() {
   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(
+    const pluginDir = manifest.pluginPath ? join16(targetDir, manifest.pluginPath) : null;
+    if (pluginDir && existsSync12(pluginDir)) {
+      const skillsDir = join16(pluginDir, "skills");
+      const agentsDir = join16(pluginDir, "agents");
+      if (existsSync12(skillsDir)) {
+        skillCount = readdirSync3(skillsDir, { withFileTypes: true }).filter(
           (e) => e.isDirectory() || e.isFile() && e.name.endsWith(".md")
         ).length;
       }
-      if (existsSync10(agentsDir)) {
-        agentCount = readdirSync2(agentsDir, { withFileTypes: true }).filter(
+      if (existsSync12(agentsDir)) {
+        agentCount = readdirSync3(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(
+      const claudeSkills = join16(targetDir, ".claude", "skills");
+      if (existsSync12(claudeSkills)) {
+        skillCount = readdirSync3(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(
+      const claudeAgents = join16(targetDir, ".claude", "agents");
+      if (existsSync12(claudeAgents)) {
+        agentCount = readdirSync3(claudeAgents, { withFileTypes: true }).filter(
           (e) => e.isFile() && e.name.endsWith(".md")
         ).length;
       }
@@ -2955,8 +3558,8 @@ async function infoCommand() {
 }
 
 // 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 { resolve as resolve9, join as join17 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "fs";
 import * as p10 from "@clack/prompts";
 import chalk11 from "chalk";
 async function listCommand(filter, options) {
@@ -2973,30 +3576,30 @@ Valid options: skills, agents`);
   }
   const skills = [];
   const agents = [];
-  const pluginDir = manifest?.pluginPath ? join14(targetDir, manifest.pluginPath) : null;
-  if (pluginDir && existsSync11(pluginDir)) {
+  const pluginDir = manifest?.pluginPath ? join17(targetDir, manifest.pluginPath) : null;
+  if (pluginDir && existsSync13(pluginDir)) {
     if (showSkills) {
-      const skillsDir = join14(pluginDir, "skills");
-      if (existsSync11(skillsDir)) {
+      const skillsDir = join17(pluginDir, "skills");
+      if (existsSync13(skillsDir)) {
         skills.push(...discoverSkills(skillsDir));
       }
     }
     if (showAgents) {
-      const agentsDir = join14(pluginDir, "agents");
-      if (existsSync11(agentsDir)) {
+      const agentsDir = join17(pluginDir, "agents");
+      if (existsSync13(agentsDir)) {
         agents.push(...discoverAgents(agentsDir));
       }
     }
   }
   if (showSkills && skills.length === 0) {
-    const claudeSkills = join14(targetDir, ".claude", "skills");
-    if (existsSync11(claudeSkills)) {
+    const claudeSkills = join17(targetDir, ".claude", "skills");
+    if (existsSync13(claudeSkills)) {
       skills.push(...discoverSkills(claudeSkills));
     }
   }
   if (showAgents && agents.length === 0) {
-    const claudeAgents = join14(targetDir, ".claude", "agents");
-    if (existsSync11(claudeAgents)) {
+    const claudeAgents = join17(targetDir, ".claude", "agents");
+    if (existsSync13(claudeAgents)) {
       agents.push(...discoverAgents(claudeAgents));
     }
   }
@@ -3020,15 +3623,15 @@ Valid options: skills, agents`);
 }
 function discoverSkills(skillsDir) {
   const items = [];
-  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  const entries = readdirSync4(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) : "";
+      const skillMd = join17(skillsDir, entry.name, "SKILL.md");
+      const description = existsSync13(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));
+      const description = extractDescription(join17(skillsDir, entry.name));
       items.push({ name, description });
     }
   }
@@ -3036,11 +3639,11 @@ function discoverSkills(skillsDir) {
 }
 function discoverAgents(agentsDir) {
   const items = [];
-  const entries = readdirSync3(agentsDir, { withFileTypes: true });
+  const entries = readdirSync4(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));
+      const description = extractDescription(join17(agentsDir, entry.name));
       items.push({ name, description });
     }
   }
@@ -3048,7 +3651,7 @@ function discoverAgents(agentsDir) {
 }
 function extractDescription(filePath) {
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const lines = content.split("\n");
     let pastHeading = false;
     for (const line of lines) {
@@ -3227,8 +3830,8 @@ async function configResetCommand(options) {
 }
 
 // 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 { resolve as resolve11, join as join18 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync5, statSync, chmodSync as chmodSync3, mkdirSync as mkdirSync3 } from "fs";
 import { execSync } from "child_process";
 import * as p12 from "@clack/prompts";
 import chalk13 from "chalk";
@@ -3329,7 +3932,7 @@ function checkManifestFiles(targetDir, manifest) {
   let existCount = 0;
   const missing = [];
   for (const relativePath of Object.keys(manifest.files)) {
-    if (fileExists(join15(targetDir, relativePath))) {
+    if (fileExists(join18(targetDir, relativePath))) {
       existCount++;
     } else {
       missing.push(relativePath);
@@ -3349,15 +3952,15 @@ function checkManifestFiles(targetDir, manifest) {
   };
 }
 function checkScriptPermissions(targetDir, manifest) {
-  const pluginDir = manifest.pluginPath ? join15(targetDir, manifest.pluginPath) : null;
+  const pluginDir = manifest.pluginPath ? join18(targetDir, manifest.pluginPath) : null;
   const shFiles = [];
-  if (pluginDir && existsSync12(pluginDir)) {
-    const scriptsDir = join15(pluginDir, "scripts");
-    if (existsSync12(scriptsDir)) {
-      const entries = readdirSync4(scriptsDir);
+  if (pluginDir && existsSync14(pluginDir)) {
+    const scriptsDir = join18(pluginDir, "scripts");
+    if (existsSync14(scriptsDir)) {
+      const entries = readdirSync5(scriptsDir);
       for (const entry of entries) {
         if (entry.endsWith(".sh")) {
-          shFiles.push(join15(scriptsDir, entry));
+          shFiles.push(join18(scriptsDir, entry));
         }
       }
     }
@@ -3420,28 +4023,28 @@ function checkPluginRegistered(targetDir) {
   };
 }
 function checkHookScripts(targetDir, manifest) {
-  const pluginDir = manifest.pluginPath ? join15(targetDir, manifest.pluginPath) : null;
-  if (!pluginDir || !existsSync12(pluginDir)) {
+  const pluginDir = manifest.pluginPath ? join18(targetDir, manifest.pluginPath) : null;
+  if (!pluginDir || !existsSync14(pluginDir)) {
     return {
       name: "hooks",
       status: "pass",
       message: "No hooks directory to check"
     };
   }
-  const hooksDir = join15(pluginDir, "hooks");
-  if (!existsSync12(hooksDir)) {
+  const hooksDir = join18(pluginDir, "hooks");
+  if (!existsSync14(hooksDir)) {
     return {
       name: "hooks",
       status: "pass",
       message: "No hooks directory found"
     };
   }
-  const hookFiles = readdirSync4(hooksDir).filter((f) => f.endsWith(".json"));
+  const hookFiles = readdirSync5(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 hookContent = JSON.parse(readFile(join18(hooksDir, hookFile)));
       const hooks = Array.isArray(hookContent) ? hookContent : [hookContent];
       for (const hook of hooks) {
         if (hook.command) {
@@ -3455,8 +4058,8 @@ function checkHookScripts(targetDir, manifest) {
               /\$\{[A-Z_]+\}\//g,
               ""
             );
-            const scriptPath = join15(pluginDir, resolved);
-            if (existsSync12(scriptPath)) {
+            const scriptPath = join18(pluginDir, resolved);
+            if (existsSync14(scriptPath)) {
               valid++;
             }
           } else {
@@ -3480,7 +4083,7 @@ function checkHookScripts(targetDir, manifest) {
   };
 }
 function checkQualityScripts(targetDir) {
-  const pkgPath = join15(targetDir, "package.json");
+  const pkgPath = join18(targetDir, "package.json");
   if (!fileExists(pkgPath)) {
     return { name: "quality", status: "warn", message: "No package.json found" };
   }
@@ -3506,8 +4109,8 @@ function checkQualityScripts(targetDir) {
   }
 }
 function checkThoughtsDir(targetDir) {
-  const thoughtsDir = join15(targetDir, "thoughts");
-  if (existsSync12(thoughtsDir)) {
+  const thoughtsDir = join18(targetDir, "thoughts");
+  if (existsSync14(thoughtsDir)) {
     return {
       name: "thoughts",
       status: "pass",
@@ -3531,15 +4134,15 @@ function checkThoughtsDir(targetDir) {
         "thoughts/archive/backlog"
       ];
       for (const dir of dirs) {
-        mkdirSync(join15(targetDir, dir), { recursive: true });
+        mkdirSync3(join18(targetDir, dir), { recursive: true });
       }
     }
   };
 }
 function checkEslint(targetDir) {
   try {
-    const eslintLocal = join15(targetDir, "node_modules", ".bin", "eslint");
-    if (existsSync12(eslintLocal)) {
+    const eslintLocal = join18(targetDir, "node_modules", ".bin", "eslint");
+    if (existsSync14(eslintLocal)) {
       return { name: "eslint", status: "pass", message: "eslint is available" };
     }
     execSync("which eslint", { stdio: "pipe" });
@@ -3554,8 +4157,8 @@ function checkEslint(targetDir) {
 }
 
 // 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 { existsSync as existsSync15, rmSync as rmSync2, readdirSync as readdirSync6 } from "fs";
+import { resolve as resolve12, join as join19, dirname as dirname8 } from "path";
 import * as p13 from "@clack/prompts";
 import chalk14 from "chalk";
 var DEVTRONIC_FILES = ["CLAUDE.md", "AGENTS.md"];
@@ -3573,12 +4176,12 @@ async function uninstallCommand(options) {
     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"));
+  const existingFiles = managedFiles.filter((f) => fileExists(join19(targetDir, f)));
+  const missingFiles = managedFiles.filter((f) => !fileExists(join19(targetDir, f)));
+  const hasPlugin = manifest.installMode === "plugin" && existsSync15(join19(targetDir, PLUGIN_DIR, PLUGIN_NAME));
+  const hasThoughts = existsSync15(join19(targetDir, "thoughts"));
+  const hasClaudeMd = fileExists(join19(targetDir, "CLAUDE.md"));
+  const hasAgentsMd = fileExists(join19(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"}`);
@@ -3664,18 +4267,18 @@ async function uninstallCommand(options) {
   }
   if (hasPlugin) {
     try {
-      rmSync(join16(targetDir, PLUGIN_DIR, PLUGIN_NAME), { recursive: true, force: true });
+      rmSync2(join19(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 });
+      const marketplaceDescDir = join19(targetDir, PLUGIN_DIR, ".claude-plugin");
+      if (existsSync15(marketplaceDescDir)) {
+        rmSync2(marketplaceDescDir, { recursive: true, force: true });
         removed.push(`${PLUGIN_DIR}/.claude-plugin/`);
       }
-      const pluginsDir = join16(targetDir, PLUGIN_DIR);
-      if (existsSync13(pluginsDir)) {
+      const pluginsDir = join19(targetDir, PLUGIN_DIR);
+      if (existsSync15(pluginsDir)) {
         const remaining = readdirSafe(pluginsDir);
         if (remaining.length === 0) {
-          rmSync(pluginsDir, { recursive: true, force: true });
+          rmSync2(pluginsDir, { recursive: true, force: true });
           removed.push(`${PLUGIN_DIR}/ (empty)`);
         }
       }
@@ -3688,11 +4291,11 @@ async function uninstallCommand(options) {
     if (file.startsWith("thoughts/")) continue;
     if (file.startsWith(PLUGIN_DIR + "/")) continue;
     try {
-      const filePath = join16(targetDir, file);
-      if (existsSync13(filePath)) {
-        rmSync(filePath, { force: true });
+      const filePath = join19(targetDir, file);
+      if (existsSync15(filePath)) {
+        rmSync2(filePath, { force: true });
         removed.push(file);
-        cleanEmptyParents(targetDir, dirname6(file));
+        cleanEmptyParents(targetDir, dirname8(file));
       }
     } catch (err) {
       errors.push(`Failed to remove ${file}: ${err instanceof Error ? err.message : String(err)}`);
@@ -3701,7 +4304,7 @@ async function uninstallCommand(options) {
   if (hasClaudeMd) {
     if (removeClaudeMd) {
       try {
-        rmSync(join16(targetDir, "CLAUDE.md"), { force: true });
+        rmSync2(join19(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)}`);
@@ -3713,7 +4316,7 @@ async function uninstallCommand(options) {
   if (hasAgentsMd) {
     if (removeAgentsMd) {
       try {
-        rmSync(join16(targetDir, "AGENTS.md"), { force: true });
+        rmSync2(join19(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)}`);
@@ -3725,7 +4328,7 @@ async function uninstallCommand(options) {
   if (hasThoughts) {
     if (removeThoughts) {
       try {
-        rmSync(join16(targetDir, "thoughts"), { recursive: true, force: true });
+        rmSync2(join19(targetDir, "thoughts"), { recursive: true, force: true });
         removed.push("thoughts/");
       } catch (err) {
         errors.push(`Failed to remove thoughts/: ${err instanceof Error ? err.message : String(err)}`);
@@ -3735,9 +4338,9 @@ async function uninstallCommand(options) {
     }
   }
   try {
-    const manifestDir = join16(targetDir, MANIFEST_DIR);
-    if (existsSync13(manifestDir)) {
-      rmSync(manifestDir, { recursive: true, force: true });
+    const manifestDir = join19(targetDir, MANIFEST_DIR);
+    if (existsSync15(manifestDir)) {
+      rmSync2(manifestDir, { recursive: true, force: true });
       removed.push(`${MANIFEST_DIR}/`);
     }
   } catch (err) {
@@ -3782,33 +4385,59 @@ async function uninstallCommand(options) {
 }
 function cleanEmptyParents(targetDir, relDir) {
   if (!relDir || relDir === ".") return;
-  const absDir = join16(targetDir, relDir);
-  if (!existsSync13(absDir)) return;
+  const absDir = join19(targetDir, relDir);
+  if (!existsSync15(absDir)) return;
   const entries = readdirSafe(absDir);
   if (entries.length === 0) {
     try {
-      rmSync(absDir, { recursive: true, force: true });
-      cleanEmptyParents(targetDir, dirname6(relDir));
+      rmSync2(absDir, { recursive: true, force: true });
+      cleanEmptyParents(targetDir, dirname8(relDir));
     } catch {
     }
   }
 }
 function readdirSafe(dir) {
   try {
-    return readdirSync5(dir);
+    return readdirSync6(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 { resolve as resolve13, join as join20, dirname as dirname9 } from "path";
+import { existsSync as existsSync16, unlinkSync as unlinkSync3, rmSync as rmSync3, readFileSync as readFileSync6 } from "fs";
 import * as p14 from "@clack/prompts";
 import chalk15 from "chalk";
+function isFileBasedAddon(addonName) {
+  return addonName !== "orchestration";
+}
 async function addonCommand(action, addonName, options) {
   const targetDir = resolve13(options.path || ".");
   p14.intro(introTitle(`Addon ${action}`));
+  const validAddons = Object.keys(ADDONS);
+  if (!validAddons.includes(addonName)) {
+    p14.cancel(`Unknown addon: ${addonName}
+
+Valid addons: ${validAddons.join(", ")}`);
+    process.exit(1);
+  }
+  const typedName = addonName;
+  const canonicalAction = action === "enable" ? "add" : action === "disable" ? "remove" : action;
+  if (action === "add" || action === "remove") {
+    const canonical = action === "add" ? "enable" : "disable";
+    p14.log.warn(
+      `"addon ${action}" is deprecated. Use "addon ${canonical}" instead.`
+    );
+  }
+  if (isFileBasedAddon(typedName)) {
+    if (canonicalAction === "add") {
+      await addFileBasedAddon(targetDir, typedName, options);
+    } else {
+      await removeFileBasedAddon(targetDir, typedName, options);
+    }
+    return;
+  }
   const manifest = readManifest(targetDir);
   if (!manifest) {
     p14.log.warn("No devtronic installation found.");
@@ -3822,16 +4451,9 @@ async function addonCommand(action, addonName, options) {
     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 addon = ADDONS[typedName];
   const currentAddons = manifest.projectConfig?.enabledAddons ?? [];
-  if (action === "add") {
+  if (canonicalAction === "add") {
     await addAddon(targetDir, manifest, addon.name, currentAddons);
   } else {
     await removeAddon(targetDir, manifest, addon.name, currentAddons);
@@ -3845,7 +4467,7 @@ async function addAddon(targetDir, manifest, addonName, currentAddons) {
   }
   const addon = ADDONS[addonName];
   const pluginRoot = manifest.pluginPath;
-  const skillsSourceDir = join17(TEMPLATES_DIR, "claude-code", ".claude", "skills");
+  const skillsSourceDir = join20(TEMPLATES_DIR, "claude-code", ".claude", "skills");
   p14.note(
     [
       `  ${chalk15.dim("Name:")}        ${addon.label}`,
@@ -3864,18 +4486,18 @@ async function addAddon(targetDir, manifest, addonName, currentAddons) {
   spinner8.start(`Adding ${addon.label}...`);
   const addedFiles = [];
   for (const skillDir of addon.skills) {
-    const sourceDir = join17(skillsSourceDir, skillDir);
-    if (!existsSync14(sourceDir)) {
+    const sourceDir = join20(skillsSourceDir, skillDir);
+    if (!existsSync16(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));
+      const content = readFile(join20(sourceDir, file));
+      const destRelPath = join20(pluginRoot, "skills", skillDir, file);
+      const destAbsPath = join20(targetDir, destRelPath);
+      ensureDir(dirname9(destAbsPath));
       writeFile(destAbsPath, content);
       manifest.files[destRelPath] = createManifestEntry(content);
       addedFiles.push(destRelPath);
@@ -3920,11 +4542,11 @@ async function removeAddon(targetDir, manifest, addonName, currentAddons) {
   }
   const modifiedFiles = [];
   for (const skillDir of addon.skills) {
-    const skillRelBase = join17(pluginRoot, "skills", skillDir);
+    const skillRelBase = join20(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 absPath = join20(targetDir, filePath);
+      if (!existsSync16(absPath)) continue;
       const current = calculateChecksum(readFile(absPath));
       if (current !== fileInfo.originalChecksum) {
         modifiedFiles.push(filePath);
@@ -3947,18 +4569,18 @@ async function removeAddon(targetDir, manifest, addonName, currentAddons) {
   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);
+    const skillRelBase = join20(pluginRoot, "skills", skillDir);
+    const skillAbsDir = join20(targetDir, skillRelBase);
     for (const filePath of Object.keys(manifest.files)) {
       if (filePath.startsWith(skillRelBase)) {
-        const absPath = join17(targetDir, filePath);
-        if (existsSync14(absPath)) unlinkSync2(absPath);
+        const absPath = join20(targetDir, filePath);
+        if (existsSync16(absPath)) unlinkSync3(absPath);
         delete manifest.files[filePath];
       }
     }
-    if (existsSync14(skillAbsDir)) {
+    if (existsSync16(skillAbsDir)) {
       try {
-        rmSync2(skillAbsDir, { recursive: true });
+        rmSync3(skillAbsDir, { recursive: true });
       } catch {
       }
     }
@@ -3975,32 +4597,196 @@ async function removeAddon(targetDir, manifest, addonName, currentAddons) {
   );
   p14.outro("Done. Restart Claude Code to apply the changes.");
 }
+async function addFileBasedAddon(targetDir, addonName, _options) {
+  const addon = ADDONS[addonName];
+  const config = readAddonConfig(targetDir);
+  if (config.installed[addonName]) {
+    p14.log.warn(`Addon "${addonName}" is already installed.`);
+    p14.outro("");
+    return;
+  }
+  p14.note(
+    [
+      `  ${chalk15.dim("Name:")}        ${addon.label}`,
+      `  ${chalk15.dim("Description:")} ${addon.description}`,
+      `  ${chalk15.dim("Skills:")}      ${addon.skills.map((s) => chalk15.cyan(`/${s}`)).join(", ")}`,
+      addon.agents.length ? `  ${chalk15.dim("Agents:")}      ${addon.agents.map((a) => chalk15.cyan(a)).join(", ")}` : `  ${chalk15.dim("Agents:")}      ${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 addonSourceDir = getAddonSourceDir(addonName);
+  const result = generateAddonFiles(targetDir, addonSourceDir, config.agents);
+  const addonManifest = JSON.parse(
+    readFileSync6(join20(addonSourceDir, "manifest.json"), "utf-8")
+  );
+  const fileList = [
+    ...(addonManifest.files.skills ?? []).map((s) => `skills/${s}`),
+    ...(addonManifest.files.agents ?? []).map((a) => `agents/${a}.md`),
+    ...(addonManifest.files.rules ?? []).map((r) => `rules/${r}`)
+  ];
+  writeAddonToConfig(targetDir, addonName, {
+    version: addonManifest.version,
+    files: fileList,
+    checksums: result.checksums ?? {}
+  });
+  spinner8.stop(`${symbols.pass} ${addon.label} added (${result.written} files written)`);
+  p14.note(
+    addon.skills.map((s) => `  ${chalk15.cyan(`/${s}`)}`).join("\n"),
+    "New skills available"
+  );
+  p14.outro("Done. Skills are now available in your agent directories.");
+}
+async function removeFileBasedAddon(targetDir, addonName, _options) {
+  const addon = ADDONS[addonName];
+  const config = readAddonConfig(targetDir);
+  if (!config.installed[addonName]) {
+    p14.log.warn(`Addon "${addonName}" is not currently installed.`);
+    p14.outro("");
+    return;
+  }
+  const modified = detectModifiedAddonFiles(targetDir, addonName);
+  if (modified.length > 0) {
+    p14.log.warn("The following files have been customized:");
+    for (const f of modified) {
+      p14.log.message(`  ${chalk15.yellow(f)}`);
+    }
+    const confirm9 = await p14.confirm({
+      message: "Remove them anyway? (customizations 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}...`);
+  removeAddonFiles(targetDir, addonName, config.agents);
+  removeAddonFromConfig(targetDir, addonName);
+  spinner8.stop(`${symbols.pass} ${addon.label} removed`);
+  p14.note(
+    addon.skills.map((s) => `  ${chalk15.dim(`/${s}`)}`).join("\n"),
+    "Skills removed"
+  );
+  p14.outro("Done.");
+}
+function getAddonListInfo(targetDir) {
+  const config = readAddonConfig(targetDir);
+  return getAvailableAddons().map((addon) => ({
+    name: addon.name,
+    label: addon.label,
+    description: addon.description,
+    installed: !!config.installed[addon.name],
+    agents: config.installed[addon.name] ? config.agents : void 0
+  }));
+}
+async function addonListCommand(options) {
+  const targetDir = resolve13(options.path || ".");
+  p14.intro(introTitle("Addon List"));
+  const items = getAddonListInfo(targetDir);
+  const lines = items.map((item) => {
+    const status = item.installed ? chalk15.green("\u2713 installed") : chalk15.dim("available");
+    const agents = item.agents ? chalk15.dim(` \u2192 ${item.agents.join(", ")}`) : "";
+    return `  ${chalk15.bold(item.name)} ${status}${agents}
+    ${chalk15.dim(item.description)}`;
+  });
+  p14.note(lines.join("\n\n"), "Addons");
+  p14.outro(`Use ${chalk15.cyan("devtronic addon add <name>")} to install.`);
+}
+async function addonSyncCommand(options) {
+  const targetDir = resolve13(options.path || ".");
+  p14.intro(introTitle("Addon Sync"));
+  const config = readAddonConfig(targetDir);
+  const installedNames = Object.keys(config.installed);
+  if (installedNames.length === 0) {
+    p14.log.info("No addons installed. Nothing to sync.");
+    p14.outro("");
+    return;
+  }
+  const spinner8 = p14.spinner();
+  spinner8.start("Syncing addon files...");
+  let totalWritten = 0;
+  let totalConflicts = [];
+  for (const name of installedNames) {
+    const addonSourceDir = getAddonSourceDir(name);
+    const result = syncAddonFiles(targetDir, addonSourceDir, config.agents);
+    totalWritten += result.written + (result.updated ?? 0);
+    totalConflicts = totalConflicts.concat(result.conflicts);
+  }
+  spinner8.stop(`${symbols.pass} Sync complete (${totalWritten} files updated)`);
+  if (totalConflicts.length > 0) {
+    p14.log.warn("Customized files were preserved:");
+    for (const f of totalConflicts) {
+      p14.log.message(`  ${chalk15.yellow(f)}`);
+    }
+  }
+  p14.outro("Done.");
+}
 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);
+  const pluginJsonRelPath = join20(pluginRoot, ".claude-plugin", "plugin.json");
+  writeFile(join20(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);
+  const marketplaceRelPath = join20(PLUGIN_DIR, ".claude-plugin", "marketplace.json");
+  writeFile(join20(targetDir, marketplaceRelPath), marketplaceContent);
   manifest.files[marketplaceRelPath] = createManifestEntry(marketplaceContent);
 }
 
+// src/commands/mode.ts
+import { resolve as resolve14, join as join21 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import * as p15 from "@clack/prompts";
+import chalk16 from "chalk";
+async function modeCommand(action, options) {
+  const targetDir = resolve14(options.path || ".");
+  p15.intro(introTitle("Mode"));
+  if (action === "show") {
+    const configPath = join21(targetDir, ".claude", "devtronic.json");
+    const hasConfig = existsSync17(configPath);
+    const config = readAddonConfig(targetDir);
+    const currentMode = config.mode;
+    const isDefault = !hasConfig || currentMode === void 0;
+    const displayMode = currentMode ?? "hitl";
+    p15.log.info(
+      `Mode: ${chalk16.cyan(displayMode)}${isDefault ? chalk16.dim(" (default)") : ""}`
+    );
+    p15.log.info(`Config: ${chalk16.dim(".claude/devtronic.json")}`);
+    p15.outro("");
+    return;
+  }
+  const newMode = action;
+  writeMode(targetDir, newMode);
+  const description = newMode === "afk" ? "Fully autonomous \u2014 no human gates" : "Human-in-the-loop \u2014 pauses for approval at key stages";
+  p15.log.success(`Mode set to ${chalk16.cyan(newMode)}`);
+  p15.log.info(chalk16.dim(description));
+  p15.outro(
+    `Change back anytime with ${chalk16.cyan(`npx devtronic mode ${newMode === "afk" ? "hitl" : "afk"}`)}`
+  );
+}
+
 // 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(chalk17.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(`  ${chalk17.dim("$")} ${chalk17.white("devtronic init")} ${chalk17.dim("[path]")}              ${chalk17.dim("Initialize in a project")}`);
+  console.log(`  ${chalk17.dim("$")} ${chalk17.white("devtronic info")}                      ${chalk17.dim("Version & config summary")}`);
+  console.log(`  ${chalk17.dim("$")} ${chalk17.white("devtronic doctor")}                    ${chalk17.dim("Health diagnostics")}`);
+  console.log(`  ${chalk17.dim("$")} ${chalk17.white("devtronic status")}                    ${chalk17.dim("File status overview")}`);
+  console.log(`  ${chalk17.dim("$")} ${chalk17.white("devtronic mode")} ${chalk17.dim("<afk|hitl|show>")}       ${chalk17.dim("Get or set execution mode")}`);
   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(`  ${chalk17.dim("$")} ${chalk17.white("devtronic help")}                      ${chalk17.dim("Show all commands")}`);
+  console.log(`  ${chalk17.dim("$")} ${chalk17.white("devtronic help --all")}                ${chalk17.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(
@@ -4059,13 +4845,20 @@ program.command("doctor").description("Run health checks on your devtronic insta
 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("mode").description("Set or show the execution mode (hitl or afk)").argument("<mode>", "Mode: afk, hitl, or show").option("--path <path>", "Target directory (default: current directory)").action(async (mode, options) => {
+  if (!["afk", "hitl", "show"].includes(mode)) {
+    console.error(`Invalid mode: "${mode}". Valid values: afk, hitl, show`);
+    process.exit(1);
+  }
+  await modeCommand(mode, { 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}
+  console.log(chalk17.dim(`  Agentic development toolkit v${cliVersion}
 `));
   const sections = [
     {
@@ -4089,7 +4882,7 @@ program.command("help").description("Show help (use --all for full reference)").
     {
       title: "Addons",
       usage: "addon add <name>",
-      desc: "Add an optional skill pack (e.g., orchestration)",
+      desc: "Add an optional skill pack (e.g., orchestration, design-best-practices)",
       opts: ["--path <path>        Target directory"]
     },
     {
@@ -4098,6 +4891,30 @@ program.command("help").description("Show help (use --all for full reference)").
       desc: "Remove an addon skill pack",
       opts: ["--path <path>        Target directory"]
     },
+    {
+      title: "",
+      usage: "addon list",
+      desc: "List available and installed addons",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "addon sync",
+      desc: "Regenerate addon files for current agent configuration",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "addon enable <name>",
+      desc: "Enable an addon (copies files to .claude/)",
+      opts: ["--path <path>        Target directory"]
+    },
+    {
+      title: "",
+      usage: "addon disable <name>",
+      desc: "Disable an addon (removes files from .claude/)",
+      opts: ["--path <path>        Target directory"]
+    },
     {
       title: "Maintenance",
       usage: "update",
@@ -4151,6 +4968,12 @@ program.command("help").description("Show help (use --all for full reference)").
       usage: "presets",
       desc: "List available configuration presets"
     },
+    {
+      title: "Mode",
+      usage: "mode <afk|hitl|show>",
+      desc: "Set or show the persistent execution mode for /auto-devtronic",
+      opts: ["--path <path>        Target directory"]
+    },
     {
       title: "Diagnostics",
       usage: "status",
@@ -4186,14 +5009,14 @@ program.command("help").description("Show help (use --all for full reference)").
   ];
   for (const section of sections) {
     if (section.title) {
-      console.log(`  ${chalk16.bold.underline(section.title)}
+      console.log(`  ${chalk17.bold.underline(section.title)}
 `);
     }
-    console.log(`  ${chalk16.white("devtronic " + section.usage)}`);
-    console.log(`  ${chalk16.dim(section.desc)}`);
+    console.log(`  ${chalk17.white("devtronic " + section.usage)}`);
+    console.log(`  ${chalk17.dim(section.desc)}`);
     if (section.opts) {
       for (const opt of section.opts) {
-        console.log(`    ${chalk16.yellow(opt)}`);
+        console.log(`    ${chalk17.yellow(opt)}`);
       }
     }
     console.log();
@@ -4206,21 +5029,33 @@ addonCmd.command("add").description("Add an addon to the devtronic plugin").argu
 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 });
 });
+addonCmd.command("list").description("List available and installed addons").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await addonListCommand({ path: options.path });
+});
+addonCmd.command("enable").description("Enable an addon (copies files to .claude/)").argument("<name>", "Addon name (e.g., auto-devtronic)").option("--path <path>", "Target directory (default: current directory)").action(async (name, options) => {
+  await addonCommand("enable", name, { path: options.path });
+});
+addonCmd.command("disable").description("Disable an addon (removes files from .claude/)").argument("<name>", "Addon name (e.g., auto-devtronic)").option("--path <path>", "Target directory (default: current directory)").action(async (name, options) => {
+  await addonCommand("disable", name, { path: options.path });
+});
+addonCmd.command("sync").description("Regenerate addon files for current agent configuration").option("--path <path>", "Target directory (default: current directory)").action(async (options) => {
+  await addonSyncCommand({ path: options.path });
+});
 program.command("presets").description("List available configuration presets").action(() => {
-  p15.intro(introTitle("Presets"));
+  p16.intro(introTitle("Presets"));
   const lines = Object.entries(PRESETS).map(([name, preset]) => {
-    const parts = [`  ${chalk16.bold(name)}`];
+    const parts = [`  ${chalk17.bold(name)}`];
     parts.push(`    ${preset.description}`);
     if (preset.config.architecture) {
-      parts.push(`    Architecture: ${chalk16.cyan(preset.config.architecture)}`);
+      parts.push(`    Architecture: ${chalk17.cyan(preset.config.architecture)}`);
     }
     if (preset.config.layers) {
-      parts.push(`    Layers: ${chalk16.cyan(preset.config.layers.join(", "))}`);
+      parts.push(`    Layers: ${chalk17.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>")}`);
+  p16.note(lines.join("\n\n"), "Available Presets");
+  p16.outro(`Usage: ${chalk17.cyan("npx devtronic init --preset <name>")}`);
 });
 program.parseAsync().catch((err) => {
   console.error(`