sinapse-ai 1.14.0 → 1.16.0

package/.sinapse-ai/product/templates/statusline/statusline-script.js

@@ -75,9 +75,16 @@ function buildStatusLine(data) {
 
   // 5 & 6. Agent & Squad (from session cache + API fallback)
   const cache = readSessionCache();
+  const badges = loadBadges();
+  const agentBadge = resolveBadge(cache, badges);
   const activeAgent = cache.agent || data.agent?.name || '';
   const activeSquad = cache.squad || '';
-  if (activeAgent) parts.push(`${cyan}\ud83e\udd16 ${activeAgent}${reset}`);
+  if (agentBadge) {
+    // Public badge: {emoji} {Name} (e.g. "\ud83d\udcbb Pixel") instead of the raw id.
+    parts.push(`${cyan}${agentBadge.emoji} ${agentBadge.name}${reset}`);
+  } else if (activeAgent) {
+    parts.push(`${cyan}\ud83e\udd16 ${activeAgent}${reset}`);
+  }
   if (activeSquad) parts.push(`${orange}\ud83c\udfaf ${activeSquad}${reset}`);
 
   // 6.5 Orchestration \u2014 Imperator + active specialists (TTL 6h)
@@ -90,7 +97,7 @@ function buildStatusLine(data) {
   }
   const ativos = (cache.specialists || []).filter(s => nowSec - s.ts < TTL);
   if (ativos.length > 0) {
-    parts.push(`${cyan}\ud83e\udded ${ativos.length} especialistas: ${ativos.map(s => s.id).join(', ')}${reset}`);
+    parts.push(`${cyan}\ud83e\udded ${ativos.length} especialistas: ${ativos.map(s => (badges && badges[s.id] ? badges[s.id].name : s.id)).join(', ')}${reset}`);
   }
 
   // 7. Project:Branch
@@ -169,6 +176,33 @@ function readSessionCache() {
   return { agent: '', squad: '', role: null, imperator: null, specialists: [] };
 }
 
+function loadBadges() {
+  // id -> {emoji, area, name}. Keys are bare ids or "squad/id"; index by the last
+  // segment to match what the session-cache stores. Best-effort — null on absence.
+  try {
+    const p = path.join(os.homedir(), '.claude', 'agent-badges.json');
+    const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (!raw || typeof raw !== 'object') return null;
+    const byId = {};
+    for (const key of Object.keys(raw)) {
+      const v = raw[key];
+      if (v && v.emoji && v.name) byId[key.split('/').pop()] = v;
+    }
+    return Object.keys(byId).length ? byId : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveBadge(cache, badges) {
+  if (!badges) return null;
+  if (cache.role === 'orqx' && cache.agent) {
+    return badges[`${cache.agent}-orqx`] || badges[cache.agent] || null;
+  }
+  if (cache.agent) return badges[cache.agent] || null;
+  return null;
+}
+
 function simpleHash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {

package/.sinapse-ai/product/templates/statusline/track-agent.cjs

@@ -33,6 +33,8 @@ const os = require('os');
 
 const MASTERS = new Set(['sinapse', 'snps', 'sinapse-orqx', 'snps-orqx']);
 const SPECIALIST_CAP = 6;
+const BADGE_TTL = 21600; // 6h — mirrors the statusline freshness window.
+const IMPERATOR_KEY = 'snps-orqx'; // badge key for the master / Imperator voice.
 
 // Identical to track-agent.sh and statusline-script.js.
 function simpleHash(str) {
@@ -132,6 +134,111 @@ function applyName(cache, name, ts) {
   }
 }
 
+// ── Badge injection ──────────────────────────────────────────────────────────
+// The detector also surfaces the speaking agent's public badge to the model via
+// the UserPromptSubmit `additionalContext` channel, so every response can open
+// with the right seal. Pure best-effort: any failure → no injection, never block.
+
+// Load ~/.claude/agent-badges.json and index by last path segment. Keys are
+// either bare ids ("developer") or "squad/id" ("squad-brand/brand-orqx"); the
+// session-cache only ever stores the bare id, so we index on the last segment.
+function loadBadges() {
+  try {
+    const p = path.join(os.homedir(), '.claude', 'agent-badges.json');
+    const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (!raw || typeof raw !== 'object') return null;
+    const byId = {};
+    for (const key of Object.keys(raw)) {
+      const v = raw[key];
+      if (!v || typeof v !== 'object' || !v.emoji || !v.name) continue;
+      byId[key.split('/').pop()] = v;
+    }
+    return Object.keys(byId).length ? byId : null;
+  } catch {
+    return null;
+  }
+}
+
+function fullBadge(b) {
+  return `▌ ${b.emoji} · SNPS · ${b.area || ''} · ${b.name}`.replace(/ ·  · /, ' · ');
+}
+function shortBadge(b) {
+  return `▌ ${b.emoji} ${b.name}`;
+}
+
+// Resolve the primary speaking voice. cache.role reflects the LAST classified
+// mention, so it doubles as the recency signal (imperator vs orqx vs specialist).
+function resolvePrimary(cache, byId) {
+  if (cache.role === 'imperator') return byId[IMPERATOR_KEY] || null;
+  if (cache.role === 'orqx' && cache.agent) {
+    return byId[`${cache.agent}-orqx`] || byId[cache.agent] || null;
+  }
+  if (cache.agent) return byId[cache.agent] || null;
+  if (cache.imperator && cache.imperator.active) return byId[IMPERATOR_KEY] || null;
+  return null;
+}
+
+// Build the additionalContext string, or null when no SINAPSE voice is active.
+function buildBadgeContext(cache) {
+  const byId = loadBadges();
+  if (!byId) return null;
+
+  const now = nowSec();
+  const primary = resolvePrimary(cache, byId);
+
+  // The specialist roster is only meaningful while the Imperator is coordinating
+  // a multi-agent orchestration; a plain specialist↔specialist switch shows just
+  // the active voice (no roster noise).
+  const imperatorActive =
+    cache.imperator && cache.imperator.active && now - (cache.imperator.ts || 0) < BADGE_TTL;
+  const specs = imperatorActive
+    ? (cache.specialists || [])
+        .filter((s) => s && s.id && s.id !== cache.agent && now - (s.ts || 0) < BADGE_TTL)
+        .map((s) => byId[s.id])
+        .filter(Boolean)
+    : [];
+
+  if (!primary && specs.length === 0) return null;
+
+  const lines = [];
+  lines.push('<sinapse-selo>');
+  lines.push('Identidade pública dos agentes SINAPSE. Aplique o protocolo de selo na sua resposta.');
+  lines.push('');
+  if (primary) {
+    lines.push(`Voz ativa → cheio: ${fullBadge(primary)}   curto: ${shortBadge(primary)}`);
+  }
+  if (specs.length) {
+    lines.push('Especialistas em jogo nesta orquestração:');
+    for (const b of specs) lines.push(`  • ${fullBadge(b)}   (curto: ${shortBadge(b)})`);
+  }
+  lines.push('');
+  lines.push('Protocolo (NON-NEGOTIABLE):');
+  lines.push('1. Abra a resposta com o selo do agente que está falando — 1ª linha, SÓ na troca de voz. Mesma voz em blocos seguidos não repete o selo.');
+  lines.push('2. Estreia da voz nesta conversa = selo CHEIO. Volta de uma voz já apresentada = selo CURTO.');
+  lines.push('3. Orquestrador (Imperator / -orqx): selo → apresenta o PLANO → ESPERA o "pode ir" do usuário → executa os handoffs (cada agente entra com seu selo) → consolida no fim.');
+  lines.push('4. O selo (emoji · SNPS · área · nome) É a identidade pública — nunca exponha @ids técnicos nem estrutura interna ao usuário.');
+  lines.push('</sinapse-selo>');
+
+  return lines.join('\n');
+}
+
+function emitBadge(cache) {
+  try {
+    const ctx = buildBadgeContext(cache);
+    if (!ctx) return;
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'UserPromptSubmit',
+          additionalContext: ctx,
+        },
+      })
+    );
+  } catch {
+    /* fail-soft: a badge is never worth blocking a prompt. */
+  }
+}
+
 function main() {
   const input = readStdin();
   if (!input) process.exit(0);
@@ -197,17 +304,20 @@ function main() {
     }
   }
 
-  if (!changed) process.exit(0);
-
-  cache.version = 2;
-  cache.updated = new Date().toISOString();
-
-  try {
-    fs.writeFileSync(cacheFile, JSON.stringify(cache));
-  } catch {
-    process.exit(0);
+  if (changed) {
+    cache.version = 2;
+    cache.updated = new Date().toISOString();
+    try {
+      fs.writeFileSync(cacheFile, JSON.stringify(cache));
+    } catch {
+      /* cache write is best-effort — still try to inject the badge below. */
+    }
   }
 
+  // Inject the active agent's badge even on continuation turns (no new mention
+  // keeps the same voice active). Fail-soft and silent when no voice is active.
+  emitBadge(cache);
+
   process.exit(0);
 }
 

package/AGENTS.md

@@ -1,7 +1,7 @@
 # AGENTS.md
 
 > SINAPSE AI -- AI-Orchestrated System for Full Stack Development
-> 17 squads · 172 agents (all `@`-resolvable in Codex) · 1,410 task files, 1,348 resolvable via the parametric activator
+> 17 squads · 172 agents (all `@`-resolvable in Codex) · 1,412 task files, 1,348 resolvable via the parametric activator
 >
 > Codex resolves every agent and its real tasks at runtime from source (no frozen
 > snapshot): `node .codex/scripts/resolve-codex-agent.js <agent> [command]`.

package/CHANGELOG.md

@@ -1,12 +1,8 @@
-## [1.14.0](https://github.com/caioimori/sinapse-ai/compare/1.13.0...1.14.0) (2026-06-24)
+## [1.16.0](https://github.com/caioimori/sinapse-ai/compare/1.15.0...1.16.0) (2026-06-25)
 
 ### Features
 
-* **agents:** potencializa 170 agentes com a base de engenharia de software ([#278](https://github.com/caioimori/sinapse-ai/issues/278)) ([86a1578](https://github.com/caioimori/sinapse-ai/commit/86a15781a704ee809ed444224b0aefbb02d57f06)), closes [#264](https://github.com/caioimori/sinapse-ai/issues/264)
-
-### Maintenance
-
-* **release:** sincroniza main com a v1.13.0 publicada (package.json + CHANGELOG) ([#277](https://github.com/caioimori/sinapse-ai/issues/277)) ([0c64e27](https://github.com/caioimori/sinapse-ai/commit/0c64e273dfe31ca06c4c72c91064f2a0e87b59ad))
+* add clarify and analyze gates to Spec Pipeline ([#280](https://github.com/caioimori/sinapse-ai/issues/280)) ([18b643f](https://github.com/caioimori/sinapse-ai/commit/18b643fe6d4038bb5a9967dccdd7b34bf3b9f6cc))
 
 # Changelog
 

package/bin/commands/install.js

@@ -48,7 +48,7 @@ const {
 
 async function cmdInstallGlobal(opts = {}) {
   const logger = getLogger();
-  header();
+  header({ force: true });
 
   // Story 10.20 — Upsert detection
   const force = Boolean(opts.force);
@@ -82,41 +82,12 @@ async function cmdInstallGlobal(opts = {}) {
     logger.always(`${DIM}  Language: ${label} (from saved config; pass --reconfigure to change)${NC}`);
   }
   if (!language) {
+    // Approved install redesign: Portuguese is the default and is NO longer
+    // prompted ("Idioma: Portugues (padrao)"). The resolved language is still
+    // saved to settings.language below and shown in the install preview. English
+    // stays available for power users via a pre-set settings.language=english.
     language = 'pt';
-    // Story 10.46 — multi-signal gate replaces the old `process.stdin.isTTY`
-    // check that silently defaulted to `pt` in Git Bash + Windows.
-    if (detectInteractiveMode()) {
-      try {
-        const inquirer = require('inquirer');
-        const langAnswer = await inquirer.prompt([{
-          type: 'list',
-          name: 'language',
-          message: 'Language / Idioma:',
-          choices: [
-            { name: 'Portugues', value: 'pt' },
-            { name: 'English', value: 'en' },
-          ],
-          default: 'pt',
-        }]);
-        language = langAnswer.language;
-      } catch {
-        // Fallback: readline
-        const readline = require('readline');
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        language = await new Promise((resolve) => {
-          logger.always(`  ${CYAN}Language / Idioma:${NC}`);
-          logger.always(`    ${GREEN}1${NC}) Portugues`);
-          logger.always(`    ${GREEN}2${NC}) English`);
-          rl.question(`  ${BOLD}[1/2]:${NC} `, (answer) => {
-            rl.close();
-            resolve((answer || '1').trim() === '2' ? 'en' : 'pt');
-          });
-        });
-      }
-    } else {
-      // Story 10.46 — surface the silent default so users on CI / pipes know.
-      warnNonInteractive();
-    }
+    if (!detectInteractiveMode()) warnNonInteractive();
   }
 
   // Save language to ~/.claude/settings.json
@@ -168,16 +139,23 @@ async function cmdInstallGlobal(opts = {}) {
     hookCount = fs.readdirSync(path.join(ROOT, '.claude', 'hooks')).filter(f => /\.(cjs|js|py|sh)$/.test(f)).length;
   } catch { /* hooks dir optional */ }
 
+  // Framed "o que será instalado" box (B&W). Rows are plain text so the width
+  // math stays correct — inline ANSI codes would break padEnd alignment.
+  const boxRows = [
+    `${squads.length} squads · ${agentTotal} agentes especializados`,
+    'Orquestrador master — @sinapse / @snps',
+  ];
+  if (hookCount) boxRows.push(`${hookCount} hooks de proteção + regras do framework`);
+  boxRows.push(`Editor(es): ${llmLabel}`);
+  boxRows.push(`Idioma: ${langLabelMap[language] || language}`);
+  boxRows.push(`Modo: ${isUpsert ? 'atualizar instalação existente' : 'instalação nova'}`);
+  boxRows.push('Destino: ~/.sinapse (núcleo) + ~/.claude/agents (agentes)');
+  const boxTitle = ' o que será instalado ';
+  const innerW = Math.max(boxTitle.length + 1, ...boxRows.map((r) => r.length + 1)) + 1;
   logger.always('');
-  logger.always(`${BOLD}──── O que será instalado ────${NC}`);
-  logger.always(`  ${BOLD}${squads.length}${NC} squads · ${BOLD}${agentTotal}${NC} agentes especializados`);
-  logger.always(`  Orquestrador master (Imperator) — chamável por ${CYAN}@sinapse${NC} / ${CYAN}@snps${NC}`);
-  if (hookCount) logger.always(`  ${hookCount} hooks de proteção + regras do framework`);
-  logger.always(`  Editor(es): ${BOLD}${llmLabel}${NC}`);
-  logger.always(`  Idioma: ${langLabelMap[language] || language}`);
-  logger.always(`  Modo: ${isUpsert ? 'atualizar instalação existente' : 'instalação nova'}`);
-  logger.always(`  Destino: ${DIM}~/.sinapse/${NC} (núcleo) + ${DIM}~/.claude/agents/${NC} (agentes)`);
-  logger.always(`${BOLD}──────────────────────────────${NC}`);
+  logger.always(`${DIM}  ┌─${boxTitle}${'─'.repeat(innerW - boxTitle.length - 1)}┐${NC}`);
+  for (const r of boxRows) logger.always(`${DIM}  │${NC} ${r.padEnd(innerW - 1)}${DIM}│${NC}`);
+  logger.always(`${DIM}  └${'─'.repeat(innerW)}┘${NC}`);
 
   if (detectInteractiveMode()) {
     const inquirer = require('inquirer');

package/bin/lib/header.js

@@ -8,11 +8,15 @@ const {
 } = require('../../.sinapse-ai/core/logger');
 const { VERSION, WHITE, BOLD, DIM, NC } = require('./constants');
 
-function header() {
+function header(opts = {}) {
   const logger = getLogger();
-  // Story A.2 AC 7 — ASCII art only on --verbose / --debug OR first-run.
-  // Never in --quiet or --json mode.
-  if (!shouldShowHeader(logger)) return;
+  const force = !!opts.force;
+  // --json (machine output) and --quiet always suppress the banner.
+  if (!logger || logger.json || logger.threshold === 0 /* LEVELS.error */) return;
+  // Outside json/quiet: show on --verbose / --debug, on first run, OR when the
+  // caller forces it. The `install` command forces it so the brand banner is
+  // always visible at install time (Story A.2 AC 7 kept for non-forced paths).
+  if (!force && !shouldShowHeader(logger)) return;
   const W = `${WHITE}${BOLD}`;
   const lines = [
     '',
@@ -23,17 +27,17 @@ function header() {
     `${W} ███████║██║ ╚████║██║     ███████║    ██║  ██║██║${NC}`,
     `${W} ╚══════╝╚═╝  ╚═══╝╚═╝     ╚══════╝    ╚═╝  ╚═╝╚═╝${NC}`,
     '',
-    `${DIM} Seu copiloto de inteligencia artificial${NC}`,
-    `${DIM} v${VERSION}${NC}`,
+    `${DIM}   Orquestracao de inteligencia artificial · v${VERSION}${NC}`,
+    '',
+    `${DIM}   ┼${'─'.repeat(50)}┼${NC}`,
     '',
   ];
-  // Write directly to stdout so the header still shows on first-run even when
-  // the logger level is `warn` (default). `shouldShowHeader` is the single
-  // gate that decides whether we get here at all.
+  // Write directly to stdout so the header still shows even when the logger
+  // level is `warn` (default). The gates above decide whether we get here.
   for (const line of lines) {
     try { process.stdout.write(`${line}\n`); } catch { /* ignore */ }
   }
-  // Mark first-run done so subsequent runs stay clean unless --verbose.
+  // Mark first-run done so subsequent (non-forced) runs stay clean.
   markFirstRunDone();
 }
 

package/bin/lib/setup-statusline.js

@@ -10,8 +10,9 @@
  *
  * What it installs:
  *   - ~/.claude/statusline-script.js          (renders the statusline)
- *   - ~/.claude/hooks/track-agent.cjs         (UserPromptSubmit detector — writes session-cache)
+ *   - ~/.claude/hooks/track-agent.cjs         (UserPromptSubmit detector — writes session-cache + injects the agent badge)
  *   - ~/.claude/hooks/track-agent-clear.cjs   (Stop hook — clears session-cache on session end)
+ *   - ~/.claude/agent-badges.json             (id -> {emoji, area, name} — read by the detector + statusline)
  *   - ~/.claude/session-cache/                (per-cwd cache directory)
  *   - settings.statusLine                     (graceful skip if already set)
  *   - settings.hooks.UserPromptSubmit → track-agent.cjs   (idempotent guard)
@@ -41,6 +42,7 @@ function resolveSources(sourceCoreDir) {
     script: path.join(templatesDir, 'statusline-script.js'),
     detector: path.join(templatesDir, 'track-agent.cjs'),
     clear: path.join(templatesDir, 'track-agent-clear.cjs'),
+    badges: path.join(templatesDir, 'agent-badges.json'),
   };
 }
 
@@ -122,6 +124,15 @@ async function setupStatusline(opts = {}) {
       result.files.push(clearTarget);
     }
 
+    // Agent badge map (id -> {emoji, area, name}). Read by the detector hook to
+    // inject the speaking agent's badge, and by the statusline to render it.
+    // Best-effort: a missing source never blocks the rest of the install.
+    if (await fse.pathExists(sources.badges)) {
+      const badgesTarget = path.join(claudeDir, 'agent-badges.json');
+      await fse.copy(sources.badges, badgesTarget);
+      result.files.push(badgesTarget);
+    }
+
     // Read existing global settings (back-compat with any prior config).
     let settings = {};
     try {