everything-gemini 1.2.0 → 1.9.0

package/bin/everything-gemini

@@ -45,20 +45,35 @@ function printHelp() {
   console.log(`  ${GREEN}doctor${RESET}                      Inspect system, AGY surfaces, and configuration health`);
   console.log(`  ${GREEN}install${RESET} [options]           Install everything-gemini profiles into workspace or globally`);
   console.log(`  ${GREEN}init${RESET} [options]              Initialize everything-gemini in current workspace`);
+  console.log(`  ${GREEN}status, check${RESET}               Show active skills, subagents, and hooks in workspace`);
+  console.log(`  ${GREEN}diff${RESET}                        Compare installed workspace components against master catalog`);
+  console.log(`  ${GREEN}export${RESET} [options]             Export installed configuration into a portable bundle`);
+  console.log(`  ${GREEN}import${RESET} <file.json>          Import portable agent configuration bundle into workspace`);
+  console.log(`  ${GREEN}bundle, pack${RESET} [options]        Package offline distribution bundle with manifest & installer`);
+  console.log(`  ${GREEN}sync${RESET} [options]                Synchronize workspace with upstream catalog & verify integrity`);
+  console.log(`  ${GREEN}update${RESET}                      Sync installed skills, agents, and hooks with latest catalog`);
   console.log(`  ${GREEN}list${RESET}                        Show all available skills, rules, hooks, and plugins`);
+  console.log(`  ${GREEN}scaffold, new${RESET} <type> <name>   Scaffold progressive skill, scoped subagent, or hook`);
   console.log(`  ${GREEN}new-skill${RESET} <name>            Scaffold a new progressive-disclosure skill`);
   console.log(`  ${GREEN}new-agent${RESET} <name>            Scaffold a new scoped subagent specification`);
-  console.log(`  ${GREEN}add${RESET} <type> <name>           Add a specific skill, agent, or plugin to workspace`);
-  console.log(`  ${GREEN}remove${RESET} <type> <name>        Remove a specific skill, agent, or plugin from workspace`);
+  console.log(`  ${GREEN}add${RESET} <type> <name>           Add a specific skill, agent, hook, or plugin to workspace`);
+  console.log(`  ${GREEN}remove${RESET} <type> <name>        Remove a specific skill, agent, hook, or plugin from workspace`);
+  console.log(`  ${GREEN}search, find${RESET} <query>         Search skills, agents, hooks, and MCP blueprints`);
+  console.log(`  ${GREEN}audit${RESET} [path]                 Comprehensive audit of frontmatter, contracts, hooks & links`);
   console.log(`  ${GREEN}test-skill${RESET} <name>           Validate a specific skill frontmatter & scripts`);
-  console.log(`  ${GREEN}info${RESET} <skill-name>            Display detailed instructions and trigger for a skill`);
+  console.log(`  ${GREEN}test-all${RESET}                    Benchmark & validate all 56 skills, 12 subagents & 7 hooks`);
+  console.log(`  ${GREEN}info${RESET} <name>                  Display overview & runbook for a skill, agent, or hook`);
+  console.log(`  ${GREEN}completion${RESET} [--install]        Generate or install shell autocompletion script (bash/zsh)`);
   console.log(`  ${GREEN}validate${RESET}                    Run self-test on frontmatter, JSON schemas & hooks`);
-  console.log(`  ${GREEN}help${RESET}                        Show this help message\n`);
-  console.log(`${BOLD}OPTIONS for 'install':${RESET}`);
+  console.log(`  ${GREEN}version, -v, --version${RESET}      Print everything-gemini version`);
+  console.log(`  ${GREEN}help, -h, --help${RESET}            Show this help message\n`);
+  console.log(`${BOLD}GLOBAL & COMMAND OPTIONS:${RESET}`);
   console.log(`  ${CYAN}--profile <core|developer|full>${RESET}   Installation preset profile (default: developer)`);
-  console.log(`  ${CYAN}--global${RESET}                          Install globally into ~/.gemini/config/`);
-  console.log(`  ${CYAN}--workspace <path>${RESET}                Install into custom workspace directory`);
-  console.log(`  ${CYAN}--force${RESET}                          Overwrite existing configuration files\n`);
+  console.log(`  ${CYAN}--global${RESET}                          Target global config (~/.gemini/config/)`);
+  console.log(`  ${CYAN}--workspace <path>${RESET}                Target custom workspace directory`);
+  console.log(`  ${CYAN}--dry-run${RESET}                         Preview actions without modifying files on disk`);
+  console.log(`  ${CYAN}--json${RESET}                            Output machine-readable JSON (status, benchmark)`);
+  console.log(`  ${CYAN}--force${RESET}                           Overwrite existing configuration files\n`);
 }
 
 function runDoctor() {
@@ -190,13 +205,29 @@ function listComponents() {
         if (item.isDirectory()) {
           findRules(path.join(dir, item.name), `${prefix}${item.name}/`);
         } else if (item.name.endsWith('.md')) {
-          console.log(`  ${BOLD}${(prefix + item.name).padEnd(32)}${RESET}`);
+          console.log(`  ${BOLD}${(prefix + item.name).padEnd(36)}${RESET}`);
         }
       }
     }
     findRules(rulesDir);
   }
 
+  // Plugin Packaged Rules
+  if (fs.existsSync(pluginsDirForSkills)) {
+    const plugins = fs.readdirSync(pluginsDirForSkills, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const plugin of plugins) {
+      const pRulesDir = path.join(pluginsDirForSkills, plugin, 'rules');
+      if (fs.existsSync(pRulesDir)) {
+        const pRules = fs.readdirSync(pRulesDir).filter(f => f.endsWith('.md'));
+        for (const r of pRules) {
+          console.log(`  ${BOLD}${(`plugins/${plugin}/rules/${r}`).padEnd(36)}${RESET}`);
+        }
+      }
+    }
+  }
+
   // Hooks
   console.log(`\n${CYAN}${BOLD}🛡️ Lifecycle Hooks:${RESET}`);
   const hooksDir = path.join(REPO_ROOT, 'hooks');
@@ -243,19 +274,26 @@ function copyRecursiveSync(src, dest) {
   } else {
     fs.mkdirSync(path.dirname(dest), { recursive: true });
     fs.copyFileSync(src, dest);
+    if (src.endsWith('.sh') || (stats.mode && (stats.mode & 0o111))) {
+      try { fs.chmodSync(dest, 0o755); } catch (e) {}
+    }
   }
 }
 
-function installProfile(profile = 'developer', isGlobal = false, customTarget = null) {
+function installProfile(profile = 'developer', isGlobal = false, customTarget = null, isDryRun = false) {
   printBanner();
   const targetDir = customTarget 
     ? path.resolve(customTarget)
     : (isGlobal ? GLOBAL_CONFIG_DIR : AGENTS_DIR);
 
+  if (isDryRun) {
+    console.log(`${YELLOW}${BOLD}🔍 DRY RUN MODE ACTIVATED - No files will be modified on disk.${RESET}`);
+  }
+
   console.log(`${BOLD}🚀 Installing everything-gemini Profile: [${GREEN}${profile}${RESET}${BOLD}]${RESET}`);
   console.log(`Target Directory: ${CYAN}${targetDir}${RESET}\n`);
 
-  if (!fs.existsSync(targetDir)) {
+  if (!isDryRun && !fs.existsSync(targetDir)) {
     fs.mkdirSync(targetDir, { recursive: true });
   }
 
@@ -263,69 +301,103 @@ function installProfile(profile = 'developer', isGlobal = false, customTarget =
   const targetSkills = path.join(targetDir, 'skills');
   const targetRules = path.join(targetDir, 'rules');
   const targetPlugins = path.join(targetDir, 'plugins');
-  fs.mkdirSync(targetSkills, { recursive: true });
-  fs.mkdirSync(targetRules, { recursive: true });
-  fs.mkdirSync(targetPlugins, { recursive: true });
+  const targetAgents = path.join(targetDir, 'agents');
+  if (!isDryRun) {
+    fs.mkdirSync(targetSkills, { recursive: true });
+    fs.mkdirSync(targetRules, { recursive: true });
+    fs.mkdirSync(targetPlugins, { recursive: true });
+  }
 
   const skillsSrc = path.join(REPO_ROOT, 'skills');
   const rulesSrc = path.join(REPO_ROOT, 'rules');
   const hooksSrc = path.join(REPO_ROOT, 'hooks');
   const pluginsSrc = path.join(REPO_ROOT, 'plugins');
+  const agentsSrc = path.join(REPO_ROOT, 'agents');
 
   // Copy Common Base Rules
   const commonGemini = path.join(rulesSrc, 'common', 'GEMINI.md');
   const commonAgents = path.join(rulesSrc, 'common', 'AGENTS.md');
   if (fs.existsSync(commonGemini)) {
-    fs.copyFileSync(commonGemini, path.join(targetDir, 'GEMINI.md'));
-    console.log(`  ${GREEN}✔${RESET} Installed base GEMINI.md`);
+    if (!isDryRun) fs.copyFileSync(commonGemini, path.join(targetDir, 'GEMINI.md'));
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} base GEMINI.md`);
   }
   if (fs.existsSync(commonAgents)) {
-    fs.copyFileSync(commonAgents, path.join(targetDir, 'AGENTS.md'));
-    console.log(`  ${GREEN}✔${RESET} Installed base AGENTS.md`);
+    if (!isDryRun) fs.copyFileSync(commonAgents, path.join(targetDir, 'AGENTS.md'));
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} base AGENTS.md`);
   }
 
-  // Determine what to copy based on profile
+  // 1. Core Profile
   if (profile === 'core' || profile === 'developer' || profile === 'full') {
-    // Core Skills
     const coreSkills = ['tdd-workflow', 'repo-onboarding'];
     for (const s of coreSkills) {
       const src = path.join(skillsSrc, s);
       if (fs.existsSync(src)) {
-        copyRecursiveSync(src, path.join(targetSkills, s));
-        console.log(`  ${GREEN}✔${RESET} Installed skill: ${s}`);
+        if (!isDryRun) copyRecursiveSync(src, path.join(targetSkills, s));
+        console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} skill: ${s}`);
       }
     }
-    // Core Hook (Safety Shield)
-    const safetyHookJson = path.join(hooksSrc, 'safety-shield', 'hooks.json');
-    if (fs.existsSync(safetyHookJson)) {
-      copyRecursiveSync(path.join(hooksSrc, 'safety-shield'), path.join(targetDir, 'hooks', 'safety-shield'));
-      console.log(`  ${GREEN}✔${RESET} Installed safety-shield hook`);
+    const safetyHook = path.join(hooksSrc, 'safety-shield');
+    if (fs.existsSync(safetyHook)) {
+      if (!isDryRun) copyRecursiveSync(safetyHook, path.join(targetDir, 'hooks', 'safety-shield'));
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} safety-shield hook`);
     }
   }
 
+  // 2. Developer Profile
   if (profile === 'developer' || profile === 'full') {
-    // Developer Skills
-    const devSkills = ['browser-qa-tester', 'architecture-designer', 'git-craftsman', 'performance-profiler', 'fullstack-nextjs'];
+    const devSkills = [
+      'browser-qa-tester',
+      'architecture-designer',
+      'git-craftsman',
+      'performance-profiler',
+      'fullstack-nextjs',
+      'gemini-multimodal',
+      'context-caching',
+      'subagent-handoff',
+      'security-audit',
+      'continuous-learning',
+      'ai-first-engineering'
+    ];
     for (const s of devSkills) {
       const src = path.join(skillsSrc, s);
       if (fs.existsSync(src)) {
-        copyRecursiveSync(src, path.join(targetSkills, s));
-        console.log(`  ${GREEN}✔${RESET} Installed skill: ${s}`);
+        if (!isDryRun) copyRecursiveSync(src, path.join(targetSkills, s));
+        console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} skill: ${s}`);
       }
     }
 
     // Developer Language Rules
     const langRules = path.join(rulesSrc, 'languages');
     if (fs.existsSync(langRules)) {
-      copyRecursiveSync(langRules, targetRules);
-      console.log(`  ${GREEN}✔${RESET} Installed language rules (TypeScript, Python, Go)`);
+      if (!isDryRun) copyRecursiveSync(langRules, targetRules);
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} language rules (TypeScript, Python, Go)`);
     }
 
     // Auto-lint formatter hook
     const lintHook = path.join(hooksSrc, 'auto-lint-formatter');
     if (fs.existsSync(lintHook)) {
-      copyRecursiveSync(lintHook, path.join(targetDir, 'hooks', 'auto-lint-formatter'));
-      console.log(`  ${GREEN}✔${RESET} Installed auto-lint-formatter hook`);
+      if (!isDryRun) copyRecursiveSync(lintHook, path.join(targetDir, 'hooks', 'auto-lint-formatter'));
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} auto-lint-formatter hook`);
+    }
+
+    // Goal-verifier hook
+    const goalHook = path.join(hooksSrc, 'goal-verifier');
+    if (fs.existsSync(goalHook)) {
+      if (!isDryRun) copyRecursiveSync(goalHook, path.join(targetDir, 'hooks', 'goal-verifier'));
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} goal-verifier hook`);
+    }
+
+    // Secret-scrubber hook
+    const scrubberHook = path.join(hooksSrc, 'secret-scrubber');
+    if (fs.existsSync(scrubberHook)) {
+      if (!isDryRun) copyRecursiveSync(scrubberHook, path.join(targetDir, 'hooks', 'secret-scrubber'));
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} secret-scrubber hook`);
+    }
+
+    // Scoped Subagents (agents/)
+    if (fs.existsSync(agentsSrc)) {
+      if (!isDryRun) copyRecursiveSync(agentsSrc, targetAgents);
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} 9 scoped subagents (agents/)`);
     }
 
     // Developer Plugins
@@ -333,58 +405,652 @@ function installProfile(profile = 'developer', isGlobal = false, customTarget =
     for (const p of devPlugins) {
       const src = path.join(pluginsSrc, p);
       if (fs.existsSync(src)) {
-        copyRecursiveSync(src, path.join(targetPlugins, p));
-        console.log(`  ${GREEN}✔${RESET} Installed plugin: ${p}`);
+        if (!isDryRun) copyRecursiveSync(src, path.join(targetPlugins, p));
+        console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} plugin: ${p}`);
       }
     }
   }
 
+  // 3. Full Power Profile
   if (profile === 'full') {
-    // All Skills
-    copyRecursiveSync(skillsSrc, targetSkills);
-    console.log(`  ${GREEN}✔${RESET} Installed entire skills library`);
+    if (!isDryRun) copyRecursiveSync(skillsSrc, targetSkills);
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} entire skills library (48 progressive skills)`);
+
+    if (!isDryRun) copyRecursiveSync(rulesSrc, targetRules);
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} entire rules library`);
 
-    // All Rules
-    copyRecursiveSync(rulesSrc, targetRules);
-    console.log(`  ${GREEN}✔${RESET} Installed entire rules library`);
+    if (!isDryRun) copyRecursiveSync(pluginsSrc, targetPlugins);
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} all modular plugins`);
 
-    // All Plugins
-    copyRecursiveSync(pluginsSrc, targetPlugins);
-    console.log(`  ${GREEN}✔${RESET} Installed all modular plugins`);
+    if (!isDryRun) copyRecursiveSync(hooksSrc, path.join(targetDir, 'hooks'));
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} full lifecycle hooks suite (7 hooks)`);
 
-    // All Hooks
-    copyRecursiveSync(hooksSrc, path.join(targetDir, 'hooks'));
-    console.log(`  ${GREEN}✔${RESET} Installed full lifecycle hooks suite`);
+    if (fs.existsSync(agentsSrc)) {
+      if (!isDryRun) copyRecursiveSync(agentsSrc, targetAgents);
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} 10 scoped subagents (agents/)`);
+    }
 
     // MCP Config Example
     const mcpExample = path.join(REPO_ROOT, 'mcp', 'mcp_config.example.json');
     if (fs.existsSync(mcpExample)) {
-      fs.copyFileSync(mcpExample, path.join(targetDir, 'mcp_config.json'));
-      console.log(`  ${GREEN}✔${RESET} Installed mcp_config.json`);
-    }
-  }
-
-  // Create or Merge Master hooks.json in targetDir
-  const masterHooks = {
-    "safety-shield": {
-      "PreToolUse": [
-        {
-          "matcher": "run_command",
-          "hooks": [
-            {
-              "type": "command",
-              "command": "bash ./hooks/safety-shield/scripts/safety-gate.sh",
-              "timeout": 15
-            }
-          ]
+      if (!isDryRun) fs.copyFileSync(mcpExample, path.join(targetDir, 'mcp_config.json'));
+      console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would install' : 'Installed'} mcp_config.json`);
+    }
+  }
+
+  // Template-driven master hooks.json generation
+  let templateHooksPath = null;
+  if (profile === 'minimal' || profile === 'core') {
+    templateHooksPath = path.join(REPO_ROOT, 'templates', 'minimal', 'hooks.json');
+  } else if (profile === 'full') {
+    templateHooksPath = path.join(REPO_ROOT, 'templates', 'full-power', 'hooks.json');
+  } else {
+    templateHooksPath = path.join(REPO_ROOT, 'templates', 'recommended', 'hooks.json');
+  }
+
+  if (fs.existsSync(templateHooksPath)) {
+    if (!isDryRun) fs.copyFileSync(templateHooksPath, path.join(targetDir, 'hooks.json'));
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would generate' : 'Generated'} profile hooks.json (${profile})`);
+  }
+
+  if (isDryRun) {
+    console.log(`\n${GREEN}${BOLD}✨ Dry run preview complete! 0 files modified on disk.${RESET}\n`);
+  } else {
+    console.log(`\n${GREEN}${BOLD}✨ Installation complete! Everything Gemini is ready.${RESET}\n`);
+  }
+}
+
+function runStatus(isGlobal = false, customTarget = null, asJson = false) {
+  const targetDir = customTarget 
+    ? path.resolve(customTarget)
+    : (isGlobal ? GLOBAL_CONFIG_DIR : AGENTS_DIR);
+
+  const isInitialized = fs.existsSync(targetDir);
+  const geminiRule = path.join(targetDir, 'GEMINI.md');
+  const agentsRule = path.join(targetDir, 'AGENTS.md');
+  const hasGemini = fs.existsSync(geminiRule);
+  const hasAgents = fs.existsSync(agentsRule);
+
+  // 1. Installed Skills
+  const skillsDir = path.join(targetDir, 'skills');
+  let installedSkills = [];
+  if (fs.existsSync(skillsDir)) {
+    installedSkills = fs.readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+  }
+
+  // 2. Subagents
+  const agentsDir = path.join(targetDir, 'agents');
+  let installedAgents = [];
+  if (fs.existsSync(agentsDir)) {
+    installedAgents = fs.readdirSync(agentsDir)
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''))
+      .sort();
+  }
+
+  // 3. Hooks
+  const hooksFile = path.join(targetDir, 'hooks.json');
+  let hooksSummary = {};
+  if (fs.existsSync(hooksFile)) {
+    try {
+      hooksSummary = JSON.parse(fs.readFileSync(hooksFile, 'utf8'));
+    } catch (e) {}
+  }
+
+  if (asJson) {
+    const payload = {
+      version: VERSION,
+      targetDir,
+      isGlobal,
+      isInitialized,
+      rules: {
+        gemini: hasGemini,
+        agents: hasAgents
+      },
+      skills: {
+        installedCount: installedSkills.length,
+        totalCatalogCount: 52,
+        installed: installedSkills
+      },
+      subagents: {
+        installedCount: installedAgents.length,
+        totalCatalogCount: 11,
+        installed: installedAgents
+      },
+      hooks: {
+        activeCount: Object.keys(hooksSummary).length,
+        active: Object.keys(hooksSummary)
+      }
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  printBanner();
+  console.log(`${BOLD}📊 Everything Gemini Workspace Status${RESET}`);
+  console.log(`Directory: ${CYAN}${targetDir}${RESET}\n`);
+
+  if (!isInitialized) {
+    console.log(`  ${YELLOW}○ Workspace is not initialized.${RESET}`);
+    console.log(`    Run ${GREEN}everything-gemini install${RESET} to set up.\n`);
+    return;
+  }
+
+  console.log(`${CYAN}${BOLD}📜 Base Rules:${RESET}`);
+  console.log(`  ${hasGemini ? GREEN + '✔' : GRAY + '○'}${RESET} GEMINI.md ${hasGemini ? '(active)' : '(not installed)'}`);
+  console.log(`  ${hasAgents ? GREEN + '✔' : GRAY + '○'}${RESET} AGENTS.md ${hasAgents ? '(active)' : '(not installed)'}`);
+
+  console.log(`\n${CYAN}${BOLD}⚡ Installed Skills (${installedSkills.length}/52):${RESET}`);
+  if (installedSkills.length === 0) {
+    console.log(`  ${GRAY}(no skills installed)${RESET}`);
+  } else {
+    for (const s of installedSkills) {
+      console.log(`  ${GREEN}✔${RESET} ${s}`);
+    }
+  }
+
+  console.log(`\n${CYAN}${BOLD}🤖 Scoped Subagents (${installedAgents.length}/11):${RESET}`);
+  if (installedAgents.length === 0) {
+    console.log(`  ${GRAY}(no subagents installed)${RESET}`);
+  } else {
+    for (const a of installedAgents) {
+      console.log(`  ${GREEN}✔${RESET} ${a}`);
+    }
+  }
+
+  console.log(`\n${CYAN}${BOLD}🛡️ Lifecycle Hooks:${RESET}`);
+  const hookNames = Object.keys(hooksSummary);
+  if (hookNames.length > 0) {
+    console.log(`  ${GREEN}✔${RESET} hooks.json configured (${hookNames.length} hooks active):`);
+    for (const h of hookNames) {
+      const events = Object.keys(hooksSummary[h]).join(', ');
+      console.log(`    • ${BOLD}${h}${RESET} [${GRAY}${events}${RESET}]`);
+    }
+  } else {
+    console.log(`  ${GRAY}(no hooks.json found)${RESET}`);
+  }
+  console.log('');
+}
+
+function runUpdate(isGlobal = false, customTarget = null, isDryRun = false) {
+  printBanner();
+  const targetDir = customTarget 
+    ? path.resolve(customTarget)
+    : (isGlobal ? GLOBAL_CONFIG_DIR : AGENTS_DIR);
+
+  if (isDryRun) {
+    console.log(`${YELLOW}${BOLD}🔍 DRY RUN MODE ACTIVATED - No files will be modified on disk.${RESET}`);
+  }
+  console.log(`${BOLD}🔄 Updating Installed Components in: ${CYAN}${targetDir}${RESET}\n`);
+
+  if (!fs.existsSync(targetDir)) {
+    console.log(`  ${YELLOW}○ Workspace is not initialized.${RESET}`);
+    console.log(`    Run ${GREEN}everything-gemini install${RESET} first.\n`);
+    return;
+  }
+
+  let updatedSkills = 0;
+  let updatedAgents = 0;
+  let updatedHooks = 0;
+
+  // 1. Update Existing Installed Skills
+  const targetSkills = path.join(targetDir, 'skills');
+  if (fs.existsSync(targetSkills)) {
+    const installed = fs.readdirSync(targetSkills, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const s of installed) {
+      const src = path.join(REPO_ROOT, 'skills', s);
+      if (fs.existsSync(src)) {
+        if (!isDryRun) copyRecursiveSync(src, path.join(targetSkills, s));
+        updatedSkills++;
+        if (isDryRun) {
+          console.log(`  ${CYAN}[DRY RUN]${RESET} Would update skill: ${s}`);
+        }
+      }
+    }
+  }
+
+  // 2. Update Existing Installed Subagents
+  const targetAgents = path.join(targetDir, 'agents');
+  if (fs.existsSync(targetAgents)) {
+    const installed = fs.readdirSync(targetAgents)
+      .filter(f => f.endsWith('.md'));
+    for (const a of installed) {
+      const src = path.join(REPO_ROOT, 'agents', a);
+      if (fs.existsSync(src)) {
+        if (!isDryRun) fs.copyFileSync(src, path.join(targetAgents, a));
+        updatedAgents++;
+        if (isDryRun) {
+          console.log(`  ${CYAN}[DRY RUN]${RESET} Would update subagent: ${a}`);
+        }
+      }
+    }
+  }
+
+  // 3. Update Hooks Scripts
+  const targetHooks = path.join(targetDir, 'hooks');
+  if (fs.existsSync(targetHooks)) {
+    const installed = fs.readdirSync(targetHooks, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const h of installed) {
+      const src = path.join(REPO_ROOT, 'hooks', h);
+      if (fs.existsSync(src)) {
+        if (!isDryRun) copyRecursiveSync(src, path.join(targetHooks, h));
+        updatedHooks++;
+        if (isDryRun) {
+          console.log(`  ${CYAN}[DRY RUN]${RESET} Would refresh hook: ${h}`);
+        }
+      }
+    }
+  }
+
+  // 4. Refresh base rules if present
+  const rulesSrc = path.join(REPO_ROOT, 'rules', 'common');
+  if (fs.existsSync(path.join(targetDir, 'GEMINI.md')) && fs.existsSync(path.join(rulesSrc, 'GEMINI.md'))) {
+    if (!isDryRun) fs.copyFileSync(path.join(rulesSrc, 'GEMINI.md'), path.join(targetDir, 'GEMINI.md'));
+    if (isDryRun) console.log(`  ${CYAN}[DRY RUN]${RESET} Would refresh base GEMINI.md`);
+  }
+  if (fs.existsSync(path.join(targetDir, 'AGENTS.md')) && fs.existsSync(path.join(rulesSrc, 'AGENTS.md'))) {
+    if (!isDryRun) fs.copyFileSync(path.join(rulesSrc, 'AGENTS.md'), path.join(targetDir, 'AGENTS.md'));
+    if (isDryRun) console.log(`  ${CYAN}[DRY RUN]${RESET} Would refresh base AGENTS.md`);
+  }
+
+  if (isDryRun) {
+    console.log(`\n${GREEN}${BOLD}✨ Dry run preview complete! 0 files modified on disk.${RESET}\n`);
+  } else {
+    console.log(`  ${GREEN}✔${RESET} Synced ${BOLD}${updatedSkills}${RESET} installed skills to latest catalog versions`);
+    console.log(`  ${GREEN}✔${RESET} Synced ${BOLD}${updatedAgents}${RESET} subagent specifications`);
+    console.log(`  ${GREEN}✔${RESET} Refreshed ${BOLD}${updatedHooks}${RESET} lifecycle hook scripts & verified permissions`);
+    console.log(`  ${GREEN}✔${RESET} Refreshed base GEMINI.md & AGENTS.md rules\n`);
+    console.log(`${GREEN}${BOLD}✨ Update complete! Everything Gemini is up to date.${RESET}\n`);
+  }
+}
+
+function runDiff(isGlobal = false, customTarget = null) {
+  printBanner();
+  const targetDir = customTarget ? path.resolve(customTarget) : (isGlobal ? GLOBAL_CONFIG_DIR : AGENTS_DIR);
+  console.log(`${BOLD}🔍 Comparing Workspace vs. Master Everything Gemini Catalog...${RESET}`);
+  console.log(`Target: ${CYAN}${targetDir}${RESET}\n`);
+
+  if (!fs.existsSync(targetDir)) {
+    console.log(`${YELLOW}No active configuration found at ${targetDir}.${RESET}\n`);
+    return;
+  }
+
+  // Compare skills
+  const wsSkillsDir = path.join(targetDir, 'skills');
+  const catalogSkillsDir = path.join(REPO_ROOT, 'skills');
+  const wsSkills = fs.existsSync(wsSkillsDir) ? fs.readdirSync(wsSkillsDir).filter(s => {
+    try { return fs.statSync(path.join(wsSkillsDir, s)).isDirectory(); } catch (_) { return false; }
+  }) : [];
+
+  console.log(`${BOLD}⚡ Progressive Skills Comparison:${RESET}`);
+  let modifiedCount = 0;
+  for (const s of wsSkills) {
+    const wsFile = path.join(wsSkillsDir, s, 'SKILL.md');
+    const catFile = path.join(catalogSkillsDir, s, 'SKILL.md');
+    if (!fs.existsSync(catFile)) {
+      console.log(`  ${CYAN}+ [CUSTOM/LOCAL]${RESET} ${s}`);
+    } else {
+      const wsContent = fs.existsSync(wsFile) ? fs.readFileSync(wsFile, 'utf8') : '';
+      const catContent = fs.readFileSync(catFile, 'utf8');
+      if (wsContent !== catContent) {
+        console.log(`  ${YELLOW}* [MODIFIED]${RESET} ${s} (differs from catalog)`);
+        modifiedCount++;
+      } else {
+        console.log(`  ${GREEN}✔ [IN-SYNC]${RESET} ${s}`);
+      }
+    }
+  }
+
+  // Compare agents
+  const wsAgentsDir = path.join(targetDir, 'agents');
+  const catAgentsDir = path.join(REPO_ROOT, 'agents');
+  const wsAgents = fs.existsSync(wsAgentsDir) ? fs.readdirSync(wsAgentsDir).filter(a => a.endsWith('.md')) : [];
+  console.log(`\n${BOLD}🤖 Scoped Subagents Comparison:${RESET}`);
+  for (const a of wsAgents) {
+    const wsFile = path.join(wsAgentsDir, a);
+    const catFile = path.join(catAgentsDir, a);
+    if (!fs.existsSync(catFile)) {
+      console.log(`  ${CYAN}+ [CUSTOM/LOCAL]${RESET} ${a}`);
+    } else {
+      const wsContent = fs.readFileSync(wsFile, 'utf8');
+      const catContent = fs.readFileSync(catFile, 'utf8');
+      if (wsContent !== catContent) {
+        console.log(`  ${YELLOW}* [MODIFIED]${RESET} ${a} (differs from catalog)`);
+        modifiedCount++;
+      } else {
+        console.log(`  ${GREEN}✔ [IN-SYNC]${RESET} ${a}`);
+      }
+    }
+  }
+
+  console.log(`\n${BOLD}Diff Summary:${RESET} ${wsSkills.length} skills, ${wsAgents.length} subagents checked. ${modifiedCount === 0 ? GREEN + 'All matching components are in sync with master catalog!' + RESET : YELLOW + `${modifiedCount} modified component(s) detected.` + RESET}\n`);
+}
+
+function runExport(isGlobal = false, customTarget = null, outputPath = null) {
+  printBanner();
+  const targetDir = customTarget ? path.resolve(customTarget) : (isGlobal ? GLOBAL_CONFIG_DIR : AGENTS_DIR);
+  console.log(`${BOLD}📦 Exporting Agent Configuration Bundle...${RESET}`);
+  console.log(`Source: ${CYAN}${targetDir}${RESET}\n`);
+
+  if (!fs.existsSync(targetDir)) {
+    console.error(`${RED}Error: Source directory does not exist: ${targetDir}${RESET}\n`);
+    process.exit(1);
+  }
+
+  const exportData = {
+    generator: "everything-gemini",
+    version: VERSION,
+    exportedAt: new Date().toISOString(),
+    source: targetDir,
+    skills: [],
+    agents: [],
+    hooksConfig: null
+  };
+
+  const skillsDir = path.join(targetDir, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    for (const s of fs.readdirSync(skillsDir)) {
+      const skillPath = path.join(skillsDir, s, 'SKILL.md');
+      if (fs.existsSync(skillPath)) {
+        exportData.skills.push({ name: s, content: fs.readFileSync(skillPath, 'utf8') });
+      }
+    }
+  }
+
+  const agentsDir = path.join(targetDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    for (const a of fs.readdirSync(agentsDir)) {
+      if (a.endsWith('.md')) {
+        exportData.agents.push({ name: a, content: fs.readFileSync(path.join(agentsDir, a), 'utf8') });
+      }
+    }
+  }
+
+  const hooksFile = path.join(targetDir, 'hooks.json');
+  if (fs.existsSync(hooksFile)) {
+    try {
+      exportData.hooksConfig = JSON.parse(fs.readFileSync(hooksFile, 'utf8'));
+    } catch (_) {}
+  }
+
+  const outDest = outputPath ? path.resolve(outputPath) : path.join(process.cwd(), 'everything-gemini-profile.json');
+  fs.writeFileSync(outDest, JSON.stringify(exportData, null, 2), 'utf8');
+  console.log(`  ${GREEN}✔${RESET} Successfully exported ${exportData.skills.length} skills, ${exportData.agents.length} subagents to:`);
+  console.log(`    ${BOLD}${outDest}${RESET}\n`);
+}
+
+function runImport(inputFile, isGlobal = false, customTarget = null, isDryRun = false) {
+  printBanner();
+  if (!inputFile) {
+    console.error(`${RED}Error: Input file required. Usage: everything-gemini import <profile.json>${RESET}\n`);
+    process.exit(1);
+  }
+
+  const filePath = path.resolve(inputFile);
+  if (!fs.existsSync(filePath)) {
+    console.error(`${RED}Error: Import file does not exist: ${filePath}${RESET}\n`);
+    process.exit(1);
+  }
+
+  let bundle = null;
+  try {
+    bundle = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    console.error(`${RED}Error parsing JSON import bundle: ${err.message}${RESET}\n`);
+    process.exit(1);
+  }
+
+  const targetDir = customTarget ? path.resolve(customTarget) : (isGlobal ? GLOBAL_CONFIG_DIR : AGENTS_DIR);
+  console.log(`${BOLD}📥 Importing Agent Configuration Bundle...${RESET}`);
+  console.log(`Source File: ${CYAN}${filePath}${RESET}`);
+  console.log(`Target: ${CYAN}${targetDir}${RESET}\n`);
+
+  if (isDryRun) {
+    console.log(`${YELLOW}${BOLD}⚠️  DRY RUN MODE ACTIVATED. Previewing import:${RESET}\n`);
+  }
+
+  let importedSkills = 0;
+  let importedAgents = 0;
+
+  // 1. Import Skills
+  if (Array.isArray(bundle.skills)) {
+    const targetSkills = path.join(targetDir, 'skills');
+    for (const s of bundle.skills) {
+      if (s.name && s.content) {
+        if (!isDryRun) {
+          const sDir = path.join(targetSkills, s.name);
+          fs.mkdirSync(sDir, { recursive: true });
+          fs.writeFileSync(path.join(sDir, 'SKILL.md'), s.content, 'utf8');
         }
-      ]
+        importedSkills++;
+        if (isDryRun) {
+          console.log(`  ${CYAN}[DRY RUN]${RESET} Would import skill: ${s.name}`);
+        }
+      }
+    }
+  }
+
+  // 2. Import Subagents
+  if (Array.isArray(bundle.agents)) {
+    const targetAgents = path.join(targetDir, 'agents');
+    for (const a of bundle.agents) {
+      if (a.name && a.content) {
+        if (!isDryRun) {
+          fs.mkdirSync(targetAgents, { recursive: true });
+          fs.writeFileSync(path.join(targetAgents, a.name), a.content, 'utf8');
+        }
+        importedAgents++;
+        if (isDryRun) {
+          console.log(`  ${CYAN}[DRY RUN]${RESET} Would import subagent: ${a.name}`);
+        }
+      }
     }
+  }
+
+  // 3. Import Hooks Config
+  if (bundle.hooksConfig && typeof bundle.hooksConfig === 'object') {
+    if (!isDryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(path.join(targetDir, 'hooks.json'), JSON.stringify(bundle.hooksConfig, null, 2), 'utf8');
+    }
+    console.log(`  ${GREEN}✔${RESET} ${isDryRun ? '[DRY RUN] Would import' : 'Imported'} hooks.json configuration`);
+  }
+
+  if (isDryRun) {
+    console.log(`\n${GREEN}${BOLD}✨ Dry run complete! Would import ${importedSkills} skills and ${importedAgents} subagents.${RESET}\n`);
+  } else {
+    console.log(`  ${GREEN}✔${RESET} Successfully imported ${BOLD}${importedSkills}${RESET} progressive skills`);
+    console.log(`  ${GREEN}✔${RESET} Successfully imported ${BOLD}${importedAgents}${RESET} scoped subagents\n`);
+    console.log(`${GREEN}${BOLD}✨ Import complete! Configuration applied to ${targetDir}${RESET}\n`);
+  }
+}
+
+function runBundle(profile = 'all', outputDir = null, isDryRun = false, asJson = false) {
+  const destDir = outputDir ? path.resolve(outputDir) : path.join(process.cwd(), 'everything-gemini-bundle');
+  const startTime = Date.now();
+  const crypto = require('crypto');
+
+  const skillsToBundle = [];
+  const agentsToBundle = [];
+  const hooksToBundle = [];
+
+  const catalogSkillsDir = path.join(REPO_ROOT, 'skills');
+  const catalogAgentsDir = path.join(REPO_ROOT, 'agents');
+  const catalogHooksDir = path.join(REPO_ROOT, 'hooks');
+
+  if (fs.existsSync(catalogSkillsDir)) {
+    const list = fs.readdirSync(catalogSkillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+    skillsToBundle.push(...list);
+  }
+
+  const pluginSkills = [
+    { name: 'antigravity-sdk-orchestrator', src: path.join(REPO_ROOT, 'plugins', 'python-ai', 'skills', 'antigravity-sdk-orchestrator') },
+    { name: 'responsive-design', src: path.join(REPO_ROOT, 'plugins', 'web-fullstack', 'skills', 'responsive-design') }
+  ];
+
+  if (fs.existsSync(catalogAgentsDir)) {
+    const list = fs.readdirSync(catalogAgentsDir)
+      .filter(f => f.endsWith('.md'))
+      .sort();
+    agentsToBundle.push(...list);
+  }
+
+  if (fs.existsSync(catalogHooksDir)) {
+    const list = fs.readdirSync(catalogHooksDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+    hooksToBundle.push(...list);
+  }
+
+  const manifest = {
+    generator: "everything-gemini",
+    version: VERSION,
+    profile,
+    createdAt: new Date().toISOString(),
+    components: {
+      skillsCount: skillsToBundle.length + pluginSkills.length,
+      subagentsCount: agentsToBundle.length,
+      hooksCount: hooksToBundle.length,
+      totalCount: skillsToBundle.length + pluginSkills.length + agentsToBundle.length + hooksToBundle.length
+    },
+    skills: [...skillsToBundle, ...pluginSkills.map(p => p.name)],
+    subagents: agentsToBundle,
+    hooks: hooksToBundle,
+    files: []
   };
-  fs.writeFileSync(path.join(targetDir, 'hooks.json'), JSON.stringify(masterHooks, null, 2));
-  console.log(`  ${GREEN}✔${RESET} Generated master hooks.json`);
 
-  console.log(`\n${GREEN}${BOLD}🎉 Installation complete! Everything Gemini is active.${RESET}\n`);
+  if (isDryRun) {
+    if (asJson) {
+      console.log(JSON.stringify({
+        dryRun: true,
+        targetDirectory: destDir,
+        manifest
+      }, null, 2));
+      return;
+    }
+    printBanner();
+    console.log(`${YELLOW}${BOLD}🔍 DRY RUN MODE ACTIVATED - Previewing bundle contents${RESET}`);
+    console.log(`Target: ${CYAN}${destDir}${RESET}\n`);
+    console.log(`  ${CYAN}⚡ Skills to bundle:${RESET} ${skillsToBundle.length + pluginSkills.length}`);
+    console.log(`  ${CYAN}🤖 Subagents to bundle:${RESET} ${agentsToBundle.length}`);
+    console.log(`  ${CYAN}🛡️ Hooks to bundle:${RESET} ${hooksToBundle.length}`);
+    console.log(`  ${CYAN}📦 Total Components:${RESET} ${manifest.components.totalCount}\n`);
+    console.log(`${GREEN}${BOLD}✨ Dry run preview complete! 0 files written to disk.${RESET}\n`);
+    return;
+  }
+
+  fs.mkdirSync(destDir, { recursive: true });
+  const bundleSkillsDir = path.join(destDir, 'skills');
+  const bundleAgentsDir = path.join(destDir, 'agents');
+  const bundleHooksDir = path.join(destDir, 'hooks');
+  const bundleRulesDir = path.join(destDir, 'rules');
+  fs.mkdirSync(bundleSkillsDir, { recursive: true });
+  fs.mkdirSync(bundleAgentsDir, { recursive: true });
+  fs.mkdirSync(bundleHooksDir, { recursive: true });
+  fs.mkdirSync(bundleRulesDir, { recursive: true });
+
+  for (const s of skillsToBundle) {
+    const src = path.join(catalogSkillsDir, s);
+    const dest = path.join(bundleSkillsDir, s);
+    copyRecursiveSync(src, dest);
+    const skillMd = path.join(dest, 'SKILL.md');
+    if (fs.existsSync(skillMd)) {
+      const hash = crypto.createHash('sha256').update(fs.readFileSync(skillMd)).digest('hex');
+      manifest.files.push({ path: `skills/${s}/SKILL.md`, sha256: hash });
+    }
+  }
+
+  for (const ps of pluginSkills) {
+    if (fs.existsSync(ps.src)) {
+      const dest = path.join(bundleSkillsDir, ps.name);
+      copyRecursiveSync(ps.src, dest);
+      const skillMd = path.join(dest, 'SKILL.md');
+      if (fs.existsSync(skillMd)) {
+        const hash = crypto.createHash('sha256').update(fs.readFileSync(skillMd)).digest('hex');
+        manifest.files.push({ path: `skills/${ps.name}/SKILL.md`, sha256: hash });
+      }
+    }
+  }
+
+  for (const a of agentsToBundle) {
+    const src = path.join(catalogAgentsDir, a);
+    const dest = path.join(bundleAgentsDir, a);
+    fs.copyFileSync(src, dest);
+    const hash = crypto.createHash('sha256').update(fs.readFileSync(dest)).digest('hex');
+    manifest.files.push({ path: `agents/${a}`, sha256: hash });
+  }
+
+  for (const h of hooksToBundle) {
+    const src = path.join(catalogHooksDir, h);
+    const dest = path.join(bundleHooksDir, h);
+    copyRecursiveSync(src, dest);
+    const hookJson = path.join(dest, 'hooks.json');
+    if (fs.existsSync(hookJson)) {
+      const hash = crypto.createHash('sha256').update(fs.readFileSync(hookJson)).digest('hex');
+      manifest.files.push({ path: `hooks/${h}/hooks.json`, sha256: hash });
+    }
+  }
+
+  const commonRules = path.join(REPO_ROOT, 'rules', 'common');
+  if (fs.existsSync(commonRules)) {
+    copyRecursiveSync(commonRules, bundleRulesDir);
+    if (fs.existsSync(path.join(bundleRulesDir, 'GEMINI.md'))) {
+      fs.copyFileSync(path.join(bundleRulesDir, 'GEMINI.md'), path.join(destDir, 'GEMINI.md'));
+    }
+    if (fs.existsSync(path.join(bundleRulesDir, 'AGENTS.md'))) {
+      fs.copyFileSync(path.join(bundleRulesDir, 'AGENTS.md'), path.join(destDir, 'AGENTS.md'));
+    }
+  }
+
+  const installerScript = `#!/usr/bin/env bash
+# Offline Installer for Everything Gemini Bundle
+set -e
+TARGET="\${1:-.agents}"
+mkdir -p "$TARGET/skills" "$TARGET/agents" "$TARGET/hooks"
+cp -R skills/* "$TARGET/skills/" 2>/dev/null || true
+cp -R agents/* "$TARGET/agents/" 2>/dev/null || true
+cp -R hooks/* "$TARGET/hooks/" 2>/dev/null || true
+[ -f GEMINI.md ] && cp GEMINI.md "$TARGET/GEMINI.md"
+[ -f AGENTS.md ] && cp AGENTS.md "$TARGET/AGENTS.md"
+find "$TARGET/hooks" -name "*.sh" -exec chmod +x {} + 2>/dev/null || true
+echo "✨ Offline Everything Gemini bundle installed cleanly into $TARGET"
+`.trim();
+  fs.writeFileSync(path.join(destDir, 'offline-install.sh'), installerScript, { mode: 0o755 });
+
+  fs.writeFileSync(path.join(destDir, 'bundle-manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
+
+  const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      targetDirectory: destDir,
+      manifest,
+      durationSeconds: parseFloat(duration)
+    }, null, 2));
+    return;
+  }
+
+  printBanner();
+  console.log(`${BOLD}📦 Everything Gemini Offline Distribution Bundle Created${RESET}`);
+  console.log(`Target: ${CYAN}${destDir}${RESET}\n`);
+  console.log(`  ${GREEN}✔${RESET} Packaged ${BOLD}${manifest.components.skillsCount}${RESET} progressive disclosure skills`);
+  console.log(`  ${GREEN}✔${RESET} Packaged ${BOLD}${manifest.components.subagentsCount}${RESET} scoped subagents`);
+  console.log(`  ${GREEN}✔${RESET} Packaged ${BOLD}${manifest.components.hooksCount}${RESET} lifecycle safety hooks`);
+  console.log(`  ${GREEN}✔${RESET} Generated ${BOLD}bundle-manifest.json${RESET} with ${manifest.files.length} SHA-256 integrity digests`);
+  console.log(`  ${GREEN}✔${RESET} Generated executable ${BOLD}offline-install.sh${RESET}`);
+  console.log(`  ${GREEN}✔${RESET} Total bundle duration: ${duration}s\n`);
+  console.log(`${GREEN}${BOLD}✨ Bundle packaging complete! Ready for air-gapped and CI/CD deployment.${RESET}\n`);
 }
 
 function runValidate() {
@@ -399,21 +1065,26 @@ function runValidate() {
   }
 }
 
-function scaffoldSkill(name) {
+function scaffoldSkill(name, customTarget = null, isDryRun = false, asJson = false) {
   if (!name) {
-    console.error(`${RED}Error: Skill name required. Example: everything-gemini new-skill my-skill${RESET}`);
+    console.error(`${RED}Error: Skill name required. Example: everything-gemini scaffold skill my-skill${RESET}`);
     process.exit(1);
   }
   const cleanName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-  const targetDir = path.join(REPO_ROOT, 'skills', cleanName);
+  const baseSkills = customTarget 
+    ? path.join(path.resolve(customTarget), 'skills')
+    : (fs.existsSync(path.join(process.cwd(), '.agents')) ? path.join(process.cwd(), '.agents', 'skills') : path.join(REPO_ROOT, 'skills'));
+  const targetDir = path.join(baseSkills, cleanName);
+
   if (fs.existsSync(targetDir)) {
-    console.error(`${RED}Error: Skill '${cleanName}' already exists at ${targetDir}${RESET}`);
+    if (asJson) {
+      console.log(JSON.stringify({ error: `Skill '${cleanName}' already exists at ${targetDir}` }));
+    } else {
+      console.error(`${RED}Error: Skill '${cleanName}' already exists at ${targetDir}${RESET}`);
+    }
     process.exit(1);
   }
 
-  fs.mkdirSync(path.join(targetDir, 'references'), { recursive: true });
-  fs.mkdirSync(path.join(targetDir, 'scripts'), { recursive: true });
-
   const titleCase = cleanName.split('-').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' ');
   const skillMd = `---
 name: ${cleanName}
@@ -453,12 +1124,29 @@ set -euo pipefail
 echo "Executing ${cleanName} automated helper..."
 `;
 
+  if (isDryRun) {
+    if (asJson) {
+      console.log(JSON.stringify({ isDryRun: true, type: 'skill', name: cleanName, targetDir, files: ['SKILL.md', 'references/spec.md', 'scripts/helper.sh'] }, null, 2));
+    } else {
+      console.log(`${YELLOW}[DRY RUN] Would scaffold skill at:${RESET} ${targetDir}`);
+      console.log(`  📄 SKILL.md, references/spec.md, scripts/helper.sh\n`);
+    }
+    return;
+  }
+
+  fs.mkdirSync(path.join(targetDir, 'references'), { recursive: true });
+  fs.mkdirSync(path.join(targetDir, 'scripts'), { recursive: true });
   fs.writeFileSync(path.join(targetDir, 'SKILL.md'), skillMd);
   fs.writeFileSync(path.join(targetDir, 'references', 'spec.md'), specMd);
   const scriptPath = path.join(targetDir, 'scripts', 'helper.sh');
   fs.writeFileSync(scriptPath, helperSh);
   try { fs.chmodSync(scriptPath, 0o755); } catch (e) {}
 
+  if (asJson) {
+    console.log(JSON.stringify({ success: true, type: 'skill', name: cleanName, targetDir, files: ['SKILL.md', 'references/spec.md', 'scripts/helper.sh'] }, null, 2));
+    return;
+  }
+
   console.log(`${GREEN}✔ Created progressive disclosure skill:${RESET} ${BOLD}${cleanName}${RESET}`);
   console.log(`  📁 ${targetDir}`);
   console.log(`  📄 SKILL.md (YAML frontmatter + procedural workflow)`);
@@ -466,17 +1154,23 @@ echo "Executing ${cleanName} automated helper..."
   console.log(`  🔧 scripts/helper.sh (executable helper)\n`);
 }
 
-function scaffoldAgent(name) {
+function scaffoldAgent(name, customTarget = null, isDryRun = false, asJson = false) {
   if (!name) {
-    console.error(`${RED}Error: Agent name required. Example: everything-gemini new-agent my-agent${RESET}`);
+    console.error(`${RED}Error: Agent name required. Example: everything-gemini scaffold agent my-agent${RESET}`);
     process.exit(1);
   }
   const cleanName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-  const targetDir = path.join(REPO_ROOT, 'agents');
-  if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
-  const targetFile = path.join(targetDir, `${cleanName}.md`);
+  const baseAgents = customTarget
+    ? path.join(path.resolve(customTarget), 'agents')
+    : (fs.existsSync(path.join(process.cwd(), '.agents')) ? path.join(process.cwd(), '.agents', 'agents') : path.join(REPO_ROOT, 'agents'));
+  const targetFile = path.join(baseAgents, `${cleanName}.md`);
+
   if (fs.existsSync(targetFile)) {
-    console.error(`${RED}Error: Agent '${cleanName}' already exists at ${targetFile}${RESET}`);
+    if (asJson) {
+      console.log(JSON.stringify({ error: `Agent '${cleanName}' already exists at ${targetFile}` }));
+    } else {
+      console.error(`${RED}Error: Agent '${cleanName}' already exists at ${targetFile}${RESET}`);
+    }
     process.exit(1);
   }
 
@@ -502,26 +1196,220 @@ Return structured report to parent agent:
 - **Open Questions / Recommended Next Steps**:
 `;
 
+  if (isDryRun) {
+    if (asJson) {
+      console.log(JSON.stringify({ isDryRun: true, type: 'agent', name: cleanName, targetFile }, null, 2));
+    } else {
+      console.log(`${YELLOW}[DRY RUN] Would scaffold subagent at:${RESET} ${targetFile}\n`);
+    }
+    return;
+  }
+
+  if (!fs.existsSync(baseAgents)) fs.mkdirSync(baseAgents, { recursive: true });
   fs.writeFileSync(targetFile, agentMd);
+
+  if (asJson) {
+    console.log(JSON.stringify({ success: true, type: 'agent', name: cleanName, targetFile }, null, 2));
+    return;
+  }
+
   console.log(`${GREEN}✔ Created subagent profile:${RESET} ${BOLD}${cleanName}${RESET}`);
   console.log(`  📄 ${targetFile}\n`);
 }
 
-function addComponent(type, name) {
-  if (!type || !name) {
-    console.error(`${RED}Usage: everything-gemini add <skill|agent|plugin> <name>${RESET}`);
+function scaffoldHook(name, customTarget = null, isDryRun = false, asJson = false) {
+  if (!name) {
+    console.error(`${RED}Error: Hook name required. Example: everything-gemini scaffold hook my-hook${RESET}`);
     process.exit(1);
   }
+  const cleanName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+  const baseHooks = customTarget
+    ? path.join(path.resolve(customTarget), 'hooks')
+    : (fs.existsSync(path.join(process.cwd(), '.agents')) ? path.join(process.cwd(), '.agents', 'hooks') : path.join(REPO_ROOT, 'hooks'));
+  const targetDir = path.join(baseHooks, cleanName);
 
-  const cleanName = name.trim().toLowerCase();
-  const targetWorkspace = path.join(WORKSPACE_DIR, '.agents');
-  if (!fs.existsSync(targetWorkspace)) {
-    fs.mkdirSync(targetWorkspace, { recursive: true });
+  if (fs.existsSync(targetDir)) {
+    if (asJson) {
+      console.log(JSON.stringify({ error: `Hook '${cleanName}' already exists at ${targetDir}` }));
+    } else {
+      console.error(`${RED}Error: Hook '${cleanName}' already exists at ${targetDir}${RESET}`);
+    }
+    process.exit(1);
   }
 
-  if (type === 'skill') {
-    const src = path.join(REPO_ROOT, 'skills', cleanName);
-    if (!fs.existsSync(src)) {
+  const hooksJson = {
+    hooks: [
+      {
+        event: "PreToolExecution",
+        matcher: { tool: "run_command" },
+        action: "execute",
+        script: `scripts/${cleanName}-gate.sh`
+      }
+    ]
+  };
+
+  const scriptSh = `#!/usr/bin/env bash
+set -euo pipefail
+
+# Lifecycle hook gate: ${cleanName}
+INPUT=$(cat)
+echo "Executing lifecycle hook: ${cleanName}" >&2
+echo '{"status": "proceed"}'
+`;
+
+  if (isDryRun) {
+    if (asJson) {
+      console.log(JSON.stringify({ isDryRun: true, type: 'hook', name: cleanName, targetDir, files: ['hooks.json', `scripts/${cleanName}-gate.sh`] }, null, 2));
+    } else {
+      console.log(`${YELLOW}[DRY RUN] Would scaffold hook at:${RESET} ${targetDir}`);
+      console.log(`  📄 hooks.json, scripts/${cleanName}-gate.sh\n`);
+    }
+    return;
+  }
+
+  fs.mkdirSync(path.join(targetDir, 'scripts'), { recursive: true });
+  fs.writeFileSync(path.join(targetDir, 'hooks.json'), JSON.stringify(hooksJson, null, 2));
+  const scriptPath = path.join(targetDir, 'scripts', `${cleanName}-gate.sh`);
+  fs.writeFileSync(scriptPath, scriptSh);
+  try { fs.chmodSync(scriptPath, 0o755); } catch (e) {}
+
+  if (asJson) {
+    console.log(JSON.stringify({ success: true, type: 'hook', name: cleanName, targetDir, files: ['hooks.json', `scripts/${cleanName}-gate.sh`] }, null, 2));
+    return;
+  }
+
+  console.log(`${GREEN}✔ Created lifecycle hook:${RESET} ${BOLD}${cleanName}${RESET}`);
+  console.log(`  📁 ${targetDir}`);
+  console.log(`  📄 hooks.json (event registration)`);
+  console.log(`  🔧 scripts/${cleanName}-gate.sh (executable gate)\n`);
+}
+
+function runScaffold(type, name, customTarget = null, isDryRun = false, asJson = false) {
+  if (!type || !name) {
+    console.error(`${RED}Error: Type and name required. Example: everything-gemini scaffold skill my-skill${RESET}`);
+    process.exit(1);
+  }
+  const cleanType = type.toLowerCase();
+  if (['skill', 'skills'].includes(cleanType)) {
+    scaffoldSkill(name, customTarget, isDryRun, asJson);
+  } else if (['agent', 'agents', 'subagent'].includes(cleanType)) {
+    scaffoldAgent(name, customTarget, isDryRun, asJson);
+  } else if (['hook', 'hooks'].includes(cleanType)) {
+    scaffoldHook(name, customTarget, isDryRun, asJson);
+  } else {
+    console.error(`${RED}Error: Unknown scaffold type '${type}'. Supported types: skill, agent, hook${RESET}`);
+    process.exit(1);
+  }
+}
+
+function runSync(customTarget = null, isGlobal = false, isDryRun = false, asJson = false, force = false) {
+  const targetDir = isGlobal
+    ? GLOBAL_CONFIG_DIR
+    : (customTarget ? path.resolve(customTarget) : (fs.existsSync(path.join(process.cwd(), '.agents')) ? path.join(process.cwd(), '.agents') : AGENTS_DIR));
+
+  if (!asJson) {
+    printBanner();
+    if (isDryRun) {
+      console.log(`${YELLOW}${BOLD}🔍 DRY RUN MODE ACTIVATED - No files will be modified on disk.${RESET}`);
+    }
+    console.log(`${BOLD}🔄 Synchronizing Workspace with Catalog: ${CYAN}${targetDir}${RESET}\n`);
+  }
+
+  const syncReport = {
+    target: targetDir,
+    timestamp: new Date().toISOString(),
+    isDryRun,
+    syncedSkills: [],
+    syncedAgents: [],
+    syncedHooks: [],
+    upToDateCount: 0,
+    updatedCount: 0,
+    createdCount: 0,
+    success: true,
+  };
+
+  if (!fs.existsSync(targetDir)) {
+    if (isDryRun) {
+      if (asJson) {
+        console.log(JSON.stringify({ ...syncReport, error: 'Target directory does not exist' }, null, 2));
+      } else {
+        console.log(`  ${YELLOW}○ Workspace does not exist yet. Run 'everything-gemini install' to initialize.${RESET}\n`);
+      }
+      return;
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  // 1. Sync Installed Skills
+  const targetSkills = path.join(targetDir, 'skills');
+  const catalogSkills = path.join(REPO_ROOT, 'skills');
+  if (fs.existsSync(targetSkills) && fs.existsSync(catalogSkills)) {
+    const installed = fs.readdirSync(targetSkills, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const skill of installed) {
+      const src = path.join(catalogSkills, skill);
+      const dest = path.join(targetSkills, skill);
+      if (fs.existsSync(src)) {
+        if (!isDryRun) copyRecursiveSync(src, dest);
+        syncReport.updatedCount++;
+        syncReport.syncedSkills.push({ name: skill, status: 'synced' });
+        if (!asJson) console.log(`  ${GREEN}✔${RESET} Skill synced: ${BOLD}${skill}${RESET}`);
+      }
+    }
+  }
+
+  // 2. Sync Installed Subagents
+  const targetAgents = path.join(targetDir, 'agents');
+  const catalogAgents = path.join(REPO_ROOT, 'agents');
+  if (fs.existsSync(targetAgents) && fs.existsSync(catalogAgents)) {
+    const installed = fs.readdirSync(targetAgents).filter(f => f.endsWith('.md'));
+    for (const ag of installed) {
+      const src = path.join(catalogAgents, ag);
+      const dest = path.join(targetAgents, ag);
+      if (fs.existsSync(src)) {
+        if (!isDryRun) fs.copyFileSync(src, dest);
+        syncReport.updatedCount++;
+        syncReport.syncedAgents.push({ name: ag.replace('.md', ''), status: 'synced' });
+        if (!asJson) console.log(`  ${GREEN}✔${RESET} Subagent synced: ${BOLD}${ag.replace('.md', '')}${RESET}`);
+      }
+    }
+  }
+
+  // 3. Ensure Recommended Hooks & Scripts Executability
+  const targetHooksJson = path.join(targetDir, 'hooks.json');
+  if (fs.existsSync(targetHooksJson)) {
+    syncReport.upToDateCount++;
+    syncReport.syncedHooks.push({ name: 'hooks.json', status: 'verified' });
+    if (!asJson) console.log(`  ${GREEN}✔${RESET} Lifecycle hooks verified: ${BOLD}hooks.json${RESET}`);
+  }
+
+  if (asJson) {
+    console.log(JSON.stringify(syncReport, null, 2));
+    return;
+  }
+
+  console.log(`\n${GREEN}${BOLD}✨ Synchronization completed! Workspace is aligned with catalog.${RESET}\n`);
+}
+
+function addComponent(type, name, isGlobal = false, customTarget = null) {
+  if (!type || !name) {
+    console.error(`${RED}Usage: everything-gemini add <skill|agent|hook|plugin> <name> [--workspace <path>] [--global]${RESET}`);
+    process.exit(1);
+  }
+
+  const cleanName = name.trim().toLowerCase();
+  const targetWorkspace = customTarget 
+    ? path.resolve(customTarget)
+    : (isGlobal ? GLOBAL_CONFIG_DIR : path.join(WORKSPACE_DIR, '.agents'));
+
+  if (!fs.existsSync(targetWorkspace)) {
+    fs.mkdirSync(targetWorkspace, { recursive: true });
+  }
+
+  if (type === 'skill') {
+    const src = path.join(REPO_ROOT, 'skills', cleanName);
+    if (!fs.existsSync(src)) {
       console.error(`${RED}Skill '${cleanName}' not found in catalog.${RESET}`);
       process.exit(1);
     }
@@ -538,6 +1426,21 @@ function addComponent(type, name) {
     fs.mkdirSync(destDir, { recursive: true });
     fs.copyFileSync(src, path.join(destDir, `${cleanName}.md`));
     console.log(`${GREEN}✔ Added agent '${cleanName}' to ${destDir}${RESET}`);
+  } else if (type === 'hook') {
+    const src = path.join(REPO_ROOT, 'hooks', cleanName);
+    if (!fs.existsSync(src)) {
+      console.error(`${RED}Hook '${cleanName}' not found in catalog.${RESET}`);
+      process.exit(1);
+    }
+    const dest = path.join(targetWorkspace, 'hooks', cleanName);
+    copyRecursiveSync(src, dest);
+    const scriptsDir = path.join(dest, 'scripts');
+    if (fs.existsSync(scriptsDir)) {
+      fs.readdirSync(scriptsDir).forEach(file => {
+        try { fs.chmodSync(path.join(scriptsDir, file), 0o755); } catch (e) {}
+      });
+    }
+    console.log(`${GREEN}✔ Added hook '${cleanName}' to ${dest}${RESET}`);
   } else if (type === 'plugin') {
     const src = path.join(REPO_ROOT, 'plugins', cleanName);
     if (!fs.existsSync(src)) {
@@ -548,19 +1451,21 @@ function addComponent(type, name) {
     copyRecursiveSync(src, dest);
     console.log(`${GREEN}✔ Added plugin '${cleanName}' to ${dest}${RESET}`);
   } else {
-    console.error(`${RED}Unknown type '${type}'. Use: skill, agent, or plugin.${RESET}`);
+    console.error(`${RED}Unknown type '${type}'. Use: skill, agent, hook, or plugin.${RESET}`);
     process.exit(1);
   }
 }
 
-function removeComponent(type, name) {
+function removeComponent(type, name, isGlobal = false, customTarget = null) {
   if (!type || !name) {
-    console.error(`${RED}Usage: everything-gemini remove <skill|agent|plugin> <name>${RESET}`);
+    console.error(`${RED}Usage: everything-gemini remove <skill|agent|hook|plugin> <name> [--workspace <path>] [--global]${RESET}`);
     process.exit(1);
   }
 
   const cleanName = name.trim().toLowerCase();
-  const targetWorkspace = path.join(WORKSPACE_DIR, '.agents');
+  const targetWorkspace = customTarget 
+    ? path.resolve(customTarget)
+    : (isGlobal ? GLOBAL_CONFIG_DIR : path.join(WORKSPACE_DIR, '.agents'));
 
   if (type === 'skill') {
     const dest = path.join(targetWorkspace, 'skills', cleanName);
@@ -569,7 +1474,7 @@ function removeComponent(type, name) {
       return;
     }
     fs.rmSync(dest, { recursive: true, force: true });
-    console.log(`${GREEN}✔ Removed skill '${cleanName}' from workspace.${RESET}`);
+    console.log(`${GREEN}✔ Removed skill '${cleanName}' from ${dest}.${RESET}`);
   } else if (type === 'agent') {
     const dest = path.join(targetWorkspace, 'agents', `${cleanName}.md`);
     if (!fs.existsSync(dest)) {
@@ -577,7 +1482,15 @@ function removeComponent(type, name) {
       return;
     }
     fs.unlinkSync(dest);
-    console.log(`${GREEN}✔ Removed agent '${cleanName}' from workspace.${RESET}`);
+    console.log(`${GREEN}✔ Removed agent '${cleanName}' from ${dest}.${RESET}`);
+  } else if (type === 'hook') {
+    const dest = path.join(targetWorkspace, 'hooks', cleanName);
+    if (!fs.existsSync(dest)) {
+      console.log(`${YELLOW}Hook '${cleanName}' is not installed in ${dest}${RESET}`);
+      return;
+    }
+    fs.rmSync(dest, { recursive: true, force: true });
+    console.log(`${GREEN}✔ Removed hook '${cleanName}' from ${dest}.${RESET}`);
   } else if (type === 'plugin') {
     const dest = path.join(targetWorkspace, 'plugins', cleanName);
     if (!fs.existsSync(dest)) {
@@ -585,9 +1498,9 @@ function removeComponent(type, name) {
       return;
     }
     fs.rmSync(dest, { recursive: true, force: true });
-    console.log(`${GREEN}✔ Removed plugin '${cleanName}' from workspace.${RESET}`);
+    console.log(`${GREEN}✔ Removed plugin '${cleanName}' from ${dest}.${RESET}`);
   } else {
-    console.error(`${RED}Unknown type '${type}'. Use: skill, agent, or plugin.${RESET}`);
+    console.error(`${RED}Unknown type '${type}'. Use: skill, agent, hook, or plugin.${RESET}`);
     process.exit(1);
   }
 }
@@ -654,14 +1567,582 @@ function testSkill(name) {
   console.log(`\n${GREEN}${BOLD}✨ Skill '${cleanName}' passed all validation checks!${RESET}\n`);
 }
 
-function showSkillInfo(skillName) {
-  if (!skillName) {
-    console.error(`\n${RED}Error: Please specify a skill name.${RESET}`);
-    console.log(`Usage: everything-gemini info <skill-name>\n`);
+function searchComponents(query, asJson = false) {
+  if (!query || !query.trim()) {
+    console.log(`${YELLOW}Please specify a search query.${RESET}`);
+    console.log(`Usage: everything-gemini search <term> [--json]\n`);
+    return;
+  }
+  const q = query.trim().toLowerCase();
+  const results = {
+    skills: [],
+    subagents: [],
+    hooks: [],
+    mcp: []
+  };
+
+  // 1. Search Skills (core + plugins)
+  const skillsDir = path.join(REPO_ROOT, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    const skills = fs.readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const skill of skills) {
+      const skillMd = path.join(skillsDir, skill, 'SKILL.md');
+      let desc = '';
+      let fullContent = '';
+      if (fs.existsSync(skillMd)) {
+        fullContent = fs.readFileSync(skillMd, 'utf8');
+        const match = fullContent.match(/description:\s*>?-?\s*([^\n\r]+)/);
+        if (match) desc = match[1].trim();
+      }
+      if (skill.toLowerCase().includes(q) || desc.toLowerCase().includes(q) || fullContent.toLowerCase().includes(q)) {
+        results.skills.push({ name: skill, description: desc || 'Progressive disclosure skill' });
+      }
+    }
+  }
+
+  const pluginsDir = path.join(REPO_ROOT, 'plugins');
+  if (fs.existsSync(pluginsDir)) {
+    const plugins = fs.readdirSync(pluginsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const p of plugins) {
+      const pSkillsDir = path.join(pluginsDir, p, 'skills');
+      if (fs.existsSync(pSkillsDir)) {
+        const pSkills = fs.readdirSync(pSkillsDir, { withFileTypes: true })
+          .filter(d => d.isDirectory())
+          .map(d => d.name);
+        for (const skill of pSkills) {
+          const skillMd = path.join(pSkillsDir, skill, 'SKILL.md');
+          let desc = '';
+          let fullContent = '';
+          if (fs.existsSync(skillMd)) {
+            fullContent = fs.readFileSync(skillMd, 'utf8');
+            const match = fullContent.match(/description:\s*>?-?\s*([^\n\r]+)/);
+            if (match) desc = match[1].trim();
+          }
+          if (skill.toLowerCase().includes(q) || desc.toLowerCase().includes(q) || fullContent.toLowerCase().includes(q)) {
+            results.skills.push({ name: `${skill} [${p}]`, description: desc || 'Plugin progressive skill' });
+          }
+        }
+      }
+    }
+  }
+
+  // 2. Search Subagents
+  const agentsDir = path.join(REPO_ROOT, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+    for (const ag of agents) {
+      const name = ag.replace('.md', '');
+      const content = fs.readFileSync(path.join(agentsDir, ag), 'utf8');
+      const missionMatch = content.match(/## Role & Mission\s+([^\n\r]+)/);
+      const mission = missionMatch ? missionMatch[1].trim() : '';
+      if (name.toLowerCase().includes(q) || content.toLowerCase().includes(q)) {
+        results.subagents.push({ name, description: mission || 'Scoped autonomous subagent' });
+      }
+    }
+  }
+
+  // 3. Search Lifecycle Hooks
+  const hooksDir = path.join(REPO_ROOT, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    const hooks = fs.readdirSync(hooksDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const h of hooks) {
+      const hJson = path.join(hooksDir, h, 'hooks.json');
+      let desc = 'Lifecycle safety gate';
+      if (fs.existsSync(hJson)) {
+        try {
+          const parsed = JSON.parse(fs.readFileSync(hJson, 'utf8'));
+          if (parsed.description) desc = parsed.description;
+        } catch (_) {}
+      }
+      if (h.toLowerCase().includes(q) || desc.toLowerCase().includes(q)) {
+        results.hooks.push({ name: h, description: desc });
+      }
+    }
+  }
+
+  // 4. Search MCP Blueprints
+  const mcpExamplePath = path.join(REPO_ROOT, 'mcp', 'mcp_config.example.json');
+  if (fs.existsSync(mcpExamplePath)) {
+    try {
+      const mcpConfig = JSON.parse(fs.readFileSync(mcpExamplePath, 'utf8'));
+      for (const [srvName, cfg] of Object.entries(mcpConfig.mcpServers || {})) {
+        const cmdStr = `${srvName} ${cfg.command || ''} ${(cfg.args || []).join(' ')}`;
+        if (cmdStr.toLowerCase().includes(q)) {
+          results.mcp.push({ name: srvName, description: (cfg.args || []).join(' ') || cfg.command });
+        }
+      }
+    } catch (_) {}
+  }
+
+  const totalMatches = results.skills.length + results.subagents.length + results.hooks.length + results.mcp.length;
+
+  if (asJson) {
+    console.log(JSON.stringify({ query, totalMatches, results }, null, 2));
+    return;
+  }
+
+  printBanner();
+  console.log(`${BOLD}🔎 Search Results for: "${CYAN}${query}${RESET}${BOLD}" (${GREEN}${totalMatches} found${RESET}${BOLD})${RESET}\n`);
+
+  if (totalMatches === 0) {
+    console.log(`  ${YELLOW}○ No matching components found.${RESET}`);
+    console.log(`    Run ${GREEN}everything-gemini list${RESET} to browse all 48 skills, 10 subagents, and 7 hooks.\n`);
+    return;
+  }
+
+  if (results.skills.length > 0) {
+    console.log(`${CYAN}${BOLD}⚡ Progressive Skills (${results.skills.length}):${RESET}`);
+    for (const s of results.skills) {
+      console.log(`  • ${BOLD}${s.name.padEnd(28)}${RESET} ${GRAY}${s.description}${RESET}`);
+      console.log(`    ${GREEN}Add:${RESET} everything-gemini add skill ${s.name.split(' ')[0]}`);
+    }
+    console.log('');
+  }
+
+  if (results.subagents.length > 0) {
+    console.log(`${CYAN}${BOLD}🤖 Scoped Subagents (${results.subagents.length}):${RESET}`);
+    for (const a of results.subagents) {
+      console.log(`  • ${BOLD}${a.name.padEnd(28)}${RESET} ${GRAY}${a.description}${RESET}`);
+      console.log(`    ${GREEN}Add:${RESET} everything-gemini add agent ${a.name}`);
+    }
+    console.log('');
+  }
+
+  if (results.hooks.length > 0) {
+    console.log(`${CYAN}${BOLD}🛡️ Lifecycle Hooks (${results.hooks.length}):${RESET}`);
+    for (const h of results.hooks) {
+      console.log(`  • ${BOLD}${h.name.padEnd(28)}${RESET} ${GRAY}${h.description}${RESET}`);
+      console.log(`    ${GREEN}Add:${RESET} everything-gemini add hook ${h.name}`);
+    }
+    console.log('');
+  }
+
+  if (results.mcp.length > 0) {
+    console.log(`${CYAN}${BOLD}🌐 MCP Blueprints (${results.mcp.length}):${RESET}`);
+    for (const m of results.mcp) {
+      console.log(`  • ${BOLD}${m.name.padEnd(28)}${RESET} ${GRAY}${m.description}${RESET}`);
+    }
+    console.log('');
+  }
+}
+
+function runAudit(targetPath = null, isGlobal = false, asJson = false) {
+  const targetDir = isGlobal
+    ? path.join(os.homedir(), '.gemini', 'config')
+    : (targetPath ? path.resolve(targetPath) : (fs.existsSync(path.join(process.cwd(), '.agents')) ? path.join(process.cwd(), '.agents') : REPO_ROOT));
+
+  const isRepoAudit = (targetDir === REPO_ROOT);
+  const auditReport = {
+    target: targetDir,
+    timestamp: new Date().toISOString(),
+    isRepoCatalog: isRepoAudit,
+    checks: [],
+    passedCount: 0,
+    warningCount: 0,
+    errorCount: 0,
+    valid: true,
+  };
+
+  function addCheck(category, item, status, message, details = null) {
+    if (status === 'error') auditReport.errorCount++;
+    else if (status === 'warn') auditReport.warningCount++;
+    else auditReport.passedCount++;
+    auditReport.checks.push({ category, item, status, message, details });
+  }
+
+  // 1. Audit Skills
+  const skillsBase = isRepoAudit ? path.join(REPO_ROOT, 'skills') : path.join(targetDir, 'skills');
+  if (fs.existsSync(skillsBase)) {
+    const skillEntries = fs.readdirSync(skillsBase, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const ent of skillEntries) {
+      const skillFile = path.join(skillsBase, ent.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) {
+        addCheck('skills', ent.name, 'error', 'Missing SKILL.md in directory');
+        continue;
+      }
+      const raw = fs.readFileSync(skillFile, 'utf8');
+      const lines = raw.split('\n');
+      const parts = raw.split('---');
+      if (parts.length < 3) {
+        addCheck('skills', ent.name, 'error', 'Invalid or missing YAML frontmatter delimiters (---)');
+        continue;
+      }
+      const frontmatter = parts[1];
+      const nameMatch = frontmatter.match(/name:\s*([a-zA-Z0-9_-]+)/);
+      const descMatch = frontmatter.match(/description:\s*>?-?\s*([^\n\r]+)/);
+
+      if (!nameMatch) {
+        addCheck('skills', ent.name, 'error', "Missing 'name' field in YAML frontmatter");
+      } else if (nameMatch[1].trim() !== ent.name) {
+        addCheck('skills', ent.name, 'warn', `Frontmatter name '${nameMatch[1].trim()}' does not match directory '${ent.name}'`);
+      }
+
+      if (!descMatch || !descMatch[1].trim()) {
+        addCheck('skills', ent.name, 'error', "Missing 'description' trigger in YAML frontmatter");
+      }
+
+      if (lines.length > 260) {
+        addCheck('skills', ent.name, 'warn', `Runbook length exceeds 250 lines (${lines.length} lines); consider progressive disclosure sub-references`);
+      } else {
+        addCheck('skills', ent.name, 'pass', `Valid YAML frontmatter and runbook compliance (${lines.length} lines)`);
+      }
+    }
+  }
+
+  // 2. Audit Scoped Subagents
+  const agentsBase = isRepoAudit ? path.join(REPO_ROOT, 'agents') : path.join(targetDir, 'agents');
+  if (fs.existsSync(agentsBase)) {
+    const agentFiles = fs.readdirSync(agentsBase).filter(f => f.endsWith('.md'));
+    for (const f of agentFiles) {
+      const agentPath = path.join(agentsBase, f);
+      const content = fs.readFileSync(agentPath, 'utf8');
+      const hasRole = /#+\s*(Core Role|Role & Mission)/i.test(content);
+      const hasGuardrails = /#+\s*(Execution Guardrails|Tool Permissions)/i.test(content);
+      const hasProtocol = /#+\s*(Delegation Protocol|Protocol|Handoff)/i.test(content);
+
+      if (hasRole && hasGuardrails && hasProtocol) {
+        addCheck('subagents', f, 'pass', 'Complies with Subagent Specification Contract (Role, Guardrails, Handoff)');
+      } else {
+        const missing = [];
+        if (!hasRole) missing.push('Role & Mission');
+        if (!hasGuardrails) missing.push('Guardrails / Tool Permissions');
+        if (!hasProtocol) missing.push('Handoff / Protocol');
+        addCheck('subagents', f, 'error', `Missing required specification sections: ${missing.join(', ')}`);
+      }
+    }
+  }
+
+  // 3. Audit Lifecycle Hooks
+  const hooksBase = isRepoAudit ? path.join(REPO_ROOT, 'hooks') : path.join(targetDir, 'hooks');
+  if (fs.existsSync(hooksBase)) {
+    const hookDirs = fs.readdirSync(hooksBase, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const hd of hookDirs) {
+      const scriptsDir = path.join(hooksBase, hd.name, 'scripts');
+      if (fs.existsSync(scriptsDir)) {
+        const scripts = fs.readdirSync(scriptsDir).filter(s => s.endsWith('.sh'));
+        for (const s of scripts) {
+          const sPath = path.join(scriptsDir, s);
+          try {
+            fs.accessSync(sPath, fs.constants.X_OK);
+            addCheck('hooks', `${hd.name}/${s}`, 'pass', 'Hook script is executable (+x)');
+          } catch {
+            addCheck('hooks', `${hd.name}/${s}`, 'error', 'Hook script lacks executable permissions (chmod +x)');
+          }
+        }
+      }
+    }
+  }
+
+  auditReport.valid = (auditReport.errorCount === 0);
+
+  if (asJson) {
+    console.log(JSON.stringify(auditReport, null, 2));
+    if (!auditReport.valid) process.exit(1);
+    return;
+  }
+
+  printBanner();
+  console.log(`${BOLD}🛡️ Everything Gemini Ecosystem Audit Report${RESET}`);
+  console.log(`Target: ${CYAN}${targetDir}${RESET} ${isRepoAudit ? `${YELLOW}(Master Repository Catalog)${RESET}` : ''}\n`);
+
+  const categories = ['skills', 'subagents', 'hooks'];
+  for (const cat of categories) {
+    const items = auditReport.checks.filter(c => c.category === cat);
+    if (items.length === 0) continue;
+
+    const catTitle = cat === 'skills' ? '⚡ Progressive Skills' :
+                     cat === 'subagents' ? '🤖 Scoped Subagents' : '🛡️ Lifecycle Hooks';
+    console.log(`${BOLD}${catTitle} (${items.length}):${RESET}`);
+    for (const it of items) {
+      const icon = it.status === 'pass' ? `${GREEN}✔${RESET}` :
+                   it.status === 'warn' ? `${YELLOW}▲${RESET}` : `${RED}✘${RESET}`;
+      console.log(`  ${icon} ${it.item.padEnd(32)} ${it.message}`);
+    }
+    console.log('');
+  }
+
+  console.log(`${BOLD}✨ Audit Summary:${RESET}`);
+  console.log(`  Passed Checks:   ${GREEN}${auditReport.passedCount}${RESET}`);
+  console.log(`  Warnings:        ${auditReport.warningCount > 0 ? YELLOW : GREEN}${auditReport.warningCount}${RESET}`);
+  console.log(`  Errors:          ${auditReport.errorCount > 0 ? RED : GREEN}${auditReport.errorCount}${RESET}\n`);
+
+  if (auditReport.valid) {
+    console.log(`  ${GREEN}${BOLD}✔ ALL CHECKS PASSED: Target is 100% compliant with Antigravity Progressive Disclosure standards!${RESET}\n`);
+  } else {
+    console.log(`  ${RED}${BOLD}✘ AUDIT FAILED: ${auditReport.errorCount} blocking errors found.${RESET}\n`);
     process.exit(1);
   }
+}
+
+function testAllSkills(asJson = false) {
+  const startTime = Date.now();
+  let skillCount = 0;
+  let totalChars = 0;
+  const skillsGathered = [];
 
-  const cleanName = skillName.trim().replace(/^skills\//, '');
+  // 1. Core Skills
+  const skillsDir = path.join(REPO_ROOT, 'skills');
+  const skills = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name)
+    .sort();
+
+  if (!asJson) {
+    printBanner();
+    console.log(`${BOLD}🧪 Benchmarking & Validating All Skills, Subagents & Hooks...${RESET}\n`);
+    console.log(`${CYAN}${BOLD}⚡ Skills Validation (Progressive Disclosure):${RESET}`);
+  }
+
+  for (const s of skills) {
+    const md = path.join(skillsDir, s, 'SKILL.md');
+    if (fs.existsSync(md)) {
+      const content = fs.readFileSync(md, 'utf8');
+      totalChars += content.length;
+      skillCount++;
+      const estTokens = Math.round(content.length / 4);
+      skillsGathered.push({ name: s, plugin: null, tokens: estTokens });
+      if (!asJson) {
+        console.log(`  ${GREEN}✔${RESET} ${s.padEnd(30)} ${GRAY}(~${estTokens} tokens)${RESET}`);
+      }
+    }
+  }
+
+  // 2. Plugin Skills
+  const pluginsDir = path.join(REPO_ROOT, 'plugins');
+  if (fs.existsSync(pluginsDir)) {
+    const plugins = fs.readdirSync(pluginsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+    for (const p of plugins) {
+      const pSkillsDir = path.join(pluginsDir, p, 'skills');
+      if (fs.existsSync(pSkillsDir)) {
+        const pSkills = fs.readdirSync(pSkillsDir, { withFileTypes: true })
+          .filter(d => d.isDirectory())
+          .map(d => d.name)
+          .sort();
+        for (const s of pSkills) {
+          const md = path.join(pSkillsDir, s, 'SKILL.md');
+          if (fs.existsSync(md)) {
+            const content = fs.readFileSync(md, 'utf8');
+            totalChars += content.length;
+            skillCount++;
+            const estTokens = Math.round(content.length / 4);
+            skillsGathered.push({ name: s, plugin: p, tokens: estTokens });
+            if (!asJson) {
+              console.log(`  ${GREEN}✔${RESET} ${(`${s} [${p}]`).padEnd(30)} ${GRAY}(~${estTokens} tokens)${RESET}`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Subagents
+  if (!asJson) console.log(`\n${CYAN}${BOLD}🤖 Scoped Subagents Validation:${RESET}`);
+  const agentsDir = path.join(REPO_ROOT, 'agents');
+  const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).sort().map(f => f.replace('.md', ''));
+  if (!asJson) {
+    for (const a of agents) {
+      console.log(`  ${GREEN}✔${RESET} ${a.padEnd(30)}`);
+    }
+  }
+
+  // 4. Lifecycle Hooks
+  if (!asJson) console.log(`\n${CYAN}${BOLD}🛡️ Lifecycle Hooks Validation:${RESET}`);
+  const hooksDir = path.join(REPO_ROOT, 'hooks');
+  const hooks = fs.readdirSync(hooksDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name)
+    .sort();
+  if (!asJson) {
+    for (const h of hooks) {
+      console.log(`  ${GREEN}✔${RESET} ${h.padEnd(30)}`);
+    }
+  }
+
+  const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+  const totalTokens = Math.round(totalChars / 4);
+  const tokenSavings = Math.round(totalTokens * 0.85);
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      version: VERSION,
+      totalComponents: skillCount + agents.length + hooks.length,
+      progressiveSkillsCount: skillCount,
+      scopedAgentsCount: agents.length,
+      lifecycleHooksCount: hooks.length,
+      totalRunbookTokens: totalTokens,
+      estimatedTokensSavedPerTurn: tokenSavings,
+      latencySeconds: parseFloat(duration),
+      skills: skillsGathered,
+      agents,
+      hooks
+    }, null, 2));
+    return;
+  }
+
+  console.log(`\n${GREEN}${BOLD}✨ Benchmark Summary:${RESET}`);
+  console.log(`  Total Components: ${BOLD}${skillCount + agents.length + hooks.length}${RESET}`);
+  console.log(`  Progressive Skills: ${BOLD}${skillCount}${RESET}`);
+  console.log(`  Total Runbook Tokens: ${BOLD}~${totalTokens.toLocaleString()}${RESET}`);
+  console.log(`  Estimated Tokens Saved / Turn: ${BOLD}~${tokenSavings.toLocaleString()} tokens (>85%)${RESET}`);
+  console.log(`  Diagnostic Latency: ${BOLD}${duration}s${RESET}\n`);
+}
+
+function printCompletion(installMode = false, isDryRun = false, customRc = null) {
+  const script = `
+# Everything Gemini Bash/Zsh completion
+_everything_gemini() {
+  local cur prev commands skills agents hooks plugins
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="doctor list init install status check update sync scaffold new new-skill new-agent add remove test-skill test-all benchmark info show completion validate version help diff export import bundle pack search find audit"
+  skills="agent-evals ai-first-engineering apache-kafka-streams api-craftsman architecture-designer argo-workflows axum-web-service browser-qa-tester cilium-ebpf-networking clickhouse-analytics cloudflare-r2-object-storage cloudflare-workers context-caching continuous-learning database-architect dbt-transformation debezium-cdc devops-pipeline distributed-rate-limiting docker-compose-orchestrator duckdb-local-olap fastapi-production fullstack-nextjs gemini-function-calling gemini-grounding gemini-multimodal git-craftsman github-ops graphql-architect grpc-connect-rpc kubernetes-operator langgraph-orchestrator litellm-proxy-gateway milvus-vector-clustering nats-jetstream open-telemetry-tracing performance-profiler playwright-visual-regression rag-architect redis-cache-patterns repo-onboarding root-cause-debugger security-audit stripe-integration subagent-handoff supabase-architect svelte-kit-architect tdd-workflow temporal-workflows trpc-react-query turborepo-monorepo vault-secrets-management vllm-inference wasm-rust-optimizer antigravity-sdk-orchestrator responsive-design"
+  agents="architect browser-qa build-repair code-reviewer database-migrator documentation-writer incident-responder performance-tuner planner platform-engineer release-engineer security-auditor"
+  hooks="auto-lint-formatter ephemeral-context gemini-shield goal-verifier learned-instincts safety-shield secret-scrubber"
+  plugins="core python-ai security-shield web-fullstack"
+
+  case "\${prev}" in
+    everything-gemini|eagy|egemini)
+      COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+      return 0
+      ;;
+    add|remove|scaffold|new)
+      COMPREPLY=( $(compgen -W "skill agent hook plugin" -- "\${cur}") )
+      return 0
+      ;;
+    skill|test-skill)
+      COMPREPLY=( $(compgen -W "\${skills}" -- "\${cur}") )
+      return 0
+      ;;
+    agent)
+      COMPREPLY=( $(compgen -W "\${agents}" -- "\${cur}") )
+      return 0
+      ;;
+    hook)
+      COMPREPLY=( $(compgen -W "\${hooks}" -- "\${cur}") )
+      return 0
+      ;;
+    plugin)
+      COMPREPLY=( $(compgen -W "\${plugins}" -- "\${cur}") )
+      return 0
+      ;;
+    info|show|search|find|audit)
+      COMPREPLY=( $(compgen -W "\${skills} \${agents} \${hooks} \${plugins}" -- "\${cur}") )
+      return 0
+      ;;
+    --profile)
+      COMPREPLY=( $(compgen -W "core developer full" -- "\${cur}") )
+      return 0
+      ;;
+  esac
+}
+complete -F _everything_gemini everything-gemini egemini eagy
+`.trim();
+
+  if (!installMode) {
+    console.log(script);
+    return;
+  }
+
+  printBanner();
+  console.log(`${BOLD}🐚 Shell Autocompletion Installer${RESET}\n`);
+
+  let targetRc = customRc;
+  if (!targetRc) {
+    const isZsh = (process.env.SHELL && process.env.SHELL.includes('zsh')) || fs.existsSync(path.join(os.homedir(), '.zshrc'));
+    targetRc = isZsh ? path.join(os.homedir(), '.zshrc') : path.join(os.homedir(), '.bashrc');
+  }
+
+  if (fs.existsSync(targetRc)) {
+    const currentContent = fs.readFileSync(targetRc, 'utf8');
+    if (currentContent.includes('_everything_gemini()')) {
+      console.log(`  ${YELLOW}ℹ${RESET} Autocompletion is already configured in ${BOLD}${targetRc}${RESET}`);
+      console.log(`    To reload, run: ${GREEN}source ${targetRc}${RESET}\n`);
+      return;
+    }
+  }
+
+  if (isDryRun) {
+    console.log(`  ${CYAN}[DRY RUN]${RESET} Would append completion script to: ${BOLD}${targetRc}${RESET}\n`);
+    return;
+  }
+
+  const payload = `\n\n# Everything Gemini Autocompletion\n${script}\n`;
+  fs.appendFileSync(targetRc, payload, 'utf8');
+  console.log(`  ${GREEN}✔${RESET} Successfully installed autocompletion into: ${BOLD}${targetRc}${RESET}`);
+  console.log(`\n${GREEN}${BOLD}✨ Ready! Reload your shell with:${RESET}`);
+  console.log(`  ${CYAN}source ${targetRc}${RESET}\n`);
+}
+
+function showComponentInfo(query1, query2) {
+  let target = query1;
+  let explicitType = null;
+  if (['skill', 'agent', 'hook', 'plugin'].includes(query1) && query2) {
+    explicitType = query1;
+    target = query2;
+  }
+  if (!target) {
+    console.error(`\n${RED}Error: Please specify a component name.${RESET}`);
+    console.log(`Usage: everything-gemini info [skill|agent|hook] <name>\n`);
+    process.exit(1);
+  }
+
+  const cleanName = target.trim().toLowerCase().replace(/^(skills|agents|hooks)\//, '');
+
+  // 1. Check Subagents if type is agent or undefined
+  if (!explicitType || explicitType === 'agent') {
+    const agentMd = path.join(REPO_ROOT, 'agents', `${cleanName}.md`);
+    if (fs.existsSync(agentMd)) {
+      printBanner();
+      console.log(`${BOLD}🤖 Subagent Specification: ${CYAN}${cleanName}${RESET}`);
+      console.log(`Path: ${GRAY}${agentMd}${RESET}\n`);
+      const content = fs.readFileSync(agentMd, 'utf8');
+      const lines = content.split('\n').slice(0, 25);
+      console.log(lines.join('\n'));
+      if (content.split('\n').length > 25) {
+        console.log(`\n${GRAY}... (${content.split('\n').length - 25} more lines in ${agentMd})${RESET}`);
+      }
+      console.log('');
+      return;
+    }
+  }
+
+  // 2. Check Hooks if type is hook or undefined
+  if (!explicitType || explicitType === 'hook') {
+    const hookDir = path.join(REPO_ROOT, 'hooks', cleanName);
+    const hookJson = path.join(hookDir, 'hooks.json');
+    if (fs.existsSync(hookJson)) {
+      printBanner();
+      console.log(`${BOLD}🛡️ Lifecycle Hook: ${CYAN}${cleanName}${RESET}`);
+      console.log(`Directory: ${GRAY}${hookDir}${RESET}\n`);
+      try {
+        const parsed = JSON.parse(fs.readFileSync(hookJson, 'utf8'));
+        console.log(`${BOLD}Configuration (hooks.json):${RESET}`);
+        console.log(JSON.stringify(parsed, null, 2));
+      } catch (e) {
+        console.log(fs.readFileSync(hookJson, 'utf8'));
+      }
+      const scriptsDir = path.join(hookDir, 'scripts');
+      if (fs.existsSync(scriptsDir)) {
+        const scripts = fs.readdirSync(scriptsDir);
+        console.log(`\n${BOLD}Hook Scripts:${RESET}`);
+        scripts.forEach(s => console.log(`  🔧 scripts/${s}`));
+      }
+      console.log('');
+      return;
+    }
+  }
+
+  // 3. Check Skills (Core or Plugin)
   let skillDir = path.join(REPO_ROOT, 'skills', cleanName);
   let pluginName = null;
 
@@ -683,39 +2164,40 @@ function showSkillInfo(skillName) {
   }
 
   const skillMd = path.join(skillDir, 'SKILL.md');
-  if (!fs.existsSync(skillMd)) {
-    console.error(`\n${RED}Error: Skill '${cleanName}' not found in catalog.${RESET}\n`);
-    process.exit(1);
-  }
-
-  printBanner();
-  console.log(`${BOLD}📖 Skill Overview: ${CYAN}${cleanName}${RESET}`);
-  if (pluginName) {
-    console.log(`Source Plugin: ${YELLOW}${pluginName}${RESET}`);
-  }
-  console.log(`Path: ${GRAY}${skillMd}${RESET}\n`);
-
-  const content = fs.readFileSync(skillMd, 'utf8');
-  const parts = content.split('---');
-  if (parts.length >= 3) {
-    const frontmatter = parts[1];
-    const descMatch = frontmatter.match(/description:\s*>?-?\s*([^\n\r]+)/);
-    if (descMatch) {
-      console.log(`${BOLD}🎯 Trigger Description:${RESET}`);
-      console.log(`  ${descMatch[1].trim()}\n`);
+  if (fs.existsSync(skillMd)) {
+    printBanner();
+    console.log(`${BOLD}📖 Skill Overview: ${CYAN}${cleanName}${RESET}`);
+    if (pluginName) {
+      console.log(`Source Plugin: ${YELLOW}${pluginName}${RESET}`);
     }
+    console.log(`Path: ${GRAY}${skillMd}${RESET}\n`);
+
+    const content = fs.readFileSync(skillMd, 'utf8');
+    const parts = content.split('---');
+    if (parts.length >= 3) {
+      const frontmatter = parts[1];
+      const descMatch = frontmatter.match(/description:\s*>?-?\s*([^\n\r]+)/);
+      if (descMatch) {
+        console.log(`${BOLD}🎯 Trigger Description:${RESET}`);
+        console.log(`  ${descMatch[1].trim()}\n`);
+      }
 
-    const body = parts.slice(2).join('---').trim();
-    const lines = body.split('\n').slice(0, 22);
-    console.log(`${BOLD}📋 Playbook Preview:${RESET}`);
-    console.log(lines.join('\n'));
-    if (body.split('\n').length > 22) {
-      console.log(`\n${GRAY}... (${body.split('\n').length - 22} more lines in ${skillMd})${RESET}`);
+      const body = parts.slice(2).join('---').trim();
+      const lines = body.split('\n').slice(0, 22);
+      console.log(`${BOLD}📋 Playbook Preview:${RESET}`);
+      console.log(lines.join('\n'));
+      if (body.split('\n').length > 22) {
+        console.log(`\n${GRAY}... (${body.split('\n').length - 22} more lines in ${skillMd})${RESET}`);
+      }
+    } else {
+      console.log(content.split('\n').slice(0, 25).join('\n'));
     }
-  } else {
-    console.log(content.split('\n').slice(0, 25).join('\n'));
+    console.log('');
+    return;
   }
-  console.log('');
+
+  console.error(`\n${RED}Error: Component '${cleanName}' not found in catalog (checked skills, agents, and hooks).${RESET}\n`);
+  process.exit(1);
 }
 
 // CLI Argument Parsing
@@ -729,41 +2211,208 @@ switch (command) {
   case 'list':
     listComponents();
     break;
+  case 'scaffold':
+  case 'new':
+  case 'create': {
+    const type = args[1];
+    const name = args[2];
+    let customTarget = null;
+    let isDryRun = false;
+    let asJson = false;
+    for (let i = 3; i < args.length; i++) {
+      if (args[i] === '--dry-run') isDryRun = true;
+      else if (args[i] === '--json') asJson = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    runScaffold(type, name, customTarget, isDryRun, asJson);
+    break;
+  }
+  case 'sync': {
+    let isGlobal = false;
+    let customTarget = null;
+    let isDryRun = false;
+    let asJson = false;
+    let force = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--dry-run') isDryRun = true;
+      else if (args[i] === '--json') asJson = true;
+      else if (args[i] === '--force') force = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+      else if (!args[i].startsWith('-') && !customTarget) customTarget = args[i];
+    }
+    runSync(customTarget, isGlobal, isDryRun, asJson, force);
+    break;
+  }
   case 'new-skill':
     scaffoldSkill(args[1]);
     break;
   case 'new-agent':
     scaffoldAgent(args[1]);
     break;
-  case 'add':
-    addComponent(args[1], args[2]);
+  case 'add': {
+    let customTarget = null;
+    let isGlobal = false;
+    for (let i = 3; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    addComponent(args[1], args[2], isGlobal, customTarget);
     break;
-  case 'remove':
-    removeComponent(args[1], args[2]);
+  }
+  case 'remove': {
+    let customTarget = null;
+    let isGlobal = false;
+    for (let i = 3; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    removeComponent(args[1], args[2], isGlobal, customTarget);
     break;
+  }
   case 'test-skill':
     testSkill(args[1]);
     break;
+  case 'test-all':
+  case 'test-skills':
+  case 'benchmark': {
+    const asJson = args.includes('--json');
+    testAllSkills(asJson);
+    break;
+  }
+  case 'completion': {
+    const installMode = args.includes('--install') || args.includes('-i');
+    const isDryRun = args.includes('--dry-run');
+    let customRc = null;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--rc' && args[i + 1]) customRc = args[++i];
+    }
+    printCompletion(installMode, isDryRun, customRc);
+    break;
+  }
   case 'info':
   case 'show':
-    showSkillInfo(args[1]);
+    showComponentInfo(args[1], args[2]);
+    break;
+  case 'status':
+  case 'check': {
+    let isGlobal = false;
+    let customTarget = null;
+    let asJson = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--json') asJson = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    runStatus(isGlobal, customTarget, asJson);
     break;
+  }
+  case 'diff': {
+    let isGlobal = false;
+    let customTarget = null;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    runDiff(isGlobal, customTarget);
+    break;
+  }
+  case 'export': {
+    let isGlobal = false;
+    let customTarget = null;
+    let outputPath = null;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+      else if ((args[i] === '--output' || args[i] === '-o') && args[i + 1]) outputPath = args[++i];
+    }
+    runExport(isGlobal, customTarget, outputPath);
+    break;
+  }
+  case 'import': {
+    const inputFile = args[1] && !args[1].startsWith('-') ? args[1] : null;
+    let isGlobal = false;
+    let customTarget = null;
+    let isDryRun = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--dry-run') isDryRun = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    runImport(inputFile, isGlobal, customTarget, isDryRun);
+    break;
+  }
+  case 'bundle':
+  case 'pack': {
+    let profile = 'all';
+    let outputDir = null;
+    let isDryRun = false;
+    let asJson = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--profile' && args[i + 1]) profile = args[++i];
+      else if ((args[i] === '--output' || args[i] === '-o') && args[i + 1]) outputDir = args[++i];
+      else if (args[i] === '--dry-run') isDryRun = true;
+      else if (args[i] === '--json') asJson = true;
+      else if (!args[i].startsWith('-') && !outputDir) outputDir = args[i];
+    }
+    runBundle(profile, outputDir, isDryRun, asJson);
+    break;
+  }
+  case 'update': {
+    let isGlobal = false;
+    let customTarget = null;
+    let isDryRun = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--dry-run') isDryRun = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+    }
+    runUpdate(isGlobal, customTarget, isDryRun);
+    break;
+  }
   case 'init':
   case 'install': {
     let profile = 'developer';
     let isGlobal = false;
     let customTarget = null;
+    let isDryRun = false;
     for (let i = 1; i < args.length; i++) {
       if (args[i] === '--profile' && args[i + 1]) profile = args[++i];
       else if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--dry-run') isDryRun = true;
       else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
     }
-    installProfile(profile, isGlobal, customTarget);
+    installProfile(profile, isGlobal, customTarget, isDryRun);
     break;
   }
   case 'validate':
     runValidate();
     break;
+  case 'search':
+  case 'find': {
+    const asJson = args.includes('--json');
+    const queryTerms = args.slice(1).filter(a => !a.startsWith('-')).join(' ');
+    searchComponents(queryTerms, asJson);
+    break;
+  }
+  case 'audit': {
+    let isGlobal = false;
+    let customTarget = null;
+    let asJson = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--global') isGlobal = true;
+      else if (args[i] === '--json') asJson = true;
+      else if (args[i] === '--workspace' && args[i + 1]) customTarget = args[++i];
+      else if (!args[i].startsWith('-') && !customTarget) customTarget = args[i];
+    }
+    runAudit(customTarget, isGlobal, asJson);
+    break;
+  }
+  case 'version':
+  case '--version':
+  case '-v':
+    console.log(VERSION);
+    break;
   case 'help':
   case '--help':
   case '-h':