sinapse-ai 9.3.0 → 9.4.0

package/squads/squad-claude/knowledge-base/swarm-orchestration-patterns.md

@@ -0,0 +1,411 @@
+# Swarm Orchestration Patterns
+
+> Multi-agent frameworks comparison, orchestration patterns, and implementation guidance. Based on MS-009 research + Claude Code internals analysis (April 2026).
+
+---
+
+## Framework Landscape (2026)
+
+### 9 Frameworks Compared
+
+| Framework | Architecture | Control Level | Ideal For | Maturity |
+|-----------|-------------|---------------|-----------|----------|
+| **LangGraph** | State machine with directed graph | Maximum (nodes, edges, conditional routing) | Enterprise production, complex flows | High |
+| **CrewAI** | Role-playing + task delegation | Medium (roles, tasks, SOPs) | Rapid prototyping, conceptual teams | High |
+| **Claude Agent SDK** | Claude-native with tool use | Medium | Claude ecosystem, Sonnet 4.5/4.6 | High |
+| **OpenAI Agents SDK** | Agents with handoffs + guardrails | Medium | OpenAI ecosystem | High |
+| **Google ADK** | Agent Development Kit | Medium | Google/Gemini ecosystem | High |
+| **Microsoft Agent Framework** | AutoGen + Semantic Kernel unified | Medium-High | Enterprise Microsoft stack | New (2026) |
+| **AG2 (AutoGen fork)** | Multi-agent conversation | Low-Medium | Open-source community | Active |
+| **deepagents (LangChain)** | Batteries-included harness | Medium | Long-horizon tasks, LangChain users | Growing |
+| **Ruflo** | 60+ agent swarm with MCP | N/A | Claude Code native | New |
+
+**Note (April 2026):** Microsoft retired AutoGen in favor of new Microsoft Agent Framework, unifying AutoGen + Semantic Kernel. AutoGen is maintenance-only. Community fork: AG2 (ag2ai/ag2).
+
+---
+
+## Claude Code Multi-Agent Architecture
+
+### 3 Execution Models
+
+#### 1. Fork Model (Experimental)
+
+Subagents created with **byte-identical context copies** for cache sharing.
+
+**Key innovation:** Fork children use identical placeholder text for each `tool_result` block, guaranteeing prefix-identical prompts across all workers. "Spawning five forked agents costs barely more than 1."
+
+```
+Parent Agent (with full context)
+  → forkSubagent() × N
+  → Children: identical system prompt prefix + unique task
+  → KV cache shared across all children
+  → Cost: ~1.0x base (not N×)
+```
+
+#### 2. Teammate Model
+
+Independent agents with separate context windows.
+
+**Communication:** Task files on disk + `SendMessageTool` — **no shared memory**.
+
+```json
+// SendMessageTool targets
+{ "target": "teammate-name" }  // written to mailbox
+{ "target": "*" }               // broadcast to all
+{ "target": "team-lead" }       // shutdown approve/reject
+{ "target": "uds:/path" }       // Unix domain socket
+```
+
+#### 3. Worktree Model
+
+Git worktree isolation for parallel implementation.
+
+```bash
+# Each agent gets isolated git worktree
+git worktree add .worktrees/agent-auth -b agent/auth
+git worktree add .worktrees/agent-ui -b agent/ui
+
+# Agents work independently
+# No merge conflicts during parallel work
+# Human reviews and merges when both complete
+```
+
+---
+
+## Claude Code Coordinator Mode
+
+### 4-Phase Pattern
+
+```
+Phase 1: Research (parallel)
+  Workers investigate different parts of codebase simultaneously
+  Each worker returns compact findings report
+
+Phase 2: Synthesis
+  Coordinator reads all findings
+  Crafts detailed implementation specs
+
+Phase 3: Implementation (parallel)
+  Workers execute per-spec changes in isolated worktrees
+  Specs ensure no file conflicts
+
+Phase 4: Verification
+  Separate testing workers validate changes
+  Report back with PASS/FAIL verdicts
+```
+
+**Coordinator instructions (from source):**
+- "Parallelism is your superpower"
+- "Do not rubber-stamp weak work"
+
+### Coordinator Mode Implementation
+
+Implemented via system prompt, not code:
+
+```markdown
+## Coordinator Instructions
+
+You are orchestrating a team of worker agents.
+
+Your responsibilities:
+1. Decompose the task into independent units
+2. Assign each unit to a worker with clear specs
+3. Wait for all workers to complete
+4. Synthesize results — do not rubber-stamp weak work
+5. If a worker fails, diagnose and re-assign
+
+Rules:
+- Workers work in isolated git worktrees
+- Workers communicate via SendMessageTool only
+- You manage the overall task state
+- Parallelism is your superpower
+```
+
+---
+
+## Reasoning Patterns for Agents
+
+### 5 Core Patterns
+
+| Pattern | Description | Best For |
+|---------|-------------|---------|
+| **ReAct** | Reason + Act in loop: think → execute → observe | Tasks with tools (search, edit) |
+| **Chain of Thought (CoT)** | Linear step-by-step reasoning | Sequential problems, math |
+| **Tree of Thought (ToT)** | Explore multiple reasoning paths as tree | Problems with multiple solutions |
+| **Graph of Thought (GoT)** | Reasoning as graph — can merge/refine thoughts | Complex synthesis from multiple sources |
+| **Reflection** | Agent evaluates and critiques its own output | Quality improvement, self-correction |
+
+### ReAct Pattern (Production Standard)
+
+```
+[Thought]: I need to find all TypeScript files that import from auth module
+[Action]: Grep(pattern="from.*auth", glob="**/*.ts")
+[Observation]: Found 23 files
+[Thought]: Now I need to check if any use the deprecated method
+[Action]: Grep(pattern="useDeprecatedAuth", files=<previous results>)
+[Observation]: 5 files use deprecated method
+[Thought]: I have a complete picture. Should create migration plan.
+[Response]: Here is the migration plan for 5 affected files...
+```
+
+---
+
+## Agentic Architecture for Second Brain
+
+### 6-Agent Specialization Model
+
+```
+[Main Orchestrator]
+  |
+  |-- [Capture Agent]     → Monitors sources, ingests content
+  |-- [Curation Agent]    → Connects, tags, classifies notes
+  |-- [Research Agent]    → Searches, navigates, discovers
+  |-- [Synthesis Agent]   → Summarizes, combines, produces
+  |-- [Quality Agent]     → Validates, scores, suggests improvements
+  |-- [Maintenance Agent] → Detects decay, archives, cleans up
+```
+
+**For SINAPSE squads, this maps to:**
+```
+[sinapse-orqx / squad *-orqx]
+  |-- @developer → implementation tasks
+  |-- @quality-gate → validation tasks
+  |-- @architect → design tasks
+  |-- @analyst → research tasks
+```
+
+---
+
+## Task Decomposition Patterns
+
+### Pattern 1: Independence Decomposition
+
+**Goal:** Minimize coordination overhead by creating truly independent subtasks.
+
+```python
+def decompose_for_parallelism(epic):
+    subtasks = []
+    for story in epic.stories:
+        # Check: does this story touch files other stories touch?
+        if not overlaps_with_others(story, epic.stories):
+            subtasks.append(ParallelTask(story))
+        else:
+            subtasks.append(SequentialTask(story))
+    return subtasks
+```
+
+**Claude Code rule:** "If two agents need to communicate more than 3 times during a task, they should probably be one agent."
+
+### Pattern 2: Pipeline Chain
+
+Sequential processing where each stage transforms the output:
+
+```
+Stage 1: Analyze (subagent)
+  → produces: analysis.json (compact artifact)
+  ↓
+Stage 2: Design (subagent)
+  → receives: analysis.json
+  → produces: design.md (compact artifact)
+  ↓
+Stage 3: Implement (subagent)
+  → receives: design.md
+  → produces: code changes
+  ↓
+Stage 4: Review (subagent)
+  → receives: code changes
+  → produces: review verdict
+```
+
+**Key principle:** Each stage produces a **compact artifact** as input to the next. No raw context carried forward.
+
+### Pattern 3: Specialist Routing
+
+```
+Orchestrator classifies task
+  → Database work → @data-engineer agent
+  → UI work → @ux-design-expert agent
+  → API work → @developer agent
+  → Testing → @quality-gate agent
+```
+
+Each specialist has domain-specific instructions and tool permissions focused on their area.
+
+### Pattern 4: Critic-Generator Loop
+
+```
+Generator Agent → produces initial output
+  → Critic Agent → evaluates output
+  → If APPROVED: done
+  → If NEEDS_REVISION: Generator revises (max N iterations)
+  → If BLOCKED: Escalate to human
+```
+
+Used in SINAPSE for story validation (sprint-lead creates → product-lead validates → developer implements → quality-gate reviews).
+
+---
+
+## Parallel Execution Guidelines
+
+### Right-Sizing Agent Teams
+
+| Task Complexity | Team Size | Pattern |
+|----------------|-----------|---------|
+| Simple (< 5 files) | 1 agent | No team needed |
+| Medium (5-15 files) | 2-3 agents | Implement + review |
+| Large (15-50 files) | 3-5 agents | Parallel workers + orchestrator |
+| Epic (50+ files) | 5-8 agents | Full team topology |
+
+**Over-decomposition creates more coordination overhead than parallelism saves.**
+
+### Concurrency Safety Rules
+
+```python
+# From Claude Code source
+class ConcurrencyModel:
+    # Tools default to non-concurrent (assume state mutation)
+    isConcurrencySafe = False
+    
+    # Only mark concurrent-safe when PROVEN independent
+    # Examples of safe: Read(different files), Grep, Glob
+    # Examples of unsafe: Edit(same file), sequential git operations
+```
+
+**CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY** = 10 (default cap).
+
+---
+
+## Swarm Communication Protocols
+
+### Event-Driven Communication
+
+```
+Agent A completes task
+  → Writes result to shared task file
+  → Broadcasts via SendMessageTool("*", "task_complete")
+  → Orchestrator receives notification
+  → Orchestrator routes to next stage
+```
+
+### Mailbox Pattern
+
+```python
+# Worker sends to orchestrator
+SendMessageTool(target="orchestrator", message={
+    "type": "result",
+    "task_id": "auth-module",
+    "status": "complete",
+    "artifacts": ["src/auth/", "tests/auth/"],
+    "verdict": "PASS",
+    "notes": "Found 2 minor issues, both fixed"
+})
+
+# Worker requests permission for dangerous op
+SendMessageTool(target="orchestrator", message={
+    "type": "permission_request",
+    "operation": "delete_legacy_files",
+    "files": ["src/old-auth.ts", "src/auth-v1.ts"],
+    "justification": "Replaced by new implementation"
+})
+```
+
+### Permission Queue (Coordinator Mode)
+
+Workers request authorization for dangerous operations via a queue:
+1. Worker sends permission request to coordinator
+2. Coordinator evaluates (or escalates to human)
+3. Coordinator responds: APPROVE / DENY / MODIFY
+4. Worker proceeds or adjusts plan
+
+**Atomic Claim Mechanism:** `createResolveOnce` prevents duplicate handling of the same request.
+
+---
+
+## BMAD Method Patterns
+
+BMAD (Breakthrough Method for Agile AI-Driven Development) v6 provides patterns SINAPSE can adopt.
+
+### Document Sharding
+
+Large documents split into focused pieces:
+- Standard: ~5,000 tokens per document
+- Sharded: ~300 tokens per shard
+- **74-90% token consumption reduction**
+
+**Applied to SINAPSE PRDs:** Instead of one large PRD.md, shard into:
+- `prd-overview.md` (~300 tokens)
+- `prd-requirements-fr.md` (~300 tokens)
+- `prd-requirements-nfr.md` (~300 tokens)
+- `prd-constraints.md` (~300 tokens)
+- `prd-acceptance-criteria.md` (~300 tokens)
+
+Agents load only the shards they need.
+
+### Party Mode
+
+Multiple agent personas collaborating within a single session — relevant context shared, irrelevant context excluded per persona.
+
+**SINAPSE equivalent:** Each `@agent` activation follows the handoff protocol, compacting previous agent to ~379 tokens.
+
+---
+
+## Guardrails and Governance
+
+### Authority Matrix (SINAPSE)
+
+| Agent | Can Write | Read-Only | Blocked |
+|-------|-----------|-----------|---------|
+| @developer | `packages/`, `src/`, stories (checkboxes) | Everything | `git push`, `gh pr` |
+| @quality-gate | `tests/`, review files | Source code | Write to src/ |
+| @architect | `docs/architecture/` | System-wide | Application code |
+| @devops | Remote operations | Everything | — |
+| @sinapse-orqx | Everything | Everything | — |
+
+### Escalation Protocol
+
+```
+Agent cannot complete task
+  → Escalate to @sinapse-orqx
+  
+Quality gate fails
+  → Return to @developer with specific feedback
+  
+Constitutional violation detected
+  → BLOCK, require fix before proceeding
+  
+Agent boundary conflict
+  → @sinapse-orqx mediates
+```
+
+### Infinite Loop Prevention
+
+```python
+# Maximum iterations per task
+MAX_ITERATIONS = {
+    "qa_loop": 5,
+    "reflection_loop": 3,
+    "research_loop": 10,
+    "synthesis_loop": 3
+}
+
+# Break conditions
+if iteration > max_iterations:
+    raise EscalateToHuman("Max iterations reached")
+
+if delta_tokens < 500 and iterations > 3:
+    early_stop("Diminishing returns detected")
+```
+
+---
+
+## Anti-Patterns
+
+| Anti-pattern | Problem | Fix |
+|-------------|---------|-----|
+| Agent proliferation | Too many agents without clear coordination | One agent per concern, max 8 per epic |
+| Infinite loops | Agents calling each other without stop condition | Max iterations + break conditions |
+| Authority confusion | Multiple agents with authority over same resource | Clear ownership matrix |
+| Skill bloat | Too many overlapping skills | Audit for duplicates quarterly |
+| Over-parallelization | Coordination overhead > parallelism savings | Right-size teams (see table above) |
+| Tight coupling | Agents sharing mutable state | Communication via immutable artifacts only |
+| Bypassing orchestrator | User → specialist directly (multi-squad work) | Always route through orchestrator |

package/squads/squad-cloning/knowledge-base/clone-quality-assurance.md

@@ -0,0 +1,211 @@
+# Clone Quality Assurance — Validacao de Fidelidade Cognitiva
+
+> Metodologia para validar que um clone gerado realmente representa
+> o pensamento do original — e nao uma versao genérica embelezada.
+> Inclui: fidelity scoring, Turing-like validation, e failure detection.
+
+---
+
+## Por Que QA Especifico Para Clones
+
+QA de software verifica se o codigo faz o que foi especificado.
+QA de clone verifica algo mais sutil: se o agente **pensa** como a pessoa original,
+nao apenas se ele **soa** como ela.
+
+A diferenca critica:
+- **Soa como:** Vocabulario correto, tom correto, frases familiares
+- **Pensa como:** Mesmas decisoes, mesmas heuristics, mesmos valores em conflito
+
+Um clone pode ter 100% de score em "soa como" e 40% em "pensa como" —
+isso e um clone de superfície, nao um clone cognitivo.
+
+---
+
+## 4 Dimensoes de Fidelidade
+
+| Dimensao | O que avalia | Peso no score geral |
+|----------|-------------|-------------------|
+| **Cognitiva** | Heuristics e decisoes corretas | 35% |
+| **Comunicativa** | Tom, vocabulario, estilo | 25% |
+| **Processual** | Workflows e metodologias | 25% |
+| **Limitar** | Boundaries e failure modes | 15% |
+
+**Formula:**
+```
+Fidelity Score = (cognitiva × 0.35) + (comunicativa × 0.25) + (processual × 0.25) + (limitar × 0.15)
+```
+
+---
+
+## Validacao Cognitiva — Teste de Decisao
+
+### Protocolo de Decisao Benchmark
+
+1. **Selecionar 5-10 cenarios de decisao** que a pessoa original enfrentou (documentados em fontes)
+2. **Registrar a decisao original** (o que a pessoa realmente fez/disse)
+3. **Apresentar o cenario ao clone** sem mencionar qual foi a decisao
+4. **Comparar resposta do clone** com decisao documentada do original
+5. **Calcular alignment rate**
+
+```
+Cognitiva Score = (decisoes alinhadas / total de cenarios) × 100
+```
+
+### Criterios de Alinhamento
+
+| Alinhamento | Criterio |
+|------------|---------|
+| **Total** | Clone chega a mesma decisao e usa raciocinio similar | 1.0 |
+| **Parcial** | Clone chega a decisao similar mas raciocinio diferente | 0.6 |
+| **Superficial** | Mesma conclusao, raciocinio errado | 0.3 |
+| **Divergente** | Conclusao diferente da original documentada | 0.0 |
+
+### Exemplos de Cenarios Benchmark
+
+Para um clone de especialista em marketing:
+- "Voce tem $50K para lancar um produto. Distribui como?"
+- "Um cliente quer pausar os ads por 30 dias. Voce recomenda?"
+- "Qual canal priorizaria para lancamento B2B vs B2C?"
+
+Comparar cada resposta com o que o original disse em fontes documentadas.
+
+---
+
+## Validacao Comunicativa — Turing-Like Test
+
+### Protocolo de Blind Comparison
+
+1. Gerar 10 respostas do clone para perguntas abertas no dominio
+2. Coletar 10 respostas reais da pessoa (de fontes documentadas, mesmas perguntas aproximadas)
+3. Embaralhar as 20 respostas
+4. Solicitar a 3 avaliadores que identifiquem quais sao do original vs clone
+5. **Taxa de confusao alvo:** >= 40% (avaliadores devem confundir com frequencia)
+
+**Interpretacao:**
+- Confusao >= 60%: Clone de alta fidelidade comunicativa
+- Confusao 40-59%: Clone aceitavel
+- Confusao 20-39%: Clone de superficie — revisar L4
+- Confusao < 20%: Clone falhou — reprocessar Layer 4
+
+### Checklist de Validacao de Tom
+
+- [ ] Nivel de formalidade correspondente (1-5)
+- [ ] Uso de analogias no mesmo estilo
+- [ ] Comprimento medio de resposta similar
+- [ ] Vocabulario caracteristico presente (>=70% das palavras-chave)
+- [ ] Abertura de resposta no mesmo padrao
+- [ ] Fechamento/CTA no mesmo padrao
+- [ ] Uso de dados vs historias na proporcao correta
+
+---
+
+## Validacao Processual — Workflow Compliance
+
+### Protocolo de Workflow Trace
+
+Para cada workflow documentado (L3):
+
+1. **Dar uma tarefa** que deveria ativar o workflow
+2. **Observar se o clone segue os steps** na ordem correta
+3. **Verificar se os outputs intermediarios** correspondem ao documentado
+4. **Verificar se o output final** match o esperado
+
+```
+Processual Score = (workflows seguidos corretamente / total testados) × 100
+```
+
+**Red flag:** Clone pula steps — pode indicar que o workflow foi extraido de forma incompleta
+ou que a heuristic de quando usar o workflow nao foi corretamente mapeada.
+
+---
+
+## Validacao de Limites — Boundary Testing
+
+### Protocolo de Limite
+
+1. **Testar pedidos fora do dominio** do original (deve recusar ou redirecionar)
+2. **Testar topicos que o original evita** (deve replicar o comportamento de evitar)
+3. **Testar areas de incerteza** documentadas (deve admitir, nao inventar)
+
+```
+Limitar Score = (respostas dentro de boundaries / total de testes) × 100
+```
+
+### Casos de Teste de Boundary
+
+| Cenario | Comportamento Esperado | Pass/Fail |
+|---------|----------------------|-----------|
+| Pergunta fora do dominio | Redirecionamento ou recusa explicita | |
+| Topico controverso que evita | Neutralidade ou "nao e minha area" | |
+| Pedido de conselho em area que admitiu ignorancia | Admite limitacao | |
+| Pergunta que contradiz valores documentados | Recusa coerente | |
+
+---
+
+## Score de Fidelidade por Tier
+
+| Score | Interpretacao | Acao |
+|-------|--------------|------|
+| >= 85% | Clone de alta fidelidade | Publicar e deployar |
+| 70-84% | Clone aceitavel com gaps | Documentar gaps, publicar com ressalvas |
+| 55-69% | Clone de superficie | Revisar extracoes, reprocessar L1 e L2 |
+| < 55% | Clone falhou | Voltar ao pipeline, mais fontes necessarias |
+
+### Fidelity Score vs Confidence Score
+
+| Score | O que mede | Quando calcular |
+|-------|-----------|----------------|
+| **Confidence Score** | Qualidade das fontes usadas na extracao | Durante extracao (pre-geração) |
+| **Fidelity Score** | Qualidade do clone gerado | Apos geracao (pos-geração) |
+
+Um clone pode ter confidence score alto (boas fontes) e fidelity score baixo
+(ma geracao). Ambos precisam ser verificados.
+
+---
+
+## Deteccao de Falsos Positivos
+
+Problemas comuns que inflariam o score artificialmente:
+
+### Problema 1: Resposta Genérica Passando por Clone
+**Sintoma:** Clone responde correto mas resposta seria identica para qualquer especialista da area.
+**Detecção:** Testar perguntas onde o original tem opiniao conhecidamente contraria ao mainstream.
+**Exemplo:** Se o original defende "nunca use ads no inicio", o clone deve replicar isso, nao a visao mainstream.
+
+### Problema 2: Estilo Mascarando Lacuna Cognitiva
+**Sintoma:** Tom/vocabulario perfeito mas decisoes erradas.
+**Deteccao:** Focar nos testes de decisao antes dos testes de estilo.
+**Indicador:** Dimensao cognitiva < dimensao comunicativa por 20+ pontos.
+
+### Problema 3: Fabricacao Confiante
+**Sintoma:** Clone responde com confianca em areas sem fontes documentadas.
+**Deteccao:** Testar em areas FORA do corpus de fontes.
+**Regra:** Clone deve declinar ou qualificar fortemente em areas nao documentadas.
+
+---
+
+## Checklist Pre-Publicacao
+
+### Gate 1 — Confidence Score
+- [ ] Confidence >= 60% (Tier 1), 75% (Tier 2), 85% (Tier 3)
+- [ ] L1 e L2 nao estao abaixo de 60% individualmente
+- [ ] Proporcao de [DIRETO] adequada por tier
+
+### Gate 2 — Fidelity Score
+- [ ] Fidelity >= 70% (minimo aceitavel)
+- [ ] Dimensao cognitiva >= 65%
+- [ ] Dimensao limitar >= 70%
+
+### Gate 3 — Integridade
+- [ ] Failure modes documentados (L6)
+- [ ] Nenhum principio ou heuristic marcado como [HIPOTESE] foi promovido a core principle
+- [ ] Fonte de cada core principle identificada
+- [ ] Gaps documentados explicitamente no agent.md
+
+### Gate 4 — Etica
+- [ ] Consent verification (ver `ethical-guidelines.md`)
+- [ ] Declaracao de representacao no agent.md
+- [ ] Limites de uso documentados
+
+Ver tambem: `clone-tier-standards.md` para os criterios minimos por tier.
+Ver tambem: `ethical-guidelines.md` para considerations de consentimento e uso.

package/squads/squad-cloning/knowledge-base/confidence-scoring.md

@@ -95,3 +95,54 @@ Para calibrar o scoring:
 4. Revise: algum [INFERIDO] deveria ser [HIPOTESE]?
 5. Recalcule
 6. Se score surpreende (muito alto ou baixo), revise tags
+
+---
+
+## Confidence Score vs Fidelity Score
+
+Sao metricas distintas que medem coisas diferentes:
+
+| Score | O que mede | Quando calcular | Quem usa |
+|-------|-----------|----------------|---------|
+| **Confidence Score** | Qualidade das fontes (pre-geracao) | Durante extracao | @cognitive-extractor |
+| **Fidelity Score** | Qualidade do clone gerado (pos-geracao) | Apos geracao | @agent-forger + validador |
+
+**Analogia:** Confidence e a qualidade dos ingredientes; fidelidade e a qualidade do prato final.
+
+Um clone pode ter:
+- Confidence alto + Fidelity baixo: boas fontes, mas geracao falhou
+- Confidence baixo + Fidelity alto: fontes fracas, mas o que foi extraido foi bem gerado
+
+**Ambos devem ser >= threshold do tier para publicacao.**
+
+---
+
+## Confidence Decay (Envelhecimento das Extracoes)
+
+O confidence score calculado no momento da extracao pode degradar
+conforme o tempo passa e novas informacoes surgem:
+
+| Situacao | Impacto no confidence |
+|---------|----------------------|
+| Nova fonte confirma [HIPOTESE] | Upgrade para [INFERIDO] |
+| Nova fonte contradiz [DIRETO] | Revisar — possivel evolucao de pensamento |
+| Fonte original removida/deletada | Downgrade por perda de proveniencia |
+| Conteudo tem 3+ anos sem confirmacao recente | Aplicar fator de decay 0.85x |
+
+**Protocolo de re-validacao:** Para clones com mais de 2 anos, re-calcular
+confidence score considerando decay temporal. Ver `source-classification.md`
+para pesos por janela temporal.
+
+---
+
+## Score por Layer — Interpretacao Critica
+
+O score geral esconde distribuicoes que importam:
+
+| Padrao | Diagnostico | Acao |
+|--------|-------------|------|
+| L1 > 85%, L2 < 50% | Clone sabe o que pensa mas nao como decide | Buscar mais conteudo de decisao (entrevistas) |
+| L2 > 85%, L4 < 50% | Clone decide bem mas "nao soa" certo | Buscar mais conteudo de comunicacao |
+| L4 > 85%, L1 < 50% | Clone "soa" mas nao "pensa" — perigoso | Priorizar mais fontes de conteudo analitico |
+| L5 < 30% independente | Meta-patterns insuficientes | Normal em Tier 1, preocupante em Tier 3 |
+| L6 = 0% | Failure modes nao documentados | Obrigatorio para Tier 2+ |