sinapse-ai 1.25.3 → 1.27.0

package/bin/commands/install.js

@@ -50,6 +50,10 @@ const {
 } = require('../lib/command-generator');
 const { deliverGlobalProviderAdapters, getGlobalCommandStagingDir } = require('../lib/global-provider-adapters');
 const { assertProviderAdapterParity } = require('../lib/provider-parity');
+const {
+  copyReactBitsCapabilitySync,
+  REACT_BITS_SKILL_RELATIVE_PATH,
+} = require('../../packages/installer/src/installer/react-bits-corpus');
 // Follow-up #13 — wire the transactional backup/rollback engine into the
 // installer so an in-place UPGRADE (upsert) that fails mid-flight is restored
 // to its previous state instead of leaving ~/.sinapse half-updated.
@@ -130,17 +134,18 @@ async function cmdInstallGlobal(opts = {}) {
 
   // LLM selection (skipped in upsert mode if previous llm known)
   // Story 10.35: --reconfigure forces prompt even in upsert mode
-  let llmChoice;
-  let llmWasReused = false;
-  if (requestedLlm) {
-    llmChoice = requestedLlm;
-  } else if (isUpsert && !reconfigure && existing.llm) {
-    llmChoice = existing.llm;
-    llmWasReused = true;
+  const llmChoice = await resolveLlmChoice({
+    requestedLlm,
+    isUpsert,
+    reconfigure,
+    existingLlm: existing.llm,
+  });
+  const llmWasReused = Boolean(isUpsert && !reconfigure && !requestedLlm && existing.llm);
+  if (llmWasReused) {
     const ideLabel = Array.isArray(llmChoice) ? llmChoice.join(', ') : String(llmChoice);
     logger.always(`${DIM}  IDE: ${ideLabel} (from saved config; pass --reconfigure to change)${NC}`);
-  } else {
-    llmChoice = await promptLlmChoice();
+  } else if (!requestedLlm && !reconfigure) {
+    logger.always(`${DIM}  IDE: Claude Code + Codex (padrao; use --llm para limitar)${NC}`);
   }
   if (languageWasReused || llmWasReused) logger.always('');
 
@@ -317,7 +322,12 @@ async function cmdInstallGlobal(opts = {}) {
   // rich, frontmatter'd stubs are always the final word. Idempotent.
   try {
     const commandsDir = getGlobalCommandStagingDir({ llmChoice, sinapseHome: SINAPSE_HOME, claudeCommandsDir: CLAUDE_COMMANDS_DIR });
-    const reconciled = deliverGlobalProviderAdapters({ llmChoice, home: HOME, commandsDir });
+    const reconciled = deliverGlobalProviderAdapters({
+      llmChoice,
+      home: HOME,
+      commandsDir,
+      reactBitsSkillPath: path.join(SINAPSE_HOME, REACT_BITS_SKILL_RELATIVE_PATH),
+    });
     const total = reconciled.claude.length + reconciled.codex.length + reconciled.skills.length;
     if (total) logger.always(`  ${GREEN}OK${NC} Global provider adapters reconciled (${total} artifacts)`);
   } catch (e) {
@@ -373,6 +383,24 @@ async function cmdInstallGlobal(opts = {}) {
   logger.always('');
 }
 
+/**
+ * Resolves provider selection independently of filesystem writes and prompts.
+ * Explicit flags win; existing configured installs remain stable until the
+ * user reconfigures them; fresh or legacy-unconfigured installs use both.
+ */
+async function resolveLlmChoice({
+  requestedLlm = null,
+  isUpsert = false,
+  reconfigure = false,
+  existingLlm = null,
+  prompt = promptLlmChoice,
+} = {}) {
+  if (requestedLlm) return requestedLlm;
+  if (isUpsert && !reconfigure && existingLlm) return existingLlm;
+  if (reconfigure) return prompt();
+  return 'both';
+}
+
 // ── Transactional install helpers (follow-up #13) ────────────────────────────
 
 /**
@@ -557,6 +585,9 @@ function installFatalPhases({ squads, squadsDir, isUpsert, llmChoice, existing,
     logger.always(`  ${GREEN}OK${NC} core development (${coreAgents} agents)`);
   }
 
+  const reactBits = copyReactBitsCapabilitySync(ROOT, SINAPSE_HOME);
+  if (reactBits.files.length) logger.always(`  ${GREEN}OK${NC} React Bits corpus (${reactBits.files.length} files)`);
+
   // Phase 2: Generate agent commands (shared with `update` via command-generator).
   logger.always(`\n${CYAN}Phase 2:${NC} Generating agent commands`);
   const commandStagingDir = getGlobalCommandStagingDir({ llmChoice, sinapseHome: SINAPSE_HOME, claudeCommandsDir: CLAUDE_COMMANDS_DIR });
@@ -570,7 +601,12 @@ function installFatalPhases({ squads, squadsDir, isUpsert, llmChoice, existing,
   logger.always(`  ${GREEN}OK${NC} ${writtenAgents.size} total command files`);
 
   // Phase 2b: Install global agents based on LLM choice
-  const globalAdapters = deliverGlobalProviderAdapters({ llmChoice, home: HOME, commandsDir: commandStagingDir });
+  const globalAdapters = deliverGlobalProviderAdapters({
+    llmChoice,
+    home: HOME,
+    commandsDir: commandStagingDir,
+    reactBitsSkillPath: path.join(SINAPSE_HOME, REACT_BITS_SKILL_RELATIVE_PATH),
+  });
   const activeAgentCount = assertProviderAdapterParity(
     llmChoice,
     globalAdapters,
@@ -854,6 +890,7 @@ function ensurePathWindows() {
 
 module.exports = {
   cmdInstallGlobal,
+  resolveLlmChoice,
   generateCommandMd,
   generateSquadAwareness,
   createLauncher,

package/bin/commands/uninstall.js

@@ -170,7 +170,7 @@ function removeOrqxAgentsFrom(dir) {
   return removeInstalledAgentsFrom(dir);
 }
 
-const MANAGED_GLOBAL_SKILL_IDS = ['snps', 'sinapse', 'snps-orqx', 'sinapse-orqx', 'sinapse-agent'];
+const MANAGED_GLOBAL_SKILL_IDS = ['snps', 'sinapse', 'snps-orqx', 'sinapse-orqx', 'sinapse-agent', 'react-bits-frontend'];
 const MANAGED_GLOBAL_SKILL_MARKER = 'SINAPSE-MANAGED:global-skill';
 
 function removeManagedGlobalSkills(home = HOME, options = {}) {

package/bin/commands/update.js

@@ -27,7 +27,6 @@ const {
   detectExistingInstall,
   detectStaleness,
 } = require('../lib/detection');
-const { promptLlmChoice } = require('../lib/prompts');
 const { generateSquadAwareness } = require('./install');
 const {
   recordInstalledAgents,
@@ -36,6 +35,10 @@ const {
 } = require('./uninstall');
 const { regenerateAgentCommands } = require('../lib/command-generator');
 const { deliverGlobalProviderAdapters, getGlobalCommandStagingDir } = require('../lib/global-provider-adapters');
+const {
+  copyReactBitsCapabilitySync,
+  REACT_BITS_SKILL_RELATIVE_PATH,
+} = require('../../packages/installer/src/installer/react-bits-corpus');
 const { assertProviderAdapterParity } = require('../lib/provider-parity');
 const { execSync } = require('child_process');
 
@@ -118,9 +121,12 @@ async function cmdUpdateGlobal() {
     logger.always('');
   }
 
-  // Story 10.22 — skip LLM prompt when previous llm known. To re-prompt,
-  // run `npx sinapse-ai install --force`.
-  const llmChoice = existing.llm || await promptLlmChoice();
+  // Story 10.22 — preserve the saved provider selection. To choose again,
+  // run `npx sinapse-ai@latest install --reconfigure`.
+  const llmChoice = existing.llm || 'both';
+  if (!existing.llm) {
+    logger.always(`${DIM}  IDE: Claude Code + Codex (padrao para instalacoes legadas sem provider salvo)${NC}`);
+  }
 
   logger.always('');
   logger.always(`${BOLD}Atualizando SINAPSE AI...${NC}\n`);
@@ -164,6 +170,9 @@ async function cmdUpdateGlobal() {
     logger.always(`  ${GREEN}OK${NC} core development`);
   }
 
+  const reactBits = copyReactBitsCapabilitySync(ROOT, SINAPSE_HOME);
+  if (reactBits.files.length) logger.always(`  ${GREEN}OK${NC} React Bits corpus (${reactBits.files.length} files)`);
+
   // Phase 2: Regenerate commands — shared with `install` so `update` produces the
   // SAME complete set (every specialist command + the rich master Imperator stubs),
   // not just the `-orqx` subset it used to write.
@@ -180,7 +189,12 @@ async function cmdUpdateGlobal() {
   logger.always(`  ${GREEN}OK${NC} ${writtenAgents.size} command files (${totalAgents} agents total)`);
 
   // Phase 2b: Install global agents based on LLM choice
-  const globalAdapters = deliverGlobalProviderAdapters({ llmChoice, home: HOME, commandsDir: commandStagingDir });
+  const globalAdapters = deliverGlobalProviderAdapters({
+    llmChoice,
+    home: HOME,
+    commandsDir: commandStagingDir,
+    reactBitsSkillPath: path.join(SINAPSE_HOME, REACT_BITS_SKILL_RELATIVE_PATH),
+  });
   const activeAgentCount = assertProviderAdapterParity(
     llmChoice,
     globalAdapters,

package/bin/lib/detection.js

@@ -82,7 +82,7 @@ function warnNonInteractive() {
   nonInteractiveWarned = true;
   // stderr so it never pollutes stdout consumers (CI logs, pipes).
   process.stderr.write(
-    `${YELLOW}INFO${NC} ambiente nao-interativo detectado, usando defaults pt + claude-code ` +
+    `${YELLOW}INFO${NC} ambiente nao-interativo detectado, usando defaults pt + Claude Code + Codex ` +
     `${DIM}(use --interactive pra forcar prompts)${NC}\n`,
   );
 }

package/bin/lib/global-provider-adapters.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const {
   MASTER_ALIAS_ENTRY_POINTS,
   GLOBAL_PROVIDER_SKILL_IDS,
+  GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS,
   SUPREME_ORCHESTRATOR_ID,
   SUPREME_PUBLIC_ID,
 } = require('./provider-contract');
@@ -102,7 +103,11 @@ function markGlobalAgent(markdown, fileName = '') {
   return `${content.trimEnd()}\n\n<!-- SINAPSE-MANAGED:global-agent -->\n`;
 }
 
-function renderGlobalSkill(skillId) {
+function renderGlobalSkill(skillId, sourceContent = null) {
+  if (skillId === 'react-bits-frontend') {
+    if (!sourceContent) throw new Error('React Bits global skill source is required');
+    return `${String(sourceContent).trimEnd()}\n\n<!-- SINAPSE-MANAGED:global-skill -->\n`;
+  }
   const generic = skillId === 'sinapse-agent';
   return [
     '---',
@@ -264,9 +269,9 @@ function writeGlobalSkillIfManaged(skillPath, content, home = path.dirname(skill
   }
 }
 
-function isValidGlobalSkill(skillId, skillPath) {
+function isValidGlobalSkill(skillId, skillPath, sourceContent = null) {
   const content = readRegularFileNoFollowSync(skillPath, 'utf8');
-  return content !== null && content === renderGlobalSkill(skillId);
+  return content !== null && content === renderGlobalSkill(skillId, sourceContent);
 }
 
 function removeStaleManagedAgents(targetDir, expectedFiles, extension, options = {}) {
@@ -318,7 +323,7 @@ function removeManagedFileWithBinding(home, filePath, beforeDelete) {
   }
 }
 
-function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir, testHooks = {} }) {
+function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir, reactBitsSkillPath, testHooks = {} }) {
   let commandFiles = fs.existsSync(commandsDir)
     ? fs.readdirSync(commandsDir).filter((file) => file.endsWith('.md')).sort()
     : [];
@@ -334,6 +339,13 @@ function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir, testHooks
     skills: [],
     availableSkills: [],
   };
+  let reactBitsSkillContent = null;
+  const providerSkillIds = [...GLOBAL_PROVIDER_SKILL_IDS];
+  if (reactBitsSkillPath) {
+    reactBitsSkillContent = readRegularFileNoFollowSync(reactBitsSkillPath, 'utf8');
+    if (reactBitsSkillContent === null) throw new Error(`React Bits global skill is missing: ${reactBitsSkillPath}`);
+    providerSkillIds.push(...GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS);
+  }
 
   if (llmChoice === 'claude-code' || llmChoice === 'both') {
     const targetDir = path.join(home, '.claude', 'agents');
@@ -345,12 +357,12 @@ function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir, testHooks
       written.claude.push(file);
     }
     const skillsRoot = path.join(home, '.claude', 'skills');
-    for (const skillId of GLOBAL_PROVIDER_SKILL_IDS) {
+    for (const skillId of providerSkillIds) {
       const skillPath = path.join(skillsRoot, skillId, 'SKILL.md');
-      if (writeGlobalSkillIfManaged(skillPath, renderGlobalSkill(skillId), home, { beforePublish: testHooks.beforeSkillPublish })) {
+      if (writeGlobalSkillIfManaged(skillPath, renderGlobalSkill(skillId, reactBitsSkillContent), home, { beforePublish: testHooks.beforeSkillPublish })) {
         written.claudeSkills.push(skillId);
       }
-      if (isValidGlobalSkill(skillId, skillPath)) written.claudeAvailableSkills.push(skillId);
+      if (isValidGlobalSkill(skillId, skillPath, reactBitsSkillContent)) written.claudeAvailableSkills.push(skillId);
     }
   }
   if (llmChoice === 'codex' || llmChoice === 'both') {
@@ -373,13 +385,13 @@ function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir, testHooks
       written.codex.push(tomlName);
     }
     const skillsRoot = path.join(home, '.agents', 'skills');
-    for (const skillId of GLOBAL_PROVIDER_SKILL_IDS) {
+    for (const skillId of providerSkillIds) {
       const skillDir = path.join(skillsRoot, skillId);
       const skillPath = path.join(skillDir, 'SKILL.md');
-      if (writeGlobalSkillIfManaged(skillPath, renderGlobalSkill(skillId), home, { beforePublish: testHooks.beforeSkillPublish })) {
+      if (writeGlobalSkillIfManaged(skillPath, renderGlobalSkill(skillId, reactBitsSkillContent), home, { beforePublish: testHooks.beforeSkillPublish })) {
         written.skills.push(skillId);
       }
-      if (isValidGlobalSkill(skillId, skillPath)) written.availableSkills.push(skillId);
+      if (isValidGlobalSkill(skillId, skillPath, reactBitsSkillContent)) written.availableSkills.push(skillId);
     }
   }
   return written;

package/bin/lib/prompts.js

@@ -15,7 +15,7 @@ async function promptLlmChoice() {
   // check that silently skipped this prompt in Git Bash + Windows.
   if (!detectInteractiveMode()) {
     warnNonInteractive();
-    return 'claude-code';
+    return 'both';
   }
   try {
     const inquirer = require('inquirer');
@@ -24,11 +24,11 @@ async function promptLlmChoice() {
       name: 'llms',
       message: 'Escolha sua LLM (espaco seleciona, enter confirma):',
       choices: [
-        { name: 'Claude Code (Recomendado)', value: 'claude-code', checked: true },
-        { name: 'Codex CLI', value: 'codex' },
+        { name: 'Claude Code', value: 'claude-code', checked: true },
+        { name: 'Codex CLI', value: 'codex', checked: true },
       ],
     }]);
-    if (llms.length === 0) return 'claude-code'; // default if none selected
+    if (llms.length === 0) return 'both'; // default if none selected
     if (llms.length === 2) return 'both';
     return llms[0];
   } catch {
@@ -37,16 +37,16 @@ async function promptLlmChoice() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
       logger.always(`${CYAN}  Escolha sua LLM:${NC}`);
-      logger.always(`    ${GREEN}1${NC}) Claude Code ${DIM}(Recomendado)${NC}`);
+      logger.always(`    ${GREEN}1${NC}) Claude Code`);
       logger.always(`    ${GREEN}2${NC}) Codex CLI`);
-      logger.always(`    ${GREEN}3${NC}) Ambos`);
+      logger.always(`    ${GREEN}3${NC}) Ambos ${DIM}(Recomendado)${NC}`);
       logger.always('');
       rl.question(`  ${BOLD}Opcao [1/2/3]:${NC} `, (answer) => {
         rl.close();
-        const choice = (answer || '1').trim();
+        const choice = (answer || '3').trim();
         if (choice === '2') resolve('codex');
-        else if (choice === '3') resolve('both');
-        else resolve('claude-code');
+        else if (choice === '1') resolve('claude-code');
+        else resolve('both');
       });
     });
   }

package/bin/lib/provider-contract.js

@@ -13,6 +13,7 @@ const GLOBAL_PROVIDER_SKILL_IDS = Object.freeze([
   SUPREME_ORCHESTRATOR_ID,
   'sinapse-agent',
 ]);
+const GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS = Object.freeze(['react-bits-frontend']);
 
 module.exports = {
   CANONICAL_AGENT_COUNT,
@@ -20,4 +21,5 @@ module.exports = {
   SUPREME_PUBLIC_ID,
   MASTER_ALIAS_ENTRY_POINTS,
   GLOBAL_PROVIDER_SKILL_IDS,
+  GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS,
 };

package/bin/lib/provider-parity.js

@@ -3,8 +3,14 @@
 const {
   CANONICAL_AGENT_COUNT,
   GLOBAL_PROVIDER_SKILL_IDS,
+  GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS,
 } = require('./provider-contract');
 
+const REQUIRED_GLOBAL_PROVIDER_SKILL_IDS = Object.freeze([
+  ...GLOBAL_PROVIDER_SKILL_IDS,
+  ...GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS,
+]);
+
 function normalizeCanonicalCatalog(canonicalCatalog, extension) {
   if (!canonicalCatalog || typeof canonicalCatalog === 'number') {
     throw new Error('Provider adapter parity requires the canonical agent ID catalog');
@@ -55,14 +61,14 @@ function assertProviderAdapterParity(llmChoice, adapters, canonicalCatalog) {
   if (llmChoice === 'claude-code' || llmChoice === 'both') {
     problems.push(...describeCatalogDivergence('Claude Code', adapters.claude, claudeCatalog));
     const claudeSkills = new Set(adapters.claudeAvailableSkills || adapters.claudeSkills || []);
-    const missingAliases = GLOBAL_PROVIDER_SKILL_IDS.filter((alias) => !claudeSkills.has(alias));
-    if (missingAliases.length) problems.push(`Claude Code alias skills missing: ${missingAliases.join(', ')}`);
+    const missingSkills = REQUIRED_GLOBAL_PROVIDER_SKILL_IDS.filter((skillId) => !claudeSkills.has(skillId));
+    if (missingSkills.length) problems.push(`Claude Code global skills missing: ${missingSkills.join(', ')}`);
   }
   if (llmChoice === 'codex' || llmChoice === 'both') {
     problems.push(...describeCatalogDivergence('Codex', adapters.codex, codexCatalog));
     const codexSkills = new Set(adapters.availableSkills || adapters.skills || []);
-    const missingAliases = GLOBAL_PROVIDER_SKILL_IDS.filter((alias) => !codexSkills.has(alias));
-    if (missingAliases.length) problems.push(`Codex alias skills missing: ${missingAliases.join(', ')}`);
+    const missingSkills = REQUIRED_GLOBAL_PROVIDER_SKILL_IDS.filter((skillId) => !codexSkills.has(skillId));
+    if (missingSkills.length) problems.push(`Codex global skills missing: ${missingSkills.join(', ')}`);
   }
   if (problems.length) {
     throw new Error(`Provider adapter parity failed (${problems.join('; ')})`);
@@ -70,4 +76,4 @@ function assertProviderAdapterParity(llmChoice, adapters, canonicalCatalog) {
   return claudeCatalog.count;
 }
 
-module.exports = { assertProviderAdapterParity };
+module.exports = { assertProviderAdapterParity, REQUIRED_GLOBAL_PROVIDER_SKILL_IDS };

package/docs/getting-started.md

@@ -4,7 +4,7 @@
 
 ## Pré-requisitos
 
-- **Node.js** ≥ 20 (LTS recomendado)
+- **Node.js** ≥ 18 (Node 22 LTS recomendado)
 - **Claude Code** ou **Codex CLI** instalado
 - **Git** (pra colaboração)
 
@@ -14,7 +14,7 @@
 npx sinapse-ai@latest install
 ```
 
-O wizard detecta seu ambiente, escolhe IDE (Claude Code ou Codex), instala os 17 squads e configura os hooks essenciais automaticamente.
+O wizard detecta seu ambiente e, em instalações novas ou sem provider salvo, instala Claude Code e Codex por padrão, além dos 17 squads e hooks essenciais. Instalações existentes preservam o provider salvo; use `--reconfigure` para alterá-lo. Use `--llm=claude-code` ou `--llm=codex` somente quando quiser limitar a instalação a um provider.
 
 ## Validar setup
 

package/docs/guides/ide-integration.md

@@ -32,7 +32,7 @@ Both providers expose native lifecycle surfaces. Their registration models diffe
 | Measured surface | Claude Code | Codex CLI |
 | --- | --- | --- |
 | Native agents | 172 | 172 |
-| Installed skills | 36 | 37 |
+| Installed skills | 37 | 37 |
 | Registered hooks | 20 native registrations | 9 lifecycle events through the bridge |
 | Activation | `@agent-name` | `$snps` or `$sinapse-agent <id>` |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinapse-ai",
-  "version": "1.25.3",
+  "version": "1.27.0",
   "description": "SINAPSE AI: Framework de orquestracao de IA — 17 squads, 172 agentes especializados",
   "bin": {
     "sinapse": "bin/sinapse.js",

package/packages/installer/src/installer/react-bits-corpus.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const REACT_BITS_CORPUS_RELATIVE_PATH = path.join('docs', 'framework', 'react-bits');
+const REACT_BITS_SKILL_RELATIVE_PATH = path.join('.agents', 'skills', 'react-bits-frontend', 'SKILL.md');
+const REQUIRED_REACT_BITS_CORPUS_FILES = Object.freeze([
+  'animations.md',
+  'audit-findings.md',
+  'backgrounds.md',
+  'catalog-summary.json',
+  'components.md',
+  'implementation-playbook.md',
+  'index.md',
+  'inventory.json',
+  'text-animations.md',
+]);
+
+function isRegularFile(filePath) {
+  try {
+    return fs.lstatSync(filePath).isFile();
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function listFilesRecursively(directory, root = directory) {
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const sourcePath = path.join(directory, entry.name);
+    if (entry.isDirectory()) return listFilesRecursively(sourcePath, root);
+    return isRegularFile(sourcePath) ? [path.relative(root, sourcePath)] : [];
+  });
+}
+
+function getMissingReactBitsCorpusFiles(root) {
+  return REQUIRED_REACT_BITS_CORPUS_FILES.filter((file) => !isRegularFile(
+    path.join(root, REACT_BITS_CORPUS_RELATIVE_PATH, file),
+  ));
+}
+
+/**
+ * Copy only the shipped React Bits corpus. Existing destination-only files are
+ * intentionally left untouched so a project or global installation never
+ * deletes user research alongside the managed corpus.
+ */
+function copyReactBitsCorpusSync(sourceRoot, destinationRoot) {
+  const source = path.join(sourceRoot, REACT_BITS_CORPUS_RELATIVE_PATH);
+  const destination = path.join(destinationRoot, REACT_BITS_CORPUS_RELATIVE_PATH);
+  const missingFiles = getMissingReactBitsCorpusFiles(sourceRoot);
+  if (missingFiles.length > 0) {
+    throw new Error(`Incomplete React Bits corpus source: ${missingFiles.join(', ')}`);
+  }
+  const files = listFilesRecursively(source);
+  for (const relativePath of files) {
+    const target = path.join(destination, relativePath);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(path.join(source, relativePath), target);
+  }
+  return files.map((relativePath) => path.join(REACT_BITS_CORPUS_RELATIVE_PATH, relativePath));
+}
+
+function hasCompleteReactBitsCorpus(root) {
+  return getMissingReactBitsCorpusFiles(root).length === 0;
+}
+
+/** Copy the corpus plus its canonical skill into a global SINAPSE home. */
+function copyReactBitsCapabilitySync(sourceRoot, destinationRoot) {
+  const files = copyReactBitsCorpusSync(sourceRoot, destinationRoot);
+  const sourceSkill = path.join(sourceRoot, REACT_BITS_SKILL_RELATIVE_PATH);
+  const destinationSkill = path.join(destinationRoot, REACT_BITS_SKILL_RELATIVE_PATH);
+  if (!fs.existsSync(sourceSkill)) throw new Error(`Missing React Bits skill: ${sourceSkill}`);
+  fs.mkdirSync(path.dirname(destinationSkill), { recursive: true });
+  fs.copyFileSync(sourceSkill, destinationSkill);
+  return { files, skillPath: destinationSkill };
+}
+
+module.exports = {
+  REACT_BITS_CORPUS_RELATIVE_PATH,
+  REACT_BITS_SKILL_RELATIVE_PATH,
+  REQUIRED_REACT_BITS_CORPUS_FILES,
+  isRegularFile,
+  listFilesRecursively,
+  getMissingReactBitsCorpusFiles,
+  copyReactBitsCorpusSync,
+  copyReactBitsCapabilitySync,
+  hasCompleteReactBitsCorpus,
+};

package/packages/installer/src/installer/sinapse-ai-installer.js

@@ -14,6 +14,7 @@ const path = require('path');
 const crypto = require('crypto');
 const ora = require('ora');
 const { hashFile } = require('./file-hasher');
+const { copyReactBitsCorpusSync } = require('./react-bits-corpus');
 
 const NOFOLLOW_READ_FLAGS = nativeFs.constants.O_RDONLY | (nativeFs.constants.O_NOFOLLOW || 0);
 
@@ -705,6 +706,13 @@ async function installSinapseCore(options = {}) {
       if (claudeSettings) result.installedFiles.push(claudeSettings);
     }
 
+    if (includeClaude || includeCodex) {
+      spinner.text = 'Copying React Bits corpus...';
+      const corpusFiles = copyReactBitsCorpusSync(pkgRoot, targetDir);
+      result.reactBitsCorpusFiles = corpusFiles.length;
+      result.installedFiles.push(...corpusFiles);
+    }
+
     // AGENTS.md is the Codex CLI's default context file (Imperator greeting +
     // the full agent roster). It lives at the package ROOT (not under .codex/ or
     // .sinapse-ai/), so neither loop above reaches it. Without it, a Codex user's
@@ -878,6 +886,7 @@ module.exports = {
   deliverClaudeNativeAdapters,
   getClaudeHookName,
   reconcileClaudeHookSettings,
+  copyReactBitsCorpusSync,
   FOLDERS_TO_COPY,
   ROOT_FILES_TO_COPY,
   CODEX_ROOT_FILES,

package/scripts/sync-provider-adapters.js

@@ -11,10 +11,12 @@ const {
   syncCodexNativeAgents,
 } = require('../.codex/scripts/sync-codex-native');
 const { resolveCodexAgent } = require('../.codex/scripts/resolve-codex-agent');
+const { GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS } = require('../bin/lib/provider-contract');
 
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 const CLAUDE_AGENTS_DIR = '.claude/agents';
 const CLAUDE_SKILLS_DIR = '.claude/skills';
+const SUPPLEMENTAL_PROVIDER_SKILL_IDS = GLOBAL_SUPPLEMENTAL_PROVIDER_SKILL_IDS;
 
 function writeFileAtomically(filePath, content) {
   const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
@@ -136,11 +138,13 @@ function collectClaudeSkills(projectRoot = PROJECT_ROOT) {
     catalog.genericAgentSkillId,
   ])].sort();
 
-  return skillIds.map((skillId) => {
+  return [...new Set([...skillIds, ...SUPPLEMENTAL_PROVIDER_SKILL_IDS])].sort().map((skillId) => {
     const nativePath = path.join(projectRoot, '.agents', 'skills', skillId, 'SKILL.md');
     const metadata = parseSkillMetadata(fs.readFileSync(nativePath, 'utf8'));
     let content;
-    if (skillId === catalog.genericAgentSkillId) {
+    if (SUPPLEMENTAL_PROVIDER_SKILL_IDS.includes(skillId)) {
+      content = fs.readFileSync(nativePath, 'utf8');
+    } else if (skillId === catalog.genericAgentSkillId) {
       content = renderClaudeGenericSkill(skillId, metadata.description);
     } else if (skillId === 'sinapse-loop' || skillId === 'sinapse-spec-driven') {
       content = renderClaudeWorkflowSkill(skillId, metadata.description);
@@ -195,6 +199,7 @@ if (require.main === module) main();
 module.exports = {
   CLAUDE_AGENTS_DIR,
   CLAUDE_SKILLS_DIR,
+  SUPPLEMENTAL_PROVIDER_SKILL_IDS,
   claudeAgentFileName,
   renderClaudeAgent,
   collectClaudeSkills,

package/scripts/validate-provider-adapters.js

@@ -8,6 +8,11 @@ const yaml = require('js-yaml');
 const legacyClaudeCommandHashes = require('../packages/installer/src/migrations/legacy-claude-agent-command-hashes.json');
 
 const { validateNativeCodex } = require('../.codex/scripts/validate-codex-native');
+const {
+  REACT_BITS_CORPUS_RELATIVE_PATH,
+  REQUIRED_REACT_BITS_CORPUS_FILES,
+  hasCompleteReactBitsCorpus,
+} = require('../packages/installer/src/installer/react-bits-corpus');
 
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 
@@ -125,10 +130,13 @@ function validateClaudeNative(projectRoot = PROJECT_ROOT) {
   try {
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
     expectedSkills = (manifest.skillIds || []).map((skillId) => ({ skillId }));
-    if (expectedSkills.length !== 36) errors.push(`Claude skill manifest must contain 36 IDs, found ${expectedSkills.length}`);
+    if (expectedSkills.length !== 37) errors.push(`Claude skill manifest must contain 37 IDs, found ${expectedSkills.length}`);
     for (const alias of ['sinapse', 'sinapse-orqx', 'snps', 'snps-orqx', 'sinapse-agent']) {
       if (!manifest.skillIds.includes(alias)) errors.push(`Claude skill manifest is missing public alias ${alias}`);
     }
+    if (!manifest.skillIds.includes('react-bits-frontend')) {
+      errors.push('Claude skill manifest is missing react-bits-frontend');
+    }
   } catch (error) {
     errors.push(`Claude skill manifest: ${error.message}`);
   }
@@ -209,6 +217,17 @@ function validateProviderAdapters(projectRoot = PROJECT_ROOT) {
     if (!pkg.files.includes(entry)) errors.push(`package.json files[] is missing ${entry}`);
   }
   if (pkg.files.includes('.codex/skills/')) errors.push('package.json must not publish the legacy .codex/skills root');
+  if (!hasCompleteReactBitsCorpus(projectRoot)) {
+    errors.push(`React Bits corpus is incomplete: expected ${REQUIRED_REACT_BITS_CORPUS_FILES.length} files under ${REACT_BITS_CORPUS_RELATIVE_PATH}`);
+  }
+  for (const relativePath of [
+    path.join('.agents', 'skills', 'react-bits-frontend', 'SKILL.md'),
+    path.join('.claude', 'skills', 'react-bits-frontend', 'SKILL.md'),
+  ]) {
+    if (!fs.existsSync(path.join(projectRoot, relativePath))) {
+      errors.push(`React Bits provider skill is missing: ${relativePath}`);
+    }
+  }
   return {
     ok: errors.length === 0,
     errors,
@@ -240,4 +259,5 @@ module.exports = {
   validateClaudeHookSettings,
   validateClaudeNative,
   validateProviderAdapters,
+  REQUIRED_REACT_BITS_CORPUS_FILES,
 };

package/squads/squad-animations/agents/animations-orqx.md

@@ -28,6 +28,8 @@ Kinetic e o diretor da squad. Recebe os Animation Briefs do Decoder (animation-i
 - Garantir coesao entre animacoes de diferentes agentes
 - Orquestrar o workflow prompt-to-animation-cycle
 - Gerar relatorios de entrega
+- Roteiar trabalho React Bits pelo task `orchestrate-react-bits-frontend` e pelo
+  corpus operacional antes de delegar implementacao
 
 ## Pipeline de Orquestracao
 
@@ -64,6 +66,7 @@ Kinetic → Review final → Entrega
 | Hover effects | css-motion-artist | shader-artist |
 | Loading animations | css-motion-artist | motion-choreographer |
 | Camera movements 3D | threejs-architect | motion-choreographer |
+| React Bits frontend | orchestrate-react-bits-frontend | animation-performance-engineer |
 
 ## Criterios de Qualidade
 
@@ -86,6 +89,7 @@ Toda animacao deve passar por:
 | Definir timing e coreografia | motion-choreographer (Tempo) |
 | Implementar scroll animation | scroll-narrative-engineer (Parallax) |
 | Criar sistema de particulas | generative-particle-engineer (Cloud) |
+| Orquestrar frontend React Bits | orchestrate-react-bits-frontend |
 | Otimizar performance | animation-performance-engineer (Benchmark) |
 
 ## NON-NEGOTIABLE: ORCHESTRATE, DON'T EXECUTE
@@ -135,6 +139,9 @@ integration:
     - agent: "animation-performance-engineer (Benchmark)"
       when: "Quality gate before delivery — perf audit, 60fps validation, mobile check"
       context_passed: "all built animations, target devices, perf budget"
+    - agent: "orchestrate-react-bits-frontend"
+      when: "Frontend request that needs React Bits discovery, selection, installation or implementation"
+      context_passed: "project stack, target surface, desired interaction, accessibility and performance constraints"
   receives_from:
     - agent: "@sinapse-orqx (Imperator)"
       when: "Animation/motion request routed from ecosystem"