sinapse-ai 1.12.2 → 1.14.0

package/bin/commands/update.js

@@ -18,19 +18,18 @@ const {
   NC,
 } = require('../lib/constants');
 const { header } = require('../lib/header');
-const { getSquads, extractAgentMeta } = require('../lib/squads');
+const { getSquads } = require('../lib/squads');
 const {
   rmDirSync,
   syncDirSync,
-  toForwardSlash,
 } = require('../lib/fs-utils');
 const {
   detectExistingInstall,
   detectStaleness,
 } = require('../lib/detection');
 const { promptLlmChoice } = require('../lib/prompts');
-const { generateCommandMd, generateSquadAwareness } = require('./install');
-const { registerGroundingHooks, HOOK_FILENAMES } = require('../lib/register-grounding-hooks');
+const { generateSquadAwareness } = require('./install');
+const { regenerateAgentCommands } = require('../lib/command-generator');
 const { execSync } = require('child_process');
 
 // Query the latest version published to npm. Returns null when npm is unreachable.
@@ -99,7 +98,7 @@ async function cmdUpdateGlobal() {
 
   // Welcome back screen
   logger.always(`${BOLD}  Que bom que voce voltou!${NC}`);
-  logger.always(`${DIM}  Atualizando SNPS AI: v${prevVer} -> v${VERSION}${NC}`);
+  logger.always(`${DIM}  Atualizando SINAPSE AI: v${prevVer} -> v${VERSION}${NC}`);
   logger.always('');
 
   // Story 10.40 — Staleness warning (installed vs executing version)
@@ -117,7 +116,7 @@ async function cmdUpdateGlobal() {
   const llmChoice = existing.llm || await promptLlmChoice();
 
   logger.always('');
-  logger.always(`${BOLD}Atualizando SNPS AI...${NC}\n`);
+  logger.always(`${BOLD}Atualizando SINAPSE AI...${NC}\n`);
 
   const squadsDir = path.join(ROOT, 'squads');
   const squadsSrcBase = fs.existsSync(squadsDir) ? squadsDir : ROOT;
@@ -147,53 +146,24 @@ async function cmdUpdateGlobal() {
     logger.always(`  ${GREEN}OK${NC} sinapse (orqx)`);
   }
 
-  // Phase 2: Regenerate commands (reuse install logic)
+  // 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.
   logger.always(`\n${CYAN}Phase 2:${NC} Regenerating commands`);
-  // Clear and regenerate
   rmDirSync(CLAUDE_COMMANDS_DIR);
-  fs.mkdirSync(CLAUDE_COMMANDS_DIR, { recursive: true });
-
-  const sinapseBase = toForwardSlash(SINAPSE_HOME);
-  const writtenAgents = new Set();
-
-  // Generate commands for orqx agents from squads (dynamic paths)
-  let totalAgents = 0;
-  for (const squad of squads) {
-    const agentsDir = path.join(SINAPSE_HOME, squad.name, 'agents');
-    if (!fs.existsSync(agentsDir)) continue;
-    const allAgents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
-    totalAgents += allAgents.length;
-    const orqxAgents = allAgents.filter(f => f.includes('-orqx'));
-    for (const file of orqxAgents) {
-      const agentId = file.replace('.md', '');
-      const meta = extractAgentMeta(path.join(agentsDir, file));
-      const squadPath = `${sinapseBase}/${squad.name}`;
-      fs.writeFileSync(path.join(CLAUDE_COMMANDS_DIR, file), generateCommandMd(agentId, meta.name, meta.icon, squad.name, squadPath, file));
-      writtenAgents.add(file);
-    }
-  }
-
-  // Generate commands for sinapse/ orqx squad agents
-  const sinapseAgentsDir = path.join(SINAPSE_HOME, 'sinapse', 'agents');
-  if (fs.existsSync(sinapseAgentsDir)) {
-    const masterAgents = fs.readdirSync(sinapseAgentsDir).filter(f => f.endsWith('.md'));
-    totalAgents += masterAgents.length;
-    for (const file of masterAgents) {
-      if (writtenAgents.has(file)) continue;
-      const agentId = file.replace('.md', '');
-      const meta = extractAgentMeta(path.join(sinapseAgentsDir, file));
-      const squadPath = `${sinapseBase}/sinapse`;
-      fs.writeFileSync(path.join(CLAUDE_COMMANDS_DIR, file), generateCommandMd(agentId, meta.name, meta.icon, 'sinapse', squadPath, file));
-      writtenAgents.add(file);
-    }
-  }
+  const { writtenAgents, totalAgents } = regenerateAgentCommands({
+    sinapseHome: SINAPSE_HOME,
+    commandsDir: CLAUDE_COMMANDS_DIR,
+    squads,
+    sinapseMasterDest: path.join(SINAPSE_HOME, 'sinapse'),
+  });
   logger.always(`  ${GREEN}OK${NC} ${writtenAgents.size} command files (${totalAgents} agents total)`);
 
   // Phase 2b: Install global agents based on LLM choice
   if (llmChoice === 'claude-code' || llmChoice === 'both') {
     const globalAgentsDir = path.join(HOME, '.claude', 'agents');
     fs.mkdirSync(globalAgentsDir, { recursive: true });
-    // Copy orqx commands as global agents
+    // Copy all generated agent commands as global agents
     for (const f of fs.readdirSync(CLAUDE_COMMANDS_DIR).filter(f => f.endsWith('.md'))) {
       fs.copyFileSync(path.join(CLAUDE_COMMANDS_DIR, f), path.join(globalAgentsDir, f));
     }
@@ -203,7 +173,7 @@ async function cmdUpdateGlobal() {
   if (llmChoice === 'codex' || llmChoice === 'both') {
     const codexAgentsDir = path.join(HOME, '.codex', 'agents');
     fs.mkdirSync(codexAgentsDir, { recursive: true });
-    // Generate orqx agents for Codex
+    // Copy all generated agent commands for Codex
     for (const f of fs.readdirSync(CLAUDE_COMMANDS_DIR).filter(f => f.endsWith('.md'))) {
       fs.copyFileSync(path.join(CLAUDE_COMMANDS_DIR, f), path.join(codexAgentsDir, f));
     }
@@ -235,36 +205,6 @@ async function cmdUpdateGlobal() {
   logger.always(`  ${CYAN}First installed:${NC} ${meta.installedAt}`);
   logger.always(`  ${CYAN}Last updated:${NC}    ${meta.updatedAt}`);
 
-  // Phase 3b — Story GA-1.6: ensure grounding hooks are present + registered.
-  if (llmChoice === 'claude-code' || llmChoice === 'both') {
-    try {
-      logger.always(`\n${CYAN}Phase 3b:${NC} Refreshing grounding hooks`);
-      const srcHooksDir = path.join(ROOT, '.sinapse-ai', 'hooks');
-      const destHooksDir = path.join(SINAPSE_HOME, 'hooks');
-      fs.mkdirSync(destHooksDir, { recursive: true });
-      let copied = 0;
-      for (const hookName of HOOK_FILENAMES) {
-        const src = path.join(srcHooksDir, hookName);
-        if (!fs.existsSync(src)) continue;
-        fs.copyFileSync(src, path.join(destHooksDir, hookName));
-        copied++;
-      }
-      const settingsPath = path.join(HOME, '.claude', 'settings.json');
-      const result = registerGroundingHooks({
-        settingsPath,
-        hooksDir: destHooksDir,
-        notify: (msg) => logger.always(`  ${DIM}${msg}${NC}`),
-      });
-      const summary = `${result.added.length} added, ${result.skipped.length} already present`;
-      logger.always(`  ${GREEN}OK${NC} ${copied} hook files refreshed — ${summary}`);
-      if (result.errors.length > 0) {
-        for (const err of result.errors) logger.always(`  ${YELLOW}WARN${NC} ${err}`);
-      }
-    } catch (error) {
-      logger.always(`  ${YELLOW}SKIP${NC} Grounding hooks: ${error.message}`);
-    }
-  }
-
   // Phase 4: Update project-local files (.sinapse-ai/, .claude/)
   logger.always(`\n${CYAN}Phase 4:${NC} Updating project files in current directory`);
   try {
@@ -292,10 +232,10 @@ async function cmdUpdateGlobal() {
 
   logger.always('');
   logger.always(`${GREEN}══════════════════════════════════════════════════════════════${NC}`);
-  logger.always(`${GREEN}  SNPS AI atualizado para v${VERSION}!${NC}`);
+  logger.always(`${GREEN}  SINAPSE AI atualizado para v${VERSION}!${NC}`);
   logger.always(`${GREEN}══════════════════════════════════════════════════════════════${NC}`);
   logger.always('');
-  logger.always(`  ${BOLD}${squads.length} squads${NC} | ${BOLD}${totalAgents} agents${NC} | ${BOLD}${writtenAgents.size} orqx commands${NC}`);
+  logger.always(`  ${BOLD}${squads.length} squads${NC} | ${BOLD}${totalAgents} agents${NC} | ${BOLD}${writtenAgents.size} command files${NC}`);
   logger.always(`  ${startCmd}`);
   logger.always('');
 }

package/bin/lib/command-generator.js

@@ -0,0 +1,261 @@
+// bin/lib/command-generator.js — shared agent-command generation.
+//
+// Single source of truth for the Phase 2 "generate agent commands" logic used by
+// BOTH `install` and `update`. Previously update.js only regenerated `-orqx`
+// commands, silently dropping every specialist command + the rich master stubs a
+// fresh install creates. Extracting the install behavior here makes `update`
+// produce byte-identical command files to `install`.
+
+const fs = require('fs');
+const path = require('path');
+
+const { SINAPSE_HOME, CLAUDE_COMMANDS_DIR } = require('./constants');
+const { extractAgentMeta } = require('./squads');
+const { toForwardSlash } = require('./fs-utils');
+
+/**
+ * Rich Imperator stub for the master entry points (@sinapse, @snps, @sinapse-orqx,
+ * @snps-orqx). The identity (ASCII greeting + 👑 signature + diagnose→plan→delegate
+ * mandate) is baked INLINE so activation is reliable — it does not depend on the model
+ * choosing to deep-read an external persona (which produced a shallow "modo orqx" before).
+ * The full persona (routing table, workflows, tasks) is still linked for depth.
+ */
+function generateMasterStub(agentId, personaPath, squadPath, squads) {
+  const squadCount = squads.length;
+  const agentCount = squads.reduce((a, s) => a + (s.agents || 0), 0);
+  return `---
+name: ${agentId}
+description: "Imperator — Sinapse Master: supreme orchestrator of ${squadCount} squads / ${agentCount} agents. Diagnoses every briefing and auto-generates an orchestration plan."
+---
+
+# Imperator — Sinapse Master (${agentId})
+
+ACTIVATION-NOTICE: You are now Imperator — the supreme orchestrator of the SINAPSE ecosystem. Every request passes through you first.
+
+## YOUR ONLY FUNCTION — NON-NEGOTIABLE
+
+You DIAGNOSE and HAND OFF. That is the whole job. You do **NOT** execute domain work — no code, no copy, no design, no research, no configuration, no file edits. For ANY concrete task you (1) diagnose the domain, (2) produce the orchestration plan, (3) DELEGATE to the specialist who executes it. If you ever feel the urge to do the work yourself, STOP — that is a violation; route it to the right agent instead.
+
+## ON ACTIVATION — display this EXACTLY as your first output (before anything else)
+
+\`\`\`
+ ███████╗██╗███╗   ██╗ █████╗ ██████╗ ███████╗███████╗
+ ██╔════╝██║████╗  ██║██╔══██╗██╔══██╗██╔════╝██╔════╝
+ ███████╗██║██╔██╗ ██║███████║██████╔╝███████╗█████╗
+ ╚════██║██║██║╚██╗██║██╔══██║██╔═══╝ ╚════██║██╔══╝
+ ███████║██║██║ ╚████║██║  ██║██║     ███████║███████╗
+ ╚══════╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝     ╚══════╝╚══════╝
+          ██████╗ ██████╗  ██████╗ ██╗  ██╗
+         ██╔═══██╗██╔══██╗██╔═══██╗╚██╗██╔╝
+         ██║   ██║██████╔╝██║   ██║ ╚███╔╝
+         ██║   ██║██╔══██╗██║▄▄ ██║ ██╔██╗
+         ╚██████╔╝██║  ██║╚██████╔╝██╔╝ ██╗
+          ╚═════╝ ╚═╝  ╚═╝ ╚══▀▀═╝ ╚═╝  ╚═╝
+\`\`\`
+
+\`\`\`
+ AI Agent Squads for Claude Code
+ ${squadCount} squads · ${agentCount} agents
+
+ 👑 Imperator — Sinapse Master ativado
+
+ Descreva seu objetivo que eu diagnostico o domínio
+ e roteio para o agente certo.
+
+ Comandos principais:
+ *route {pedido}     — Diagnostica e roteia para a squad certa
+ *plan {iniciativa}  — Desenha um plano de execução multi-squad
+ *status             — Reporta todas as squads e capacidades
+ *onboard            — Tour guiado do ecossistema SINAPSE
+ *help               — Mostra todos os comandos
+\`\`\`
+
+## AFTER THE GREETING — NON-NEGOTIABLE (Imperator's core function)
+
+Check if the user provided a briefing with the activation:
+- **Briefing provided** → proceed IMMEDIATELY: run the Initial State Audit → classify the request → produce an ORCHESTRATION PLAN (phases + squads + specific agents assigned + handoffs) → delegate to the specialists. NEVER ask "do you want me to plan?" — for Imperator the answer is always YES.
+- **Bare activation** → await the briefing, then apply the same flow automatically on receipt.
+
+You diagnose and DELEGATE — never execute domain work yourself. Route simple, well-defined requests directly to @specialist; complex ones to @{domain}-orqx; cross-domain ones by coordinating multiple orchestrators.
+
+## FULL OPERATING PARAMETERS
+
+For your complete persona — the routing table of all squads, the Initial State Audit, the Documentation-First gate, NSN enforcement, and every workflow and task — read and ADOPT:
+\`${personaPath}\`
+Tasks: \`${squadPath}/tasks/\` · Workflows: \`${squadPath}/workflows/\` · Manifest: \`${squadPath}/squad.yaml\`
+
+— Imperator, orchestrating SINAPSE
+`;
+}
+
+function generateCommandMd(agentId, agentName, agentIcon, squadName, squadPath, agentFile) {
+  // Detecta se é orquestrador: id termina em -orqx OU é Imperator (snps-orqx/sinapse-orqx)
+  // ou um dos apelidos curtos do master (sinapse/snps).
+  const isOrchestrator = /-orqx$/.test(agentId) || agentId === 'snps-orqx' || agentId === 'sinapse-orqx' || agentId === 'sinapse' || agentId === 'snps';
+
+  const step4 = isOrchestrator
+    ? `4. Briefing-on-activation check (this agent is an ORCHESTRATOR):
+   - If user provided briefing/context with the activation → proceed IMMEDIATELY: absorb → diagnose → plan with phases + agents + handoffs → execute (YOLO). NEVER ask "do you want me to plan?".
+   - If bare activation only → await briefing. On receipt, apply same flow automatically.`
+    : '4. HALT and await user input';
+
+  const step6 = isOrchestrator
+    ? `6. Briefing-on-activation check (ORCHESTRATOR):
+   - If user provided briefing → proceed IMMEDIATELY: absorb → diagnose → plan → execute
+   - If bare activation → await briefing, then plan automatically. NEVER ask "do you want me to plan?".`
+    : '6. HALT and await user input';
+
+  // Frontmatter (name + description) is REQUIRED so the file resolves as a Claude Code
+  // subagent (@id) — without it, @id matches nothing. The same file doubles as a slash
+  // command (/SINAPSE:agents:id); extra frontmatter is harmless there.
+  const fmDesc = (isOrchestrator
+    ? `${agentName || agentId} — orchestrator for ${squadName}; diagnoses, routes to specialists and auto-generates an orchestration plan`
+    : `${agentName || agentId} — ${squadName} specialist`).replace(/["\n\r]/g, ' ').trim();
+
+  return `---
+name: ${agentId}
+description: "${fmDesc}"
+---
+
+# ${agentId}
+
+ACTIVATION-NOTICE: This command activates an agent from ${squadName}.
+
+CRITICAL: Read the agent definition file at \`${squadPath}/agents/${agentFile}\` to understand your full operating parameters. Then:
+1. Adopt the persona defined in that file (name: ${agentName}, icon: ${agentIcon})
+2. Load the squad manifest at \`${squadPath}/squad.yaml\` for context
+3. Display a greeting showing your agent name, role, and available commands
+${step4}
+
+## Agent Reference
+- **Agent ID:** ${agentId}
+- **Squad:** ${squadName}
+- **Definition:** \`${squadPath}/agents/${agentFile}\`
+- **Squad Manifest:** \`${squadPath}/squad.yaml\`
+- **Tasks:** \`${squadPath}/tasks/\`
+- **Knowledge Bases:** \`${squadPath}/knowledge-base/\`
+- **Workflows:** \`${squadPath}/workflows/\`
+
+## Activation Instructions
+1. Read the full agent definition: \`${squadPath}/agents/${agentFile}\`
+2. Adopt the persona (name, icon, communication style, principles)
+3. Show greeting: "{icon} {name} — {role} ativado"
+4. Show: "Squad: ${squadName} | Invoke: /SINAPSE:agents:${agentId}"
+5. List your key tasks from the agent definition
+${step6}
+
+## How to Execute Tasks
+When the user requests a task:
+1. Find the matching task in \`${squadPath}/tasks/\`
+2. Read the task file completely
+3. Execute following the task checklist step by step
+4. Consult knowledge bases in \`${squadPath}/knowledge-base/\` as needed
+
+## Cross-Squad Handoff
+If the task requires expertise outside this squad:
+1. Identify which squad covers the needed domain
+2. Recommend: /SINAPSE:agents:{appropriate-agent}
+3. Provide handoff context
+`;
+}
+
+/**
+ * Regenerate ALL agent command files into `commandsDir`. This is the exact Phase 2
+ * behavior of a fresh install, shared so `update` produces an identical set:
+ *   1. Clear commandsDir.
+ *   2. Write a command for EVERY agent of every squad (not only -orqx).
+ *   3. Write commands for the sinapse master squad agents.
+ *   4. Overwrite the four master entry points (sinapse-orqx, snps-orqx, sinapse,
+ *      snps) with the rich Imperator stub.
+ *
+ * @param {Object} [deps] - Injectable dependencies (defaults bind to real fs/paths).
+ * @param {string} [deps.sinapseHome] - Root of installed squads (~/.sinapse).
+ * @param {string} [deps.commandsDir] - Target commands dir.
+ * @param {Array}  deps.squads - Squad descriptors ({ name, agents, ... }).
+ * @param {string} [deps.sinapseMasterDest] - Path to the installed sinapse/ master squad.
+ * @returns {{ writtenAgents: Set<string>, totalAgents: number }}
+ */
+function regenerateAgentCommands(deps = {}) {
+  const {
+    sinapseHome = SINAPSE_HOME,
+    commandsDir = CLAUDE_COMMANDS_DIR,
+    squads,
+    sinapseMasterDest = path.join(sinapseHome, 'sinapse'),
+  } = deps;
+
+  if (!Array.isArray(squads)) {
+    throw new Error('regenerateAgentCommands: `squads` array is required');
+  }
+
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  // Clear old commands (dir may not exist on a fresh install — guarded).
+  try {
+    for (const f of fs.readdirSync(commandsDir)) {
+      fs.unlinkSync(path.join(commandsDir, f));
+    }
+  } catch { /* dir may not exist yet */ }
+
+  const sinapseBase = toForwardSlash(sinapseHome);
+  const writtenAgents = new Set();
+
+  // 1. A command/subagent for EVERY agent (not only -orqx), so every specialist
+  //    is invokable via @agent and /SINAPSE:agents:agent.
+  for (const squad of squads) {
+    const squadPath = `${sinapseBase}/${squad.name}`;
+    const agentsDir = path.join(sinapseHome, squad.name, 'agents');
+    if (!fs.existsSync(agentsDir)) continue;
+
+    const squadAgents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+    for (const file of squadAgents) {
+      const agentId = file.replace('.md', '');
+      const meta = extractAgentMeta(path.join(agentsDir, file));
+      const cmdContent = generateCommandMd(agentId, meta.name, meta.icon, squad.name, squadPath, file);
+      fs.writeFileSync(path.join(commandsDir, `${agentId}.md`), cmdContent);
+      writtenAgents.add(file);
+    }
+  }
+
+  // 2. Commands for sinapse/ master squad agents.
+  if (fs.existsSync(sinapseMasterDest)) {
+    const masterAgentsDir = path.join(sinapseMasterDest, 'agents');
+    if (fs.existsSync(masterAgentsDir)) {
+      for (const file of fs.readdirSync(masterAgentsDir).filter(f => f.endsWith('.md'))) {
+        if (writtenAgents.has(file)) continue;
+        const agentId = file.replace('.md', '');
+        const meta = extractAgentMeta(path.join(masterAgentsDir, file));
+        const squadPath = `${sinapseBase}/sinapse`;
+        const cmdContent = generateCommandMd(agentId, meta.name, meta.icon, 'sinapse', squadPath, file);
+        fs.writeFileSync(path.join(commandsDir, `${agentId}.md`), cmdContent);
+        writtenAgents.add(file);
+      }
+    }
+  }
+
+  // 3. Master entry points (@sinapse, @snps, @sinapse-orqx, @snps-orqx) → rich
+  //    Imperator stub. Overwrites the generic command file for the orqx names and
+  //    adds the short aliases the user actually types.
+  if (fs.existsSync(sinapseMasterDest)) {
+    const masterSquadPath = `${sinapseBase}/sinapse`;
+    const masterEntryPoints = [
+      ['sinapse-orqx', 'sinapse-orqx.md'],
+      ['snps-orqx', 'snps-orqx.md'],
+      ['sinapse', 'sinapse-orqx.md'],
+      ['snps', 'snps-orqx.md'],
+    ];
+    for (const [id, personaFile] of masterEntryPoints) {
+      const personaPath = `${masterSquadPath}/agents/${personaFile}`;
+      const stub = generateMasterStub(id, personaPath, masterSquadPath, squads);
+      fs.writeFileSync(path.join(commandsDir, `${id}.md`), stub);
+      writtenAgents.add(`${id}.md`);
+    }
+  }
+
+  return { writtenAgents, totalAgents: writtenAgents.size };
+}
+
+module.exports = {
+  generateCommandMd,
+  generateMasterStub,
+  regenerateAgentCommands,
+};

package/bin/lib/prompts.js

@@ -1,9 +1,8 @@
-// bin/lib/prompts.js — interactive prompts (LLM, grounding, uninstall).
+// bin/lib/prompts.js — interactive prompts (LLM, uninstall).
 // Story GA-1.2 — extracted from bin/cli.js.
 
-const path = require('path');
 const { getLogger } = require('../../.sinapse-ai/core/logger');
-const { ROOT, CYAN, GREEN, BOLD, DIM, YELLOW, NC } = require('./constants');
+const { CYAN, GREEN, BOLD, DIM, YELLOW, NC } = require('./constants');
 const { detectInteractiveMode, warnNonInteractive } = require('./detection');
 
 /**
@@ -53,67 +52,6 @@ async function promptLlmChoice() {
   }
 }
 
-// Story 10.47 — collect optional grounding paths (vault / design system /
-// brand). Empty answers leave the section disabled and the shipped hook
-// stays a no-op. Reuses the multi-signal interactive detector from Story
-// 10.46 so CI / non-TTY runs skip silently with the consolidated warning
-// already emitted by lang/LLM helpers.
-async function promptGroundingSections({ isUpsert = false, reconfigure = false } = {}) {
-  const logger = getLogger();
-  const groundingConfig = require(path.join(
-    ROOT, 'packages', 'installer', 'src', 'wizard', 'grounding-config',
-  ));
-  const existing = groundingConfig.readGroundingConfig();
-  const pending = isUpsert && !reconfigure
-    ? groundingConfig.pendingGroundingSections(existing)
-    : { askVault: true, askDesignSystem: true, askBrand: true };
-
-  if (!pending.askVault && !pending.askDesignSystem && !pending.askBrand) {
-    return existing;
-  }
-
-  if (!detectInteractiveMode()) {
-    warnNonInteractive();
-    // Persist defaults so the file exists with a documented schema even on
-    // headless installs (helps users discover it later via `--reconfigure`).
-    const merged = groundingConfig.buildGroundingFromAnswers({}, existing);
-    groundingConfig.writeGroundingConfig(merged);
-    return merged;
-  }
-
-  const questions = require(path.join(
-    ROOT, 'packages', 'installer', 'src', 'wizard', 'questions',
-  ));
-  const inquirer = require('inquirer');
-
-  const ask = [];
-  if (pending.askVault) ask.push(questions.getVaultGroundingQuestion());
-  if (pending.askDesignSystem) ask.push(questions.getDesignSystemGroundingQuestion());
-  if (pending.askBrand) ask.push(questions.getBrandGroundingQuestion());
-
-  logger.always('');
-  logger.always(`${CYAN}Grounding semantico (opt-in):${NC}`);
-  logger.always(`${DIM}  Pular qualquer pergunta ativa o fallback generico do framework.${NC}`);
-
-  let answers = {};
-  try {
-    answers = await inquirer.prompt(ask);
-  } catch {
-    // Fallback: minimal readline loop if inquirer fails (e.g. exotic shells).
-    const readline = require('readline');
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const askLine = (msg) => new Promise((resolve) => rl.question(msg, resolve));
-    if (pending.askVault) answers.vaultPath = (await askLine('  Vault path (Enter pra pular): ')).trim();
-    if (pending.askDesignSystem) answers.designSystemPath = (await askLine('  Design system path (Enter pra pular): ')).trim();
-    if (pending.askBrand) answers.brandbookPath = (await askLine('  Brandbook path (Enter pra pular): ')).trim();
-    rl.close();
-  }
-
-  const merged = groundingConfig.buildGroundingFromAnswers(answers, existing);
-  groundingConfig.writeGroundingConfig(merged);
-  return merged;
-}
-
 // Story 10.40 — Confirmation prompt for destructive uninstall.
 // Returns true if user confirmed, false otherwise.
 async function confirmUninstall() {
@@ -130,6 +68,5 @@ async function confirmUninstall() {
 
 module.exports = {
   promptLlmChoice,
-  promptGroundingSections,
   confirmUninstall,
 };

package/bin/modules/chrome-brain-installer.js

@@ -140,7 +140,8 @@ function mergeHooks(settingsPath, hookDefs) {
     const existing = settings.hooks[hookType] || [];
     const newKeys = new Set(hookList.map(h => hookKey(h.matcher, h)));
     // Dedupe by (matcher + command) so SessionStart matcher="" doesn't
-    // collide with other modules' SessionStart hooks (e.g. vault-grounding).
+    // collide with other modules' SessionStart hooks (e.g. another
+    // session-start grounding hook).
     const filtered = existing.filter(e => !newKeys.has(hookKey(e.matcher, e)));
     filtered.push(...hookList);
     settings.hooks[hookType] = filtered;

package/bin/postinstall.js

@@ -340,7 +340,7 @@ function stepCreateRuntimeDirs() {
       fs.mkdirSync(dir, { recursive: true });
     } catch (err) {
       if (err.code === 'EACCES' || err.code === 'EPERM') {
-        warn(`Sem permissão para criar ${path.relative(PROJECT_ROOT, dir)} — SNPS AI vai tentar criar no primeiro uso.`);
+        warn(`Sem permissão para criar ${path.relative(PROJECT_ROOT, dir)} — SINAPSE AI vai tentar criar no primeiro uso.`);
         softFailures += 1;
         continue;
       }
@@ -439,7 +439,7 @@ function stepDoctor() {
  *   Teste:   sinapse doctor
  *   Começar: @sinapse no Claude Code
  *
- *   Docs:    https://sinapse.club
+ *   Docs:    https://github.com/caioimori/sinapse-ai#readme
  *
  * In --verbose mode the caller has already printed detailed step output, so we
  * still render the minimal summary at the end as a recap.
@@ -477,9 +477,9 @@ function renderFinalSummary(opts = {}) {
   const isGlobal = isGlobalInstall();
   const lines = [];
   if (firstRun) {
-    lines.push(`${c.bold}Bem-vindo ao SNPS AI!${c.reset} 🎉`);
+    lines.push(`${c.bold}Bem-vindo ao SINAPSE AI!${c.reset} 🎉`);
   }
-  lines.push(`${c.bold}SNPS AI ${version}${c.reset} instalado ${c.green}✓${c.reset}`);
+  lines.push(`${c.bold}SINAPSE AI ${version}${c.reset} instalado ${c.green}✓${c.reset}`);
   if (!isGlobal) {
     lines.push(`${c.dim}${agents} ${agentsWord} · ${squads} ${squadsWord} ${prontosWord}${c.reset}`);
   }
@@ -493,7 +493,7 @@ function renderFinalSummary(opts = {}) {
     lines.push(`Começar: ${c.cyan}@sinapse${c.reset} no Claude Code`);
   }
   lines.push('');
-  lines.push(`Docs:    ${c.dim}https://sinapse.club${c.reset}`);
+  lines.push(`Docs:    ${c.dim}https://github.com/caioimori/sinapse-ai#readme${c.reset}`);
 
   for (const line of lines) {
     process.stdout.write(`${line}\n`);
@@ -567,7 +567,7 @@ function main(argvOverride) {
     return 0;
   }
 
-  verboseLog(`${c.dim}SNPS AI postinstall — configurando ambiente...${c.reset}`);
+  verboseLog(`${c.dim}SINAPSE AI postinstall — configurando ambiente...${c.reset}`);
 
   const syncIde = stepSyncIde();
   if (syncIde.critical) {

package/docs/getting-started.md

@@ -42,7 +42,6 @@ No prompt do Claude Code ou Codex:
 |---|---|
 | Entender filosofia do framework | [`README.md`](../README.md) |
 | Ver lista completa de agentes | [Agent Reference Guide](agent-reference-guide.md) |
-| Configurar grounding (vault, DS, brand) | [Grounding Setup](guides/grounding-setup.md) |
 | Resolver problema na instalação | [Troubleshooting](troubleshooting.md) |
 | Ver workflow de desenvolvimento | [`docs/sinapse-workflows/`](sinapse-workflows/) |
 | Contribuir | [`CONTRIBUTING.md`](../CONTRIBUTING.md) |

package/docs/pt/getting-started.md

@@ -337,7 +337,7 @@ steps:
 
 ## Conceitos Básicos da Camada de Memória
 
-A camada de memória da SINAPSE (Chrome Brain v3) fornece gerenciamento inteligente de contexto com grounding do Second Brain e recuperação semântica nativa.
+A camada de memória da SINAPSE (Chrome Brain v3) fornece gerenciamento inteligente de contexto com grounding contra seu vault de notas (opcional) e recuperação semântica nativa.
 
 ### Como a Memória Funciona