sinapse-ai 1.23.0 → 1.24.0

package/.claude/rules/mandatory-delegation-reference.md

@@ -66,7 +66,7 @@ Everything OUTSIDE their orchestration domain MUST be delegated.
 **On EVERY user message (not just orchestrator):**
 1. Detect the domain of the request
 2. If a specialist exists → delegate automatically (no confirmation needed)
-3. Brief acknowledgment: "Delegando para @specialist..."
+3. Brief acknowledgment via selo: o bloco do especialista abre com o selo dele (`▌ {emoji} · SNPS · {ÁREA} · {Nome}`) — nunca `@id` técnico em texto user-facing
 4. Return the result to the user
 
 **Auto-detect project state on first interaction:**

package/.claude/rules/mandatory-delegation.md

@@ -23,7 +23,7 @@ If the user says "voce faz", "faz voce mesmo", "nao delega", "I want YOU to writ
 the code", "just do it yourself", "implementa isso ai" — the orchestrator MUST
 still delegate:
 
-> "Absorvi o briefing. Delegando para @{specialist-agent} que e o especialista nesse dominio."
+> Absorvi o briefing. O especialista do domínio assume — e o bloco de trabalho dele abre com o **selo** próprio (`▌ {emoji} · SNPS · {ÁREA} · {Nome}`), nunca com `@id` técnico.
 
 **NEVER** execute the work directly. **ALWAYS** delegate to the specialist.
 

package/.claude/rules/squad-awareness.md

@@ -62,7 +62,7 @@ When ANY user message arrives, classify and route:
 When routing between agents/squads:
 1. **Never ask permission** — just route
 2. **Provide context** — pass the user's original request + project state
-3. **Confirm briefly** — "Delegando para @specialist que e o expert nisso."
+3. **Confirm via selo** — o bloco do especialista abre com o selo dele (`▌ {emoji} · SNPS · {ÁREA} · {Nome}`); nunca `@id` técnico em texto user-facing
 4. **Return result** — bring the deliverable back to the user
 
 ## Brownfield Auto-Behavior

package/.claude/rules/token-economy.md

@@ -115,7 +115,7 @@ Default: tabela ou bullet.
 
 - **Português** pra Caio e Matheus
 - Sem jargão ("salvei" não "commitei no HEAD")
-- Sem nomes de agentes em conversa (usuário vê "implementei", não "@developer")
+- Identidade de agente APENAS pelo **selo** (`▌ {emoji} · SNPS · {ÁREA} · {Nome}`, na troca de voz) — o selo é o canal sancionado e esperado; fora dele, verbos ("implementei"), nunca `@ids` técnicos nem estrutura interna
 - Sem comandos pro usuário rodar — agentes fazem tudo (Safe Collaboration)
 
 **Exceção:** usuário pede explicitamente ("explica em detalhes", "modo educativo"). Mesmo assim, sem preamble nem trailing summary.

package/.sinapse-ai/development/agents/snps-orqx.md

@@ -163,7 +163,7 @@ When the user provides ANY briefing, request, or initiative (regardless of compl
    - What the outgoing agent delivers (artifact, format)
    - What the incoming agent receives and needs
    - Handoff validation criteria
-4. **Execute** — After presenting the plan, begin execution immediately (YOLO mode) unless the user explicitly asks to review first
+4. **Execute** — After presenting the plan, WAIT for the user's go ("pode ir" / "go") before running the handoffs — same timing as the selo protocol injected per prompt. Exception: if the user already granted standing autonomous execution in this conversation (YOLO / "vai direto"), proceed immediately after presenting the plan
 
 **Anti-patterns (FORBIDDEN):**
 - Waiting for the user to ask "make a plan" — the plan is ALWAYS produced
@@ -199,6 +199,19 @@ No project continues without proper documentation. For every execution:
 
 Documentation is NOT optional. It is a handoff deliverable like code.
 
+## NON-NEGOTIABLE: SELO EM HANDOFFS (VISIBLE IDENTITY)
+
+> **Todo handoff é visível. O selo é a identidade pública de quem trabalha — handoff sem selo é handoff invisível.**
+
+Ao orquestrar qualquer briefing:
+
+1. **No plano:** cada fase é apresentada com o selo do responsável (`▌ {emoji} · SNPS · {ÁREA} · {Nome}`) — nunca com `@id` técnico nem lista de nomes de agente sem selo.
+2. **Na execução:** cada bloco de trabalho de domínio abre com o selo de quem está executando (selo CHEIO na estreia da voz na conversa, CURTO nas voltas). Trabalho de especialista entregue sob a voz do orquestrador viola este protocolo.
+3. **Na consolidação:** o Imperator retoma com o próprio selo e entrega o resultado em linguagem de negócio.
+4. **Fonte dos selos:** o hook injeta o elenco (núcleo + orquestradores de squad) no bloco `<sinapse-selo>`; pra especialista de squad fora do elenco, consultar `~/.claude/agent-badges.json` (chave `squad/id`).
+
+O selo é o ÚNICO canal sancionado de identidade de agente em texto user-facing. `@ids` técnicos, matrizes de handoff e estrutura interna seguem proibidos fora dele.
+
 ## COMPLETE AGENT DEFINITION
 
 ```yaml

package/.sinapse-ai/install-manifest.yaml

@@ -7,9 +7,9 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.23.0
+version: 1.24.0
 generator: scripts/generate-install-manifest.js
-file_count: 1155
+file_count: 1156
 files:
   - path: cli/commands/config/index.js
     hash: sha256:bfa83cb1dc111b0b30dd298dc0abc2150b73f939b6cd4458effa8e6d407bc9e2
@@ -1504,9 +1504,9 @@ files:
     type: agent
     size: 21342
   - path: development/agents/snps-orqx.md
-    hash: sha256:8e4145cdf25f57d366e0f6b3563e907c7a3ba8b2d6d3af0a6e573927f4a0321c
+    hash: sha256:d557a1c47a3bc82efdcbf799ca4363ea19a1883244edc5557474625315cb6fe8
     type: agent
-    size: 43871
+    size: 45205
   - path: development/agents/sprint-lead.md
     hash: sha256:df8dbd1de7b9c1238cbe3629d307563bbac1515869a5658dc7286b3dcbb55078
     type: agent
@@ -4236,13 +4236,17 @@ files:
     type: template
     size: 9200
   - path: product/templates/statusline/track-agent-clear.cjs
-    hash: sha256:3cda606de2463374e60440ba6cae9ca98e39b782b19c6ae39aa7569a1b211f09
+    hash: sha256:1258406127c7f3c66f2b17e9a25d26c725a7112443a1a17127a6f29b831c3f4f
     type: template
-    size: 2137
+    size: 3171
   - path: product/templates/statusline/track-agent.cjs
-    hash: sha256:0194c9a5750ed9e7a11fb5de21060021f64636f21e8b91039543abccaf6a4c86
+    hash: sha256:b8ab372aba97c4c3d82d78b5130eb44f47ffe8e74b925fe7ef75f5fb4393519a
     type: template
-    size: 10990
+    size: 15433
+  - path: product/templates/statusline/track-delegation.cjs
+    hash: sha256:17dc12b0ee286c752cddf6186cee6f25d19c1a59f3769090fa061a32d796c187
+    type: template
+    size: 5265
   - path: product/templates/story-tmpl.yaml
     hash: sha256:3dbcd522e69b86715f32eaf0cd13ce3a2631b5d2fc4f068c33df9593b6dbbfc2
     type: template

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

@@ -5,8 +5,10 @@
  * Called via Claude Code Stop hook (when the assistant turn ends).
  *
  * Soft-clears the per-CWD session cache at end of turn:
- *   - specialists[] -> []          (no longer "active" specialists)
- *   - imperator.active -> false    (imperator no longer active)
+ *   - imperator.active -> false    (turn-scoped flag; role survives)
+ *   - PRESERVES specialists[]       (orchestration cast spans turns — the 6h
+ *     TTL in track-agent.cjs/statusline handles expiry; wiping per turn made
+ *     cross-turn delegation tracking impossible)
  *   - PRESERVES squad and agent     (last-known, for statusline back-compat)
  *   - regrava updated (ISO)
  *
@@ -49,7 +51,19 @@ function main() {
 
   if (!raw || typeof raw !== 'object') process.exit(0);
 
+  // Freeze the voice-freshness point BEFORE refreshing `updated` below.
+  // Legacy caches (pre-voiceTs) inherit their ORIGINAL last-activity time —
+  // without this, every Stop would refresh `updated` and resurrect expired
+  // ("ghost") voices on the next prompt, defeating the voice TTL.
+  let voiceTs = Number.isFinite(raw.voiceTs) && raw.voiceTs > 0 ? raw.voiceTs : 0;
+  if (!voiceTs && typeof raw.updated === 'string' && raw.updated) {
+    const parsed = Date.parse(raw.updated);
+    if (Number.isFinite(parsed)) voiceTs = Math.floor(parsed / 1000);
+  }
+
   // Build a v2 cache preserving squad + agent, clearing the active layers.
+  // voiceTs is preserved so the primary voice keeps its 6h freshness window
+  // across turns of the same session (track-agent.cjs enforces the TTL).
   const cache = {
     version: 2,
     agent: typeof raw.agent === 'string' ? raw.agent : '',
@@ -59,7 +73,12 @@ function main() {
       active: false,
       ts: raw.imperator && Number.isFinite(raw.imperator.ts) ? raw.imperator.ts : 0,
     },
-    specialists: [],
+    specialists: Array.isArray(raw.specialists)
+      ? raw.specialists.filter(
+          (s) => s && typeof s === 'object' && typeof s.id === 'string' && s.id
+        )
+      : [],
+    voiceTs,
     updated: new Date().toISOString(),
   };
 

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

@@ -16,6 +16,12 @@
  *   - /squad:cmd         -> sets squad (when not :agents:)
  *   - *exit / *reset     -> clears agent/squad/role/specialists + imperator.active
  *
+ * Badge injection (selo):
+ *   - Primary voice has a 6h freshness TTL (voiceTs) — no more ghost voices
+ *     leaking across sessions.
+ *   - With the Imperator active, the block also ships the handoff CAST (core
+ *     agents + squad orchestrators) so auto-routed voices can stamp their seal.
+ *
  * Writes the per-CWD cache to:
  *   ~/.claude/session-cache/{simpleHash(cwd)}.json   (Session-Cache v2 shape)
  *
@@ -68,6 +74,7 @@ function normalizeCache(raw) {
     role: null,
     imperator: { active: false, ts: 0 },
     specialists: [],
+    voiceTs: 0,
     updated: '',
   };
   if (!raw || typeof raw !== 'object') return base;
@@ -75,6 +82,17 @@ function normalizeCache(raw) {
   base.agent = typeof raw.agent === 'string' ? raw.agent : '';
   base.squad = typeof raw.squad === 'string' ? raw.squad : '';
   base.role = typeof raw.role === 'string' ? raw.role : null;
+  base.voiceTs = Number.isFinite(raw.voiceTs) && raw.voiceTs > 0 ? raw.voiceTs : 0;
+  base.updated = typeof raw.updated === 'string' ? raw.updated : '';
+  // One-time migration for legacy caches (written before voiceTs existed):
+  // freeze the voice-freshness point at the cache's ORIGINAL last-activity
+  // time. This runs at READ time, before any writer refreshes `updated`, and
+  // the migrated value persists on the next write — so `updated` refreshes
+  // (Stop hook, delegation tracker, /squad:cmd) can never resurrect a ghost.
+  if (!base.voiceTs && base.updated) {
+    const parsed = Date.parse(base.updated);
+    if (Number.isFinite(parsed)) base.voiceTs = Math.floor(parsed / 1000);
+  }
 
   if (raw.imperator && typeof raw.imperator === 'object') {
     base.imperator = {
@@ -102,6 +120,9 @@ function applyName(cache, name, ts) {
   if (!name) return;
   const lower = name.toLowerCase();
 
+  // Any explicit mention renews the primary-voice freshness window (TTL below).
+  cache.voiceTs = ts;
+
   if (MASTERS.has(lower)) {
     // Master -> imperator. Does NOT enter specialists.
     cache.imperator = { active: true, ts };
@@ -142,18 +163,42 @@ function applyName(cache, name, ts) {
 // 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.
+// Also derives the handoff CAST (core agents + squad orchestrators) so the
+// model can stamp the seal of any agent it routes to — auto-routing means the
+// user never types those @ids, so the roster can't come from the prompt.
+// A few badge entries carry double-escaped emoji ("\\U0001F9E0" as literal
+// text). Decode them for display; garbage never reaches the user's selo.
+function fixEmoji(e) {
+  if (typeof e !== 'string' || !e) return '◆';
+  if (!e.includes('\\u') && !e.includes('\\U')) return e;
+  try {
+    const decoded = e
+      .replace(/\\U([0-9A-Fa-f]{8})/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+      .replace(/\\u([0-9A-Fa-f]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+    return decoded || '◆';
+  } catch {
+    return '◆';
+  }
+}
+
 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 = {};
+    const core = [];
+    const orqx = [];
     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;
+      const id = key.split('/').pop();
+      const b = { emoji: fixEmoji(v.emoji), area: v.area, name: v.name };
+      byId[id] = b;
+      if (!key.includes('/')) core.push({ id, b });
+      else if (id.endsWith('-orqx')) orqx.push({ id, b });
     }
-    return Object.keys(byId).length ? byId : null;
+    return Object.keys(byId).length ? { byId, core, orqx } : null;
   } catch {
     return null;
   }
@@ -178,20 +223,35 @@ function resolvePrimary(cache, byId) {
   return null;
 }
 
+// Freshness of the primary voice: an explicit mention within BADGE_TTL keeps
+// the voice alive; older than that → the voice expired. Kills ghost voices
+// that used to leak across sessions (the primary voice had no TTL at all).
+// voiceTs is the SINGLE source here — legacy caches are migrated at read time
+// by normalizeCache (frozen at their original `updated`), so a `updated`
+// refresh by any writer can never resurrect an expired voice.
+function voiceIsFresh(cache, now) {
+  const ts = Number.isFinite(cache.voiceTs) && cache.voiceTs > 0 ? cache.voiceTs : 0;
+  return ts > 0 && now - ts < BADGE_TTL;
+}
+
 // Build the additionalContext string, or null when no SINAPSE voice is active.
 function buildBadgeContext(cache) {
-  const byId = loadBadges();
-  if (!byId) return null;
+  const badges = loadBadges();
+  if (!badges) return null;
+  const byId = badges.byId;
 
   const now = nowSec();
-  const primary = resolvePrimary(cache, byId);
+  const primary = voiceIsFresh(cache, now) ? resolvePrimary(cache, byId) : null;
 
   // 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).
+  // the active voice (no roster noise). `imperator.active` is turn-scoped (the
+  // Stop hook lowers it), so cross-turn orchestration is detected by the ROLE,
+  // which survives turns and expires with the voice TTL.
   const imperatorActive =
     cache.imperator && cache.imperator.active && now - (cache.imperator.ts || 0) < BADGE_TTL;
-  const specs = imperatorActive
+  const imperatorLeading = imperatorActive || (cache.role === 'imperator' && !!primary);
+  const specs = imperatorLeading
     ? (cache.specialists || [])
         .filter((s) => s && s.id && s.id !== cache.agent && now - (s.ts || 0) < BADGE_TTL)
         .map((s) => byId[s.id])
@@ -211,6 +271,32 @@ function buildBadgeContext(cache) {
     lines.push('Especialistas em jogo nesta orquestração:');
     for (const b of specs) lines.push(`  • ${fullBadge(b)}   (curto: ${shortBadge(b)})`);
   }
+  // With the Imperator coordinating, ship the handoff cast (core + squad
+  // orchestrators) so every voice the plan routes to can enter with its own
+  // seal — auto-routing means these ids never appear in the user's prompt.
+  if (imperatorLeading && (badges.core.length || badges.orqx.length)) {
+    const cast = badges.core.filter((e) => e.id !== IMPERATOR_KEY).concat(badges.orqx);
+    const castLines = cast.map(
+      (e) => `  ${e.id} → ${e.b.emoji} · ${e.b.area || '—'} · ${e.b.name}`
+    );
+    // Hard budget: the whole <sinapse-selo> block stays ≤ 2500 chars even as
+    // squads grow. RESERVE covers the protocol tail pushed after this section.
+    const RESERVE = 900;
+    let room = 2500 - RESERVE - lines.join('\n').length;
+    const kept = [];
+    for (const l of castLines) {
+      if (room - (l.length + 1) < 0) break;
+      kept.push(l);
+      room -= l.length + 1;
+    }
+    lines.push('');
+    lines.push('Elenco pra handoffs — cada voz entra com o selo `▌ {emoji} · SNPS · {área} · {nome}`:');
+    lines.push(...kept);
+    if (kept.length < castLines.length) {
+      lines.push(`  … +${castLines.length - kept.length} no arquivo abaixo`);
+    }
+    lines.push('  (especialista de squad fora do elenco: chave "squad/id" em ~/.claude/agent-badges.json)');
+  }
   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.');
@@ -278,6 +364,7 @@ function main() {
     cache.role = null;
     cache.specialists = [];
     cache.imperator = { active: false, ts: cache.imperator.ts || 0 };
+    cache.voiceTs = 0;
     changed = true;
   } else {
     // /ns:agents:name  (e.g. /SINAPSE:agents:developer) -> classify as @name.

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

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * SINAPSE Delegation Tracker — Session-Cache v2
+ *
+ * Called via Claude Code PreToolUse hook with matcher "Task".
+ *
+ * Auto-routing means the user never types specialist @ids — so the prompt
+ * detector (track-agent.cjs) can't see programmatic delegations. This hook
+ * closes that gap: every real delegation (Task tool spawn) registers its
+ * `subagent_type` in the per-CWD session-cache `specialists[]`, so the next
+ * turn's badge injection lists the voices actually in play and the statusline
+ * can show the orchestration cast.
+ *
+ * Rules:
+ *   - Only ids that resolve to a badge in ~/.claude/agent-badges.json enter
+ *     the cache (harness-generic types like "general-purpose" are ignored).
+ *   - Never mutates the primary voice (agent/role) — delegation does not
+ *     change who is speaking; the orchestrator remains the voice.
+ *   - Cap of 6 specialists (oldest evicted), mirroring track-agent.cjs.
+ *
+ * OBSERVER ONLY / FAIL-OPEN: always exits 0 — a tracking hook must NEVER
+ * block a Task call, on any error whatsoever.
+ *
+ * Installed automatically by `npx sinapse-ai install`.
+ * Source: .sinapse-ai/product/templates/statusline/
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SPECIALIST_CAP = 6;
+// Masters are never a delegated "specialist in play" — they ARE the primary
+// voice. Squad orchestrators delegated as subagents DO enter the cast.
+const MASTERS = new Set(['sinapse', 'snps', 'sinapse-orqx', 'snps-orqx']);
+
+// Identical to track-agent.cjs and statusline-script.js.
+function simpleHash(str) {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h) + str.charCodeAt(i);
+    h |= 0;
+  }
+  return Math.abs(h).toString(16);
+}
+
+function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+// Badge ids indexed by last path segment (same contract as track-agent.cjs).
+function loadBadgeIds() {
+  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 ids = new Set();
+    for (const key of Object.keys(raw)) {
+      const v = raw[key];
+      if (!v || typeof v !== 'object' || !v.emoji || !v.name) continue;
+      ids.add(key.split('/').pop().toLowerCase());
+    }
+    return ids.size ? ids : null;
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  let input;
+  try {
+    input = JSON.parse(fs.readFileSync(0, 'utf8'));
+  } catch {
+    process.exit(0);
+  }
+
+  if (!input || input.tool_name !== 'Task') process.exit(0);
+
+  const subagent = ((input.tool_input || {}).subagent_type || '').toLowerCase().trim();
+  if (!subagent || MASTERS.has(subagent)) process.exit(0);
+
+  // Only SINAPSE agents (present in the badge map) enter the cast.
+  const badgeIds = loadBadgeIds();
+  if (!badgeIds || !badgeIds.has(subagent)) process.exit(0);
+
+  const cacheDir = path.join(os.homedir(), '.claude', 'session-cache');
+  const cacheFile = path.join(cacheDir, `${simpleHash(process.cwd())}.json`);
+
+  let cache;
+  try {
+    cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+  } catch {
+    cache = null;
+  }
+  if (!cache || typeof cache !== 'object') {
+    cache = {
+      version: 2,
+      agent: '',
+      squad: '',
+      role: null,
+      imperator: { active: false, ts: 0 },
+      specialists: [],
+      voiceTs: 0,
+      updated: '',
+    };
+  }
+  if (!Array.isArray(cache.specialists)) cache.specialists = [];
+
+  const ts = nowSec();
+  const existing = cache.specialists.find(
+    (s) => s && typeof s.id === 'string' && s.id.toLowerCase() === subagent
+  );
+  if (existing) {
+    existing.ts = ts; // renew freshness, no duplicate
+  } else {
+    cache.specialists.push({ id: subagent, label: subagent, icon: '🤖', ts });
+    if (cache.specialists.length > SPECIALIST_CAP) {
+      let minIdx = 0;
+      for (let i = 1; i < cache.specialists.length; i++) {
+        if (cache.specialists[i].ts < cache.specialists[minIdx].ts) minIdx = i;
+      }
+      cache.specialists.splice(minIdx, 1);
+    }
+  }
+
+  cache.version = 2;
+  // Freeze the voice-freshness point BEFORE refreshing `updated` — a legacy
+  // cache (pre-voiceTs) must not have its ghost voice resurrected by this
+  // write (same migration as track-agent.cjs/track-agent-clear.cjs).
+  if (!(Number.isFinite(cache.voiceTs) && cache.voiceTs > 0)) {
+    let frozen = 0;
+    if (typeof cache.updated === 'string' && cache.updated) {
+      const parsed = Date.parse(cache.updated);
+      if (Number.isFinite(parsed)) frozen = Math.floor(parsed / 1000);
+    }
+    cache.voiceTs = frozen;
+  }
+  cache.updated = new Date().toISOString();
+
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    // Atomic (tmp+rename): concurrent readers (statusline, track-agent) must
+    // never see a torn file. Parallel Task spawns remain last-write-wins —
+    // acceptable for an observer-only cast (worst case: one specialist waits
+    // for its next delegation to appear).
+    const tmp = `${cacheFile}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(cache));
+    fs.renameSync(tmp, cacheFile);
+  } catch {
+    /* best-effort */
+  }
+
+  process.exit(0);
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/CHANGELOG.md

@@ -1,8 +1,12 @@
-## [1.23.0](https://github.com/caioimori/sinapse-ai/compare/1.22.0...1.23.0) (2026-07-08)
+## [1.24.0](https://github.com/caioimori/sinapse-ai/compare/1.23.0...1.24.0) (2026-07-09)
 
 ### Features
 
-* **gate:** cobertura doc-first por extensao em qualquer pasta — marco de release [Story mesa2-docfirst-gate-coverage] ([#371](https://github.com/caioimori/sinapse-ai/issues/371)) ([a77b4e1](https://github.com/caioimori/sinapse-ai/commit/a77b4e1b3d4ba250e488d229071e341e3f763bfc)), closes [#370](https://github.com/caioimori/sinapse-ai/issues/370)
+* **selo:** handoffs visiveis — elenco injetado, delegacao rastreada, voz com TTL, regras reconciliadas [Story selo-handoff-visibility] ([#373](https://github.com/caioimori/sinapse-ai/issues/373)) ([0d8c58f](https://github.com/caioimori/sinapse-ai/commit/0d8c58f0bb0644b30e8c864cba18da785e958352))
+
+### Maintenance
+
+* **release:** sync da main pos-release 1.23.0 ([#372](https://github.com/caioimori/sinapse-ai/issues/372)) ([4e1bd6c](https://github.com/caioimori/sinapse-ai/commit/4e1bd6c3ef36940c57dfb7398dde52b4c853662e))
 
 # Changelog
 
@@ -13,6 +17,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.23.0] — 2026-07-08 — 🛡️ Gates doc-first cobrem código em qualquer pasta
+
+> Minor. Atualização segura via `npx sinapse-ai update`. Fecha a brecha de cobertura dos gates doc-first: a detecção deixa de depender de uma allowlist de 8 pastas e passa a valer por extensão de código em qualquer lugar do projeto.
+
+### Features
+
+- **gate:** amplia cobertura dos gates doc-first pra código em qualquer pasta — detecção por (pasta de código expandida OU extensão de código), isentando config-by-pattern (`*.config.*`, `*.d.ts`, `.*rc`) e build outputs (`.next/`, `dist/`, `coverage/`, `.vercel/`); exceção `isFrameworkRepo` no story gate (Art. III); +25 testes, fail-open preservado (#370, #371)
+
 ## [1.22.0] — 2026-07-07 — 🎛️ Mesa AF-20260704: guards doc-first + economia de contexto + calibração do juiz
 
 > Minor. Atualização segura via `npx sinapse-ai update`. Executa integralmente a Mesa da rodada 2 (épicos `epic-rodada2-mesa` + `epic-rodada2-mesa-fase2`, PRs #357–#368) — dos guards de qualidade ao contexto enxuto, tudo com verificação adversarial.

package/bin/lib/setup-statusline.js

@@ -12,11 +12,13 @@
  *   - ~/.claude/statusline-script.js          (renders the statusline)
  *   - ~/.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/hooks/track-delegation.cjs    (PreToolUse[Task] — registers real delegations in the cast)
  *   - ~/.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)
  *   - settings.hooks.Stop            → track-agent-clear.cjs (idempotent guard)
+ *   - settings.hooks.PreToolUse[Task] → track-delegation.cjs (idempotent guard)
  *
  * Design notes:
  *   - FAIL-SOFT: statusline is non-critical. Any unexpected error returns a
@@ -43,6 +45,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'),
+    delegation: path.join(templatesDir, 'track-delegation.cjs'),
     badges: path.join(templatesDir, 'agent-badges.json'),
   };
 }
@@ -77,7 +80,7 @@ function nodeCommand(targetPath) {
  * @param {string} [opts.sourceCoreDir] Absolute path to the installed `.sinapse-ai` directory.
  *   Defaults to the repo's `.sinapse-ai` relative to this module (`../../.sinapse-ai`).
  * @param {string} [opts.homeDir] Override the home directory (testing). Defaults to os.homedir().
- * @returns {Promise<{installed:boolean, reason?:string, statusLineSet:boolean, detectorHook:boolean, clearHook:boolean, files:string[]}>}
+ * @returns {Promise<{installed:boolean, reason?:string, statusLineSet:boolean, detectorHook:boolean, clearHook:boolean, delegationHook:boolean, files:string[]}>}
  */
 async function setupStatusline(opts = {}) {
   const result = {
@@ -85,6 +88,7 @@ async function setupStatusline(opts = {}) {
     statusLineSet: false,
     detectorHook: false,
     clearHook: false,
+    delegationHook: false,
     files: [],
   };
 
@@ -102,6 +106,7 @@ async function setupStatusline(opts = {}) {
       return result;
     }
     const hasClear = await fse.pathExists(sources.clear);
+    const hasDelegation = await fse.pathExists(sources.delegation);
 
     const claudeDir = path.join(homeDir, '.claude');
     const hooksDir = path.join(claudeDir, 'hooks');
@@ -110,6 +115,7 @@ async function setupStatusline(opts = {}) {
     const scriptTarget = path.join(claudeDir, 'statusline-script.js');
     const detectorTarget = path.join(hooksDir, 'track-agent.cjs');
     const clearTarget = path.join(hooksDir, 'track-agent-clear.cjs');
+    const delegationTarget = path.join(hooksDir, 'track-delegation.cjs');
 
     // Ensure directories (hooks + session-cache the trackers write to).
     await fse.ensureDir(hooksDir);
@@ -124,6 +130,10 @@ async function setupStatusline(opts = {}) {
       await fse.copy(sources.clear, clearTarget);
       result.files.push(clearTarget);
     }
+    if (hasDelegation) {
+      await fse.copy(sources.delegation, delegationTarget);
+      result.files.push(delegationTarget);
+    }
 
     // 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.
@@ -153,16 +163,25 @@ async function setupStatusline(opts = {}) {
       result.statusLineSet = true;
     }
 
-    // Hooks — register the .cjs detector (UserPromptSubmit) + clear (Stop), idempotently.
+    // Hooks — register the .cjs detector (UserPromptSubmit) + clear (Stop) +
+    // delegation tracker (PreToolUse[Task]), idempotently.
     if (!settings.hooks || typeof settings.hooks !== 'object') {
       settings.hooks = {};
     }
 
-    if (!Array.isArray(settings.hooks.UserPromptSubmit)) {
-      settings.hooks.UserPromptSubmit = [];
-    }
-    if (!hasHookCommand(settings.hooks.UserPromptSubmit, 'track-agent.cjs')) {
-      settings.hooks.UserPromptSubmit.push({
+    // PRESERVATION GUARD: if the user's settings carry an event in a legacy /
+    // hand-written NON-ARRAY shape, we must not clobber it (that would destroy
+    // their hooks). Skip registration for that event instead — never destroy.
+    const eventArray = (event) => {
+      if (settings.hooks[event] === undefined || settings.hooks[event] === null) {
+        settings.hooks[event] = [];
+      }
+      return Array.isArray(settings.hooks[event]) ? settings.hooks[event] : null;
+    };
+
+    const upsArr = eventArray('UserPromptSubmit');
+    if (upsArr && !hasHookCommand(upsArr, 'track-agent.cjs')) {
+      upsArr.push({
         matcher: '',
         hooks: [{ type: 'command', command: nodeCommand(detectorTarget), timeout: 10 }],
       });
@@ -170,11 +189,9 @@ async function setupStatusline(opts = {}) {
     }
 
     if (hasClear) {
-      if (!Array.isArray(settings.hooks.Stop)) {
-        settings.hooks.Stop = [];
-      }
-      if (!hasHookCommand(settings.hooks.Stop, 'track-agent-clear.cjs')) {
-        settings.hooks.Stop.push({
+      const stopArr = eventArray('Stop');
+      if (stopArr && !hasHookCommand(stopArr, 'track-agent-clear.cjs')) {
+        stopArr.push({
           matcher: '',
           hooks: [{ type: 'command', command: nodeCommand(clearTarget), timeout: 10 }],
         });
@@ -182,6 +199,20 @@ async function setupStatusline(opts = {}) {
       }
     }
 
+    // Delegation tracker — PreToolUse on the Task tool: registers each real
+    // (programmatic) delegation in the session-cache so auto-routed specialists
+    // surface in the badge context and statusline. Observer-only, fail-open.
+    if (hasDelegation) {
+      const preArr = eventArray('PreToolUse');
+      if (preArr && !hasHookCommand(preArr, 'track-delegation.cjs')) {
+        preArr.push({
+          matcher: 'Task',
+          hooks: [{ type: 'command', command: nodeCommand(delegationTarget), timeout: 5 }],
+        });
+        result.delegationHook = true;
+      }
+    }
+
     await fse.ensureDir(path.dirname(globalSettingsPath));
     // Atomic (tmp+rename): a crash mid-write must never leave a torn settings.json
     atomicWriteFileSync(globalSettingsPath, JSON.stringify(settings, null, 2), 'utf8');

package/package.json

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

package/packages/installer/src/wizard/ide-config-generator.js

@@ -659,6 +659,14 @@ const HOOK_EVENT_MAP = {
     matcher: null,
     timeout: 10,
   },
+  // Delegation tracker — registers each real Task-tool delegation in the
+  // session-cache so auto-routed specialists surface in the badge context.
+  // Observer-only, fail-open (always exit 0).
+  'track-delegation.cjs': {
+    event: 'PreToolUse',
+    matcher: 'Task',
+    timeout: 5,
+  },
 };
 
 /** Default event config for unmapped hooks (backwards compatible). */