@luquimbo/bi-superpowers 4.1.2 → 4.1.4

package/bin/cli.js

@@ -11,9 +11,9 @@
  * Architecture:
  * - Skills are authored once in src/content/skills/ and copied out to
  *   each supported agent by `super install`.
- * - `super kickoff` generates a full Claude Code plugin tree in a
+ * - `super kickoff` optionally generates a local Claude Code plugin tree in a
  *   user project (skills + commands + MCP config).
- * - `super recharge` regenerates that plugin after local edits.
+ * - `super recharge` regenerates an existing local Claude Code plugin after edits.
  *
  * Supported agents: Claude Code, GitHub Copilot, Codex, Gemini CLI, Kilo Code.
  * License: MIT. This project is fully open source — no activation, no keys.
@@ -28,34 +28,6 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { loadSkills } = require('./lib/skills');
 
-// Background update check. update-notifier spawns a detached child process
-// that fetches the latest version from npm and caches it; the banner that
-// `notify()` schedules is printed at process exit, so this is zero-latency
-// on the command path. Errors are swallowed silently — the CLI must not
-// break because of a failed update check.
-let _updateNotifierNotify = null;
-try {
-  const updateNotifier = require('update-notifier');
-  const pkg = require('../package.json');
-  const notifier = updateNotifier({
-    pkg,
-    updateCheckInterval: 1000 * 60 * 60 * 24, // 24h
-    shouldNotifyInNpmScript: false,
-  });
-  _updateNotifierNotify = () =>
-    notifier.notify({
-      defer: true,
-      isGlobal: true,
-      message:
-        'Update available {currentVersion} → {latestVersion}\n' +
-        'Run {updateCommand} to update,\n' +
-        'then refresh your install path (`/plugin update bi-superpowers`, `super install --yes`, or run `super recharge` inside each repo where you used `super kickoff`).',
-    });
-} catch (_) {
-  // update-notifier not available during npm install phase, or network
-  // probe failed — skip silently.
-}
-
 // Optional lib import — may not be available during npm install phase.
 let generators;
 try {
@@ -160,14 +132,6 @@ function main() {
   const args = process.argv.slice(2);
   const command = args[0] || 'help';
 
-  // Schedule the update-notifier banner to print at process exit. Only fire
-  // for "normal" commands — skipping machine-readable and ultra-hot paths so
-  // tools that parse super output don't get surprised by the banner.
-  const SKIP_NOTIFY_COMMANDS = new Set(['version', 'help', 'about', 'info']);
-  if (_updateNotifierNotify && !SKIP_NOTIFY_COMMANDS.has(command)) {
-    _updateNotifierNotify();
-  }
-
   if (commands[command]) {
     commands[command](args.slice(1));
   } else {
@@ -186,18 +150,18 @@ Open-source toolkit for Power BI Desktop development across 5 AI coding agents:
 Claude Code · GitHub Copilot · Codex · Gemini CLI · Kilo Code.
 
 Quick Start:
-  super install              # Install skills + MCPs for all your AI agents
-  super kickoff              # Generate the Claude Code plugin in a project
+  super install --all --yes  # Install skills + MCPs user-level for all agents
+  super powers               # List the skills and MCPs available
 
 Usage:
   super <command> [options]
 
 Primary commands:
-  install           Install the 4 skills + 2 MCPs across your AI agents
-  kickoff [path]    Generate the full Claude Code plugin in a project
-  recharge [path]   Regenerate the plugin after editing source skills
+  install           Install the 4 skills + 2 MCPs user-level across your AI agents
+  kickoff [path]    Optional: generate a repo-local Claude Code plugin
+  recharge [path]   Optional: regenerate an existing repo-local Claude Code plugin
   build-desktop     Build the .mcpb extension for Claude Desktop
-  mcp-setup         Configure the official Microsoft MCP servers
+  mcp-setup         Refresh MCP config for an existing Claude Code local plugin
   powers            List available skills and MCPs
   upgrade           Update to the latest version on npm
   about             Show installation info
@@ -214,13 +178,14 @@ Options:
 Examples:
   super install                    # Interactive installer for all agents
   super install --all --yes        # Non-interactive install for every agent
+  super install -a codex           # Install user-level skills + MCPs for Codex
   super install -a claude-code     # Install only for Claude Code
-  super kickoff                    # Initialize plugin in current directory
-  super kickoff ./my-project       # Initialize in a specific directory
-  super kickoff --dry-run          # Preview what would be created
-  super recharge                   # Regenerate plugin after editing skills
+  super kickoff                    # Claude Code only: create local plugin files
+  super kickoff ./my-project       # Claude Code only: initialize in a repo
+  super kickoff --dry-run          # Preview local Claude Code plugin files
+  super recharge                   # Regenerate existing local Claude Code plugin
   super build-desktop              # Build .mcpb for Claude Desktop
-  super mcp-setup                  # Configure the local Power BI Modeling MCP
+  super mcp-setup                  # Existing local Claude Code plugin only
 
 Open source — MIT licensed.
 Documentation: https://github.com/luquimbo/bi-superpowers
@@ -293,7 +258,7 @@ function parseSkillMetadata(content) {
 // ============================================
 
 /**
- * `super kickoff` — generate the Claude Code plugin in the target directory.
+ * `super kickoff` — generate an optional local Claude Code plugin in the target directory.
  *
  * What it does:
  *  1. Generates .claude-plugin/, .mcp.json, commands/, skills/ in the target.
@@ -314,10 +279,17 @@ async function initProject(args) {
   console.log(`
 BI Agent Superpowers v${VERSION}
 ================================
-Claude Code Plugin Setup
+Claude Code local plugin setup
 
 Initializing in: ${targetDir}
 Skills available: ${skills.length}
+
+This is not the multi-agent install path. For Codex, GitHub Copilot,
+Gemini CLI, Kilo Code, and user-level Claude Code installs, run:
+
+  super install --all --yes
+
+kickoff writes repo-local Claude Code plugin files only.
 `);
 
   if (dryRun) {
@@ -359,7 +331,7 @@ Skills available: ${skills.length}
 }
 
 /**
- * `super recharge` — regenerate the Claude Code plugin without prompts.
+ * `super recharge` — regenerate an existing local Claude Code plugin without prompts.
  *
  * Re-reads the saved tool preferences from .bi-superpowers.json (or falls
  * back to the default toolset) and regenerates everything. Useful after:
@@ -393,6 +365,23 @@ Regenerating configs from ${skills.length} skills...
     }
   }
 
+  if (!hasProjectLocalPlugin(targetDir)) {
+    console.log(`
+This repo does not contain a local Claude Code plugin generated by super kickoff.
+
+For Codex, GitHub Copilot, Gemini CLI, Kilo Code, and user-level Claude Code
+installs, refresh the user-level install instead:
+
+  super install --all --yes
+
+If you intentionally want repo-local Claude Code plugin files, run:
+
+  super kickoff
+`);
+    process.exitCode = 2;
+    return;
+  }
+
   const config = loadToolConfig(targetDir);
   const selectedTools = ensurePluginTool(config.tools || [...DEFAULT_TOOLS]);
 
@@ -544,6 +533,13 @@ function loadToolConfig(targetDir) {
   };
 }
 
+function hasProjectLocalPlugin(targetDir) {
+  return (
+    fs.existsSync(path.join(targetDir, CONFIG_FILE)) ||
+    fs.existsSync(path.join(targetDir, '.claude-plugin', 'plugin.json'))
+  );
+}
+
 /**
  * Dispatch to the tool-specific generator.
  */
@@ -561,6 +557,10 @@ function showCompletionMessage(targetDir, tools, skillCount) {
 
   Skills:     ${skillCount} skills generated
 
+  Note: this is a repo-local Claude Code plugin only.
+  Codex, GitHub Copilot, Gemini CLI, Kilo Code, and user-level Claude Code
+  installs use: super install --all --yes
+
 ────────────────────────────────────────────────────────────
   CLAUDE CODE
 ────────────────────────────────────────────────────────────
@@ -783,19 +783,32 @@ function runWatch(args) {
     process.exit(1);
   }
 
-  const cliModule = {
-    syncProjectInternal: (targetDir, tools) => {
-      const skills = getSkillFiles();
+  watchCommand(args, getCommandConfig(), createWatchCliModule());
+}
+
+/**
+ * Build the tiny adapter used by `super sentinel`.
+ * It intentionally delegates through generateForTool(), the same path as
+ * kickoff/recharge, so regenerated plugin files keep the real package version,
+ * library prefix, and MCP launcher mode.
+ *
+ * @param {Object} [deps] - Test seams
+ * @param {Function} [deps.getSkillFilesFn] - Skill loader
+ * @param {Function} [deps.generateForToolFn] - Tool generator
+ * @returns {{syncProjectInternal: Function}} Watch command adapter
+ */
+function createWatchCliModule(deps = {}) {
+  const getSkillFilesFn = deps.getSkillFilesFn || getSkillFiles;
+  const generateForToolFn = deps.generateForToolFn || generateForTool;
+
+  return {
+    syncProjectInternal: async (targetDir, tools) => {
+      const skills = getSkillFilesFn();
       for (const tool of tools) {
-        const cfg = AI_TOOLS[tool];
-        if (cfg && cfg.generate) {
-          cfg.generate(targetDir, skills, { packageDir: PACKAGE_DIR });
-        }
+        await generateForToolFn(tool, targetDir, skills);
       }
     },
   };
-
-  watchCommand(args, getCommandConfig(), cliModule);
 }
 
 /**
@@ -823,6 +836,8 @@ module.exports = {
   getUpgradeCommand,
   getUpgradeRefreshSteps,
   resetUpdateCheckStateAfterUpgrade,
+  createWatchCliModule,
+  getGenerationOptions,
   AI_TOOLS,
   SKILLS_DIR,
   VERSION,

package/bin/commands/build-desktop.js

@@ -30,10 +30,10 @@ const DESKTOP_TEMPLATE_DIR = path.join(PACKAGE_DIR, 'desktop-extension');
  * Bundle skills into the Desktop extension's skills/ directory.
  *
  * Handles both flat `src/content/skills/<name>.md` and folder-based
- * `src/content/skills/<name>/SKILL.md` layouts by flattening each skill
- * to a single `<name>.md` file inside `skillsOutDir`. The Claude Desktop
- * MCP server loads those flat files as prompts — `references/` and
- * `scripts/` are distributed through `super install`, not bundled here.
+ * `src/content/skills/<name>/SKILL.md` layouts by writing each skill as
+ * `<name>/SKILL.md`. Folder-based skills also get their runtime
+ * `references/` and `scripts/` subtrees copied into the MCPB, so prompts
+ * never point Claude Desktop at files missing from the installed extension.
  *
  * @param {string} skillsOutDir - Destination directory (created if missing)
  * @param {string} packageDir - npm package root containing src/content/skills/
@@ -43,11 +43,63 @@ function bundleSkills(skillsOutDir, packageDir) {
   fs.mkdirSync(skillsOutDir, { recursive: true });
   const skills = loadSkills({ packageDir });
   for (const skill of skills) {
-    fs.writeFileSync(path.join(skillsOutDir, `${skill.name}.md`), skill.content);
+    const skillOutDir = path.join(skillsOutDir, skill.name);
+    fs.mkdirSync(skillOutDir, { recursive: true });
+    fs.writeFileSync(path.join(skillOutDir, 'SKILL.md'), skill.content);
+
+    if (skill.bundleDir) {
+      copyRuntimeTree(
+        path.join(skill.bundleDir, 'references'),
+        path.join(skillOutDir, 'references')
+      );
+      copyRuntimeTree(path.join(skill.bundleDir, 'scripts'), path.join(skillOutDir, 'scripts'));
+    }
   }
   return skills.map((s) => s.name);
 }
 
+/**
+ * Copy runtime skill assets, excluding test/build/editor artifacts.
+ *
+ * @param {string} source - Source file or directory
+ * @param {string} target - Destination file or directory
+ */
+function copyRuntimeTree(source, target) {
+  if (!fs.existsSync(source)) {
+    return;
+  }
+
+  const stat = fs.statSync(source);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(target, { recursive: true });
+    for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+      copyRuntimeTree(path.join(source, entry.name), path.join(target, entry.name));
+    }
+    return;
+  }
+
+  if (!stat.isFile() || shouldSkipRuntimeFile(source)) {
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.copyFileSync(source, target);
+}
+
+/**
+ * @param {string} filePath - Runtime asset path
+ * @returns {boolean} True if this file should not ship in the MCPB
+ */
+function shouldSkipRuntimeFile(filePath) {
+  const base = path.basename(filePath);
+  return (
+    base.endsWith('.test.js') ||
+    base.endsWith('.spec.js') ||
+    base.endsWith('.bak') ||
+    base.endsWith('.tmp')
+  );
+}
+
 /**
  * Build the .mcpb extension for Claude Desktop.
  *
@@ -94,7 +146,7 @@ BI Agent Superpowers — Build Desktop Extension
 
     // Bundle every skill (flat + folder-based) into temp/skills/
     const bundledNames = bundleSkills(path.join(tmpDir, 'skills'), PACKAGE_DIR);
-    const skillFiles = bundledNames.map((n) => `${n}.md`);
+    const skillFiles = bundledNames.map((n) => `${n}/SKILL.md`);
     console.log(`  Bundled ${bundledNames.length} skills`);
 
     // Patch template placeholder versions with the real package version
@@ -185,3 +237,5 @@ BI Agent Superpowers — Build Desktop Extension
 
 module.exports = buildDesktop;
 module.exports.bundleSkills = bundleSkills;
+module.exports.copyRuntimeTree = copyRuntimeTree;
+module.exports.shouldSkipRuntimeFile = shouldSkipRuntimeFile;

package/bin/commands/diff.js

@@ -13,6 +13,7 @@ const fs = require('fs');
 const path = require('path');
 const tui = require('../utils/tui');
 const { readSkillDirectory, normalizeSkillName } = require('../lib/skills');
+const { buildCommandMarkdown } = require('../lib/generators/claude-plugin');
 
 /**
  * Generate a simple diff between two strings
@@ -113,6 +114,71 @@ function compareFiles(skillPath, generatedPath) {
   };
 }
 
+/**
+ * Compare a loaded skill against the content that should have been generated
+ * for a specific tool. This avoids false drift from generator-owned wrappers
+ * such as Claude command frontmatter, generated comments, and update-check
+ * preambles.
+ *
+ * @param {{name: string, path: string, content: string}} skill - Loaded source skill
+ * @param {string} generatedPath - Path to generated file
+ * @param {Object} [options] - Comparison options
+ * @param {string} [options.tool] - Tool id
+ * @param {string} [options.libraryPrefix] - Library prefix used by the generator
+ * @returns {Object} Comparison result
+ */
+function compareSkillToGenerated(skill, generatedPath, options = {}) {
+  if (!skill || !fs.existsSync(skill.path)) {
+    return {
+      skill: skill && skill.name ? skill.name : 'unknown',
+      status: 'missing-source',
+      message: 'Source skill file not found',
+    };
+  }
+
+  if (!fs.existsSync(generatedPath)) {
+    return {
+      skill: skill.name,
+      status: 'not-generated',
+      message: 'Generated file does not exist (will be created on sync)',
+    };
+  }
+
+  const generatedContent = fs.readFileSync(generatedPath, 'utf8');
+  const expectedContent = buildExpectedGeneratedContent(skill, options);
+
+  if (expectedContent === generatedContent) {
+    return {
+      skill: skill.name,
+      status: 'unchanged',
+      message: 'No changes',
+    };
+  }
+
+  const diff = generateDiff(generatedContent, expectedContent);
+
+  return {
+    skill: skill.name,
+    status: 'changed',
+    diff,
+    sourcePath: skill.path,
+    generatedPath,
+  };
+}
+
+/**
+ * @param {{name: string, content: string}} skill - Loaded source skill
+ * @param {Object} options - Comparison options
+ * @returns {string} Expected generated output for the scan target
+ */
+function buildExpectedGeneratedContent(skill, options = {}) {
+  if (options.tool === 'claude-code') {
+    return buildCommandMarkdown(skill, options.libraryPrefix || 'library');
+  }
+
+  return skill.content;
+}
+
 /**
  * Get generated file path for a skill based on tool
  * @param {string} skillName - Skill name (without .md)
@@ -291,6 +357,7 @@ function diffCommand(args, config) {
   // and `path.basename(...)` would return `SKILL`, breaking the diff.
   const results = skillFiles.map((skillPath) => {
     const skillName = skillNameByPath.get(skillPath) || path.basename(skillPath, '.md');
+    const skill = skillsByName.get(skillName);
     const generatedPath = getGeneratedPath(skillName, options.tool, targetDir);
 
     if (!generatedPath) {
@@ -301,7 +368,10 @@ function diffCommand(args, config) {
       };
     }
 
-    return compareFiles(skillPath, generatedPath);
+    return compareSkillToGenerated(skill, generatedPath, {
+      tool: options.tool,
+      libraryPrefix: getLibraryPrefix(targetDir, config.packageDir),
+    });
   });
 
   // Display results
@@ -340,6 +410,21 @@ function diffCommand(args, config) {
 module.exports = Object.assign(diffCommand, {
   generateDiff,
   compareFiles,
+  compareSkillToGenerated,
+  buildExpectedGeneratedContent,
   getGeneratedPath,
   parseArgs,
 });
+
+/**
+ * Match the Claude plugin generator's library reference behavior.
+ *
+ * @param {string} targetDir - Target project directory
+ * @param {string} packageDir - Package root
+ * @returns {string} Library prefix used in generated markdown
+ */
+function getLibraryPrefix(targetDir, packageDir) {
+  return fs.existsSync(path.join(targetDir, 'library'))
+    ? 'library'
+    : path.join(packageDir, 'library');
+}

package/bin/commands/mcp-setup.js

@@ -1,8 +1,8 @@
 /**
  * MCP Setup Command
  * =================
- * Configures the official Microsoft MCP servers for the Claude Code plugin
- * and legacy adapter formats.
+ * Configures the official Microsoft MCP servers for an existing project-local
+ * Claude Code plugin and legacy adapter formats.
  *
  * Usage:
  *   super mcp-setup
@@ -103,6 +103,13 @@ function loadConfiguredTools(targetDir) {
   return ['claude-plugin'];
 }
 
+function hasLocalPluginMarker(targetDir) {
+  return (
+    fs.existsSync(path.join(targetDir, '.bi-superpowers.json')) ||
+    fs.existsSync(path.join(targetDir, '.claude-plugin', 'plugin.json'))
+  );
+}
+
 function readJson(filePath) {
   if (!fs.existsSync(filePath)) {
     return {};
@@ -157,8 +164,24 @@ function mcpSetupCommand(args, config) {
 
   if (options.deprecatedFlags.length > 0) {
     tui.warning(
-      `Deprecated flags ignored: ${options.deprecatedFlags.join(', ')}. MCP setup is now plugin-first and uses the official Microsoft servers.`
+      `Deprecated flags ignored: ${options.deprecatedFlags.join(', ')}. MCP setup now targets local Claude Code plugin configs and uses the official Microsoft servers.`
+    );
+  }
+
+  if (!options.tool && !hasLocalPluginMarker(targetDir)) {
+    tui.warning('mcp-setup is only for project-local Claude Code plugin configs.');
+    tui.info(
+      'For Codex, GitHub Copilot, Gemini CLI, Kilo Code, and Claude Code user-level installs, run:'
+    );
+    tui.listItem('super install --all --yes');
+    tui.info(
+      'That writes user-level skills and MCP config under your home directory without creating files in this repo.'
+    );
+    tui.info(
+      'If you intentionally need a local Claude Code plugin, run `super kickoff` first or pass `--tool claude-plugin`.'
     );
+    process.exitCode = 2;
+    return;
   }
 
   let configuredTools = loadConfiguredTools(targetDir);

package/bin/commands/watch.js

@@ -48,6 +48,42 @@ function parseArgs(args) {
   return options;
 }
 
+/**
+ * Chokidar v4 no longer supports glob paths. Watch the skill root and filter
+ * relevant runtime/source files in-process so folder-based skills are covered.
+ *
+ * @param {string} skillsDir - Directory containing skill sources
+ * @returns {string[]} Watch roots
+ */
+function getWatchRoots(skillsDir) {
+  return [skillsDir];
+}
+
+/**
+ * @param {string} changedPath - Changed file path
+ * @param {string} skillsDir - Watched skill root
+ * @returns {boolean} Whether the changed file should trigger regeneration
+ */
+function isRelevantSkillPath(changedPath, skillsDir) {
+  const relative = path.relative(skillsDir, changedPath);
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+    return false;
+  }
+
+  const base = path.basename(changedPath);
+  if (
+    base.endsWith('.test.js') ||
+    base.endsWith('.spec.js') ||
+    base.endsWith('.bak') ||
+    base.endsWith('.tmp') ||
+    base.startsWith('.')
+  ) {
+    return false;
+  }
+
+  return ['.md', '.js', '.json', '.sh'].includes(path.extname(changedPath));
+}
+
 /**
  * Main watch command handler
  * @param {string[]} args - Command arguments
@@ -91,7 +127,7 @@ function watchCommand(args, config, cliModule) {
   const pendingChanges = new Set();
 
   // Create watcher
-  const watcher = chokidar.watch(path.join(skillsDir, '*.md'), {
+  const watcher = chokidar.watch(getWatchRoots(skillsDir), {
     persistent: true,
     ignoreInitial: true,
     awaitWriteFinish: {
@@ -106,7 +142,11 @@ function watchCommand(args, config, cliModule) {
    * @param {string} eventType - Type of event (add, change, unlink)
    */
   function handleChange(changedPath, _eventType) {
-    const filename = path.basename(changedPath);
+    if (!isRelevantSkillPath(changedPath, skillsDir)) {
+      return;
+    }
+
+    const filename = path.relative(skillsDir, changedPath);
     pendingChanges.add(filename);
 
     // Clear existing timer
@@ -157,7 +197,7 @@ function watchCommand(args, config, cliModule) {
  * @param {string|null} specificTool - Specific tool or null for all
  * @param {Object} cliModule - CLI module reference
  */
-function regenerateConfigs(targetDir, specificTool, cliModule) {
+async function regenerateConfigs(targetDir, specificTool, cliModule) {
   const ora = require('ora');
   const spinner = ora('Regenerating configs...').start();
 
@@ -193,7 +233,7 @@ function regenerateConfigs(targetDir, specificTool, cliModule) {
 
     // Call the sync logic from CLI module
     if (cliModule && typeof cliModule.syncProjectInternal === 'function') {
-      cliModule.syncProjectInternal(targetDir, tools);
+      await cliModule.syncProjectInternal(targetDir, tools);
       spinner.succeed(`Regenerated configs for: ${tools.join(', ')}`);
     } else {
       // Fallback: just report what would be done
@@ -205,4 +245,9 @@ function regenerateConfigs(targetDir, specificTool, cliModule) {
   }
 }
 
-module.exports = watchCommand;
+module.exports = Object.assign(watchCommand, {
+  parseArgs,
+  getWatchRoots,
+  isRelevantSkillPath,
+  regenerateConfigs,
+});

package/bin/postinstall.js

@@ -36,7 +36,7 @@ Funciona con los 5 agentes:
   /report-design     — Generá reportes PBIR para Power BI Desktop (Windows)
 
 2 MCP servers:
-  powerbi-modeling   — Conexión local a Power BI Desktop (XMLA)
+  powerbi-modeling-mcp — Conexión local a Power BI Desktop (XMLA)
   microsoft-learn    — Docs de Microsoft Learn en contexto
 
 Documentation: https://github.com/luquimbo/bi-superpowers

package/bin/utils/mcp-detect.js

@@ -188,7 +188,7 @@ function getInstallInstructions() {
           'Ir a Extensions (Ctrl+Shift+X)',
           'Buscar "Power BI Modeling MCP"',
           'Instalar la extensión de Microsoft',
-          'Ejecutar: super mcp-setup',
+          'Ejecutar: super install --all --yes',
         ],
         link: 'https://aka.ms/powerbi-modeling-mcp-vscode',
       },

package/commands/bi-start.md

@@ -55,7 +55,7 @@ Interpret the single-line output:
     ```bash
     super upgrade
     ```
-    After it finishes, remind: _"Si instalaste skills en el perfil del agente, corré `super install --yes`. Si además usás un plugin local generado con `super kickoff`, corré `super recharge` dentro de ese repo."_
+  After it finishes, remind: _"Corré `super install --all --yes` para refrescar la instalación user-level de todos los agentes. Solo si además mantenés un plugin local de Claude Code generado con `super kickoff`, corré `super recharge` dentro de ese repo."_
 
   On `no` — respect it, continue to PHASE 1 silently. The update-state.json already tracks the user's snooze per `update-check.js` semantics.
 
@@ -86,7 +86,7 @@ Do these detections in order:
    ```
    (or equivalent). `$pbiDesktopRunning = true` if present.
 
-4. **MCP configured**: look for `.mcp.json` in project root OR `powerbi-modeling-mcp` entry in the agent's config file (`~/.claude.json`, `~/.codex/config.toml`, etc). Keep the check shallow — no need to deep-diff.
+4. **MCP configured**: look first for `powerbi-modeling-mcp` in the agent's user-level config file (`~/.claude.json`, `~/.codex/config.toml`, etc). Only check project-root `.mcp.json` when the user explicitly says they use a local Claude Code plugin. Keep the check shallow — no need to deep-diff.
 
 ### Emit the context in 3-4 lines max
 
@@ -180,7 +180,7 @@ Stop. Don't hover. The user will tell you what they want next.
 - **Project analysis or setup**: that's `/project-kickoff`. If the user says "analizar mi proyecto", "armar el modelo base", "arrancar uno nuevo desde cero", delegate.
 - **MCP wiring details**: that's `/pbi-connect`. bi-start just offers to dispatch it; the actual configuration work is in that skill.
 - **Report authoring**: that's `/report-design`. Same pattern.
-- **Running the update**: bi-start offers + dispatches `super upgrade`; the actual refresh path after eso (`/plugin update bi-superpowers`, `super install --yes`, o `super recharge`) is owned by `/bin/cli.js`.
+- **Running the update**: bi-start offers + dispatches `super upgrade`; the actual refresh path after eso (`/plugin update bi-superpowers`, `super install --all --yes`, o `super recharge` only for local Claude Code plugins) is owned by `/bin/cli.js`.
 
 ## Related Skills