@jaimevalasek/aioson 1.8.0 → 1.9.0

package/docs/pt/living-memory/autonomy-contract.md

@@ -0,0 +1,206 @@
+# Autonomy Contract — 3 tiers de autonomia
+
+> O Autonomy Contract responde uma pergunta operacional: **o agente pode rodar este comando sozinho, ou precisa parar e pedir?** A resposta vive em `.aioson/config/autonomy-protocol.json` (schema v1.1) e é materializada nas configurações nativas de cada harness (Claude Code, Codex, Gemini, OpenCode).
+
+## A ideia em uma linha
+
+Cada comando do AIOSON e cada padrão de shell entra em **um e apenas um** tier. O tier dita o UX:
+
+| Tier | Intenção | UX | Exemplos |
+|---|---|---|---|
+| `tier1_silent` | Leitura, telemetria interna | sem notificação | `git status`, `aioson preflight`, `aioson context:health`, `agent:done` |
+| `tier2_notified` | Mudanças em memória do framework | auto + notify inline (ℹ) | `memory:reflect-prepare/commit`, `workflow:next`, `dossier:*`, `notify` |
+| `tier3_blocking` | Operações irreversíveis ou externas | bloqueia, pede humano (⛔) | `git push`, `npm publish`, `cloud:publish:*`, `genome:publish` |
+
+A invariante mais importante: **tier 3 nunca é materializado em allow list de tool**, mesmo se um tool listar `tier3_blocking` em `derived_from_tiers`. O generator filtra hard. Operação irreversível sempre exige humano.
+
+## O arquivo canônico
+
+`.aioson/config/autonomy-protocol.json`:
+
+```json
+{
+  "version": "1.1",
+  "global_mode": "guarded",
+  "tiers": {
+    "tier1_silent": {
+      "description": "Read-only and internal telemetry. Auto-execute without notification.",
+      "shell_patterns": ["git diff *", "git log *", "git status", "ls *", "cat *", ...],
+      "aioson_commands": ["preflight", "context:health", "memory:status", "agent:done", "doctor", ...]
+    },
+    "tier2_notified": {
+      "description": "Changes to framework memory. Auto-execute plus inline notify.",
+      "shell_patterns": [],
+      "aioson_commands": ["memory:reflect-prepare", "memory:reflect-commit", "workflow:next", "notify", ...],
+      "write_paths": [
+        ".aioson/context/bootstrap/**",
+        ".aioson/context/features/**",
+        ".aioson/runtime/**"
+      ]
+    },
+    "tier3_blocking": {
+      "description": "Irreversible or external operations. Block and require human action.",
+      "shell_patterns": ["git push *", "rm -rf *", "npm publish *", "curl * | sh"],
+      "aioson_commands": ["cloud:publish:*", "genome:publish", "skill:publish", "squad:publish"]
+    }
+  },
+  "tools": {
+    "claude":   { "mode": "trusted",  "derived_from_tiers": ["tier1_silent", "tier2_notified"], "requires_tty": false, "max_auto_retries": 3 },
+    "codex":    { "mode": "trusted",  "derived_from_tiers": ["tier1_silent", "tier2_notified"], "requires_tty": false, "max_auto_retries": 3 },
+    "gemini":   { "mode": "guarded",  "derived_from_tiers": ["tier1_silent"],                    "requires_tty": true,  "max_auto_retries": 1 },
+    "opencode": { "mode": "guarded",  "derived_from_tiers": ["tier1_silent"],                    "requires_tty": true,  "max_auto_retries": 0 }
+  },
+  "agents": {
+    "committer": { "max_mode": "guarded" }
+  }
+}
+```
+
+Cada tool opta nos tiers via `derived_from_tiers`. Claude e Codex podem rodar tier 1 e 2 sem perguntar. Gemini e OpenCode só rodam tier 1 (rest é guarded — pergunta antes).
+
+## Como vira permissão nativa por harness
+
+Toda vez que `aioson update` ou `aioson setup` roda, o `permissions-generator` lê o protocol e escreve 4 arquivos:
+
+| Harness | Arquivo gerado | Formato | Merge |
+|---|---|---|---|
+| Claude Code | `.claude/settings.json` | JSON (`permissions.allow[]`) | Merge com entradas existentes (preserva customizações) |
+| Codex CLI | `.codex/permissions.json` | JSON nativo | Sobrescreve (com backup) |
+| Gemini CLI | `.gemini/permissions.toml` | TOML | Sobrescreve (com backup) |
+| OpenCode | `.opencode/permissions.yaml` | YAML | Sobrescreve (com backup) |
+
+A versão anterior é sempre salva em `.aioson/backups/{timestamp}/permissions/`.
+
+### Claude Code — conversão de patterns
+
+`.claude/settings.json` usa `Bash(<spec>)` para cada regra. O generator converte:
+
+| Pattern original | Vira |
+|---|---|
+| `git diff *` | `Bash(git diff:*)` |
+| `git status` (exato, sem `*`) | `Bash(git status)` |
+| `aioson preflight` (comando) | `Bash(aioson preflight:*)` |
+| `cloud:publish:*` (tier 3) | **não aparece** |
+
+Resultado típico para um claude trusted:
+
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(git diff:*)",
+      "Bash(git log:*)",
+      "Bash(git status)",
+      "Bash(ls:*)",
+      "Bash(cat:*)",
+      "...",
+      "Bash(aioson preflight:*)",
+      "Bash(aioson memory:reflect-prepare:*)",
+      "Bash(aioson workflow:next:*)",
+      "..."
+    ]
+  }
+}
+```
+
+Note que padrões tier 3 (`git push`, `npm publish`) **não estão na lista**. Cada vez que o agente tenta rodar um deles, Claude pergunta. Esse é o ponto.
+
+### Gemini / OpenCode
+
+Modo `guarded` por padrão. Só tier 1 é auto-aprovado. Tudo o resto pergunta. Adequado para harnesses com TTY interativo onde o usuário acompanha cada ação.
+
+## Notify — o canal visual
+
+Sempre que tier 2 dispara, o AIOSON pode chamar:
+
+```bash
+aioson notify . --level=info --topic=memory --message="Atualizando bootstrap após mudança em src/routes/"
+```
+
+Saída:
+
+```
+ℹ [memory] Atualizando bootstrap após mudança em src/routes/
+```
+
+Três níveis, três prefixos, dois exit codes:
+
+| Level | Prefixo | Exit code | Uso típico |
+|---|---|---|---|
+| `info` | ℹ | 0 | tier 2 disparou, agente acompanha |
+| `warn` | ⚠ | 0 | algo merece atenção (bootstrap stale, drift) |
+| `block` | ⛔ | 2 | tier 3 acionado — script wrapper precisa pausar |
+
+Internamente, `notify` chama `runtime:emit` (registra em `agent_events` como `notify_<level>`) e renderiza. A telemetria fica para o dashboard ou queries SQL.
+
+Detalhes completos em [notificacoes-info](./notificacoes-info.md).
+
+## Adicionar um comando a um tier
+
+Se você criou um comando novo (`aioson foo:bar`) e quer que ele rode sozinho em Claude e Codex:
+
+1. Edite `template/.aioson/config/autonomy-protocol.json`:
+
+```json
+"tier1_silent": {
+  ...
+  "aioson_commands": [
+    "...",
+    "foo:bar"   // se for read-only
+  ]
+}
+```
+
+ou:
+
+```json
+"tier2_notified": {
+  ...
+  "aioson_commands": [
+    "...",
+    "foo:bar"   // se muda algo em .aioson/
+  ]
+}
+```
+
+2. Rode em qualquer projeto consumidor:
+
+```bash
+aioson update .
+```
+
+O hook do installer chama `permissions-generator` e regenera os 4 arquivos nativos. O comando passa a aparecer no allow list de cada harness aplicável.
+
+**Nunca adicione a `tier3_blocking` por conveniência.** Esse tier é a barreira de segurança. Se um comando precisa rodar sozinho, ele vai em tier 1 ou tier 2.
+
+## Backward-compat com v1.0
+
+Projetos com `autonomy-protocol.json` versão 1.0 (sem o bloco `tiers`, com `shell_whitelist` e `aioson_whitelist` por tool) continuam funcionando. O generator detecta a versão:
+
+- v1.1 com `tiers` + `derived_from_tiers` → união dos tiers (tier 3 filtrado)
+- v1.0 ou v1.1 sem `derived_from_tiers` → cai nos `*_whitelist` legados do tool
+
+Não há migration forçada. `aioson update` regenera com o que estiver lá.
+
+## Diagnóstico — drift detection
+
+`aioson doctor` (Fase 4) checa se os 4 arquivos nativos estão em sync com o protocol:
+
+```bash
+$ aioson doctor .
+...
+[FAIL] Native harness permissions are in sync with autonomy-protocol.json (2 drifted, 0 missing)
+  Hint: Run `aioson doctor . --fix` to regenerate: .claude/settings.json, .codex/permissions.json.
+```
+
+`doctor --fix` chama `permissions-generator` e regenera. Backup do anterior fica em `.aioson/backups/`.
+
+## Ambiente vs config
+
+O Autonomy Contract não substitui as decisões do **usuário** no harness. Se você roda `claude --no-permissions` ou desabilita o allow list manualmente, o AIOSON respeita — ele só **escreve** o arquivo. Quem aplica é o harness.
+
+## Continue lendo
+
+- [Reflexão In-Harness](./reflexao-in-harness.md) — tier 2 em ação
+- [Notificações inline](./notificacoes-info.md) — detalhes de levels e exit codes
+- [Troubleshooting](./troubleshooting.md) — drift de permissions, tier 3 disparou, etc.

package/docs/pt/living-memory/diagramas.md

@@ -0,0 +1,365 @@
+# Diagramas — Memória Viva em ASCII
+
+> Fluxos canônicos da feature. ASCII porque renderiza em qualquer terminal, qualquer Markdown viewer, e qualquer diff. Mermaid fica para quando o leitor precisa de cor.
+
+---
+
+## 1. Ciclo completo de uma sessão com reflexão
+
+```
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  Usuário                                                                     │
+│  ───────                                                                     │
+│  /dev "adicionar paginação em /api/posts"                                    │
+└─────────────────────────────────┬────────────────────────────────────────────┘
+                                  │
+                                  ▼
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  Agente @dev (Claude Code / Codex / Gemini / OpenCode)                       │
+│  ──────────                                                                  │
+│  1. Lê .aioson/config.md                                                     │
+│  2. Lê .aioson/context/project.context.md                                    │
+│  3. Lê .aioson/context/dev-state.md (foco + pacote de contexto)              │
+│  4. Lê bootstrap/how-it-works.md + bootstrap/current-state.md                │
+│  5. Implementa, testa, commita                                               │
+│  6. Chama: aioson agent:done . --agent=dev --summary="paginação"             │
+└─────────────────────────────────┬────────────────────────────────────────────┘
+                                  │
+                                  ▼
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  src/commands/runtime.js#runAgentDone                                        │
+│  ────────────────────────────────────                                        │
+│  • Registra agent_done no SQLite                                             │
+│  • [hook] best-effort: runMemoryReflectPrepare({...})                        │
+│      try { ... } catch { /* ignore — never blocks */ }                       │
+└─────────────────────────────────┬────────────────────────────────────────────┘
+                                  │
+                                  ▼
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  src/memory-reflect-engine.js#evaluate                                       │
+│  ──────────────────────────────────────                                      │
+│  git diff --name-only HEAD~3..HEAD →                                         │
+│     ['src/routes/api/posts.js', 'features.md', 'tests/posts.test.js']        │
+│  Classify:                                                                   │
+│     ✓ routes/controllers touched (1)                                         │
+│     ✓ features.md changed                                                    │
+│  verdict = 'relevant'                                                        │
+└─────────────────────────────────┬────────────────────────────────────────────┘
+                                  │
+                                  ▼
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  buildPrompt → escreve .aioson/runtime/reflect-prompt.json                   │
+│  ──────────────────────────────────────────────────────────                  │
+│  {                                                                           │
+│    "session_id": "...",                                                      │
+│    "targets": ["how-it-works.md", "what-it-does.md", "current-state.md"],    │
+│    "current_bootstrap_snapshot": { ... },                                    │
+│    "snapshot_hash": "237721bf...",                                           │
+│    "validation_rules": { allowed_paths: [...] }                              │
+│  }                                                                           │
+│  + emit memory_reflect_prepared                                              │
+└─────────────────────────────────┬────────────────────────────────────────────┘
+                                  │
+                                  ▼ próxima sessão
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  Agente entra (mesmo agente ou outro)                                        │
+│  ─────────────────────────────────────                                       │
+│  Step 0: detecta .aioson/runtime/reflect-prompt.json                         │
+│  Seção "Memory reflection" do agent.md instrui:                              │
+│    1. Lê o manifest                                                          │
+│    2. Edita os 3 targets em bootstrap/* preservando frontmatter,             │
+│       atualizando generated_at                                               │
+│    3. Monta { "files": { "<rel>": "<content>", ... } }                       │
+│    4. Roda: aioson memory:reflect-commit . --agent=<você> --output=<json>    │
+└─────────────────────────────────┬────────────────────────────────────────────┘
+                                  │
+                                  ▼
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  memory:reflect-commit → engine.validate                                     │
+│  ───────────────────────────────────────                                     │
+│  ✓ frontmatter present                                                       │
+│  ✓ generated_at bumped                                                       │
+│  ✓ content differs from snapshot                                             │
+│  ✓ all paths in allowed_paths                                                │
+│  ✓ snapshot_hash matches (no concurrent edit)                                │
+│  → Write bootstrap/*.md                                                      │
+│  → Delete reflect-prompt.json                                                │
+│  → Emit memory_reflect_committed                                             │
+└──────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 2. Hook em `workflow:next --complete`
+
+```
+aioson workflow:next . --complete=dev
+        │
+        ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│ finalizeCurrentStage(dev)                                           │
+│  • valida handoff contract                                          │
+│  • roda gates técnicos                                              │
+│  • grava last-handoff.json + handoff-protocol.json                  │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │
+                       ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│ [hook Living Memory] best-effort                                    │
+│   try {                                                             │
+│     await runMemoryReflectPrepare({ agent: 'dev', json: true });    │
+│   } catch { /* never block workflow */ }                            │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │
+                       ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│ activateStage(next agent)                                           │
+│  • monta activation.prompt                                          │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │
+                       ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│ [hook Living Memory] se reflect-prompt.json existe:                 │
+│   activation.prompt =                                               │
+│     "ℹ [memory] reflect-prompt.json pending — before any other       │
+│      action, read .aioson/runtime/reflect-prompt.json and run        │
+│      `aioson memory:reflect-commit . --agent=<next> --output=<>`     │
+│      per your Memory Reflection section.\n\n"                       │
+│     + activation.prompt                                             │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │
+                       ▼
+                logger.log(activation.prompt)
+```
+
+---
+
+## 3. Geração de permissões nativas (Autonomy Contract)
+
+```
+.aioson/config/autonomy-protocol.json                  (canonical)
+                  │
+                  │ aioson update . / aioson setup .
+                  ▼
+        src/permissions-generator.js
+                  │
+                  │ resolveToolSets(protocol, tool)
+                  │   • lê derived_from_tiers
+                  │   • UNION de shell_patterns + aioson_commands
+                  │   • HARD-REJECT tier3_blocking
+                  │
+        ┌─────────┼─────────┬─────────────┐
+        ▼         ▼         ▼             ▼
+   ┌────────┐ ┌──────┐ ┌────────┐  ┌──────────┐
+   │ Claude │ │ Codex│ │ Gemini │  │ OpenCode │
+   │ JSON   │ │ JSON │ │ TOML   │  │ YAML     │
+   │ (merge │ │ (over│ │ (over- │  │ (over-   │
+   │ user)  │ │ -wr) │ │ write) │  │ write)   │
+   └────┬───┘ └──┬───┘ └───┬────┘  └────┬─────┘
+        │       │         │            │
+        │       │         │            │  backup do anterior
+        │       │         │            ├──────────────────────┐
+        ▼       ▼         ▼            ▼                      ▼
+   .claude/    .codex/   .gemini/   .opencode/      .aioson/backups/
+   settings    permis-   permis-    permis-          {timestamp}/
+   .json       sions     sions      sions            permissions/
+               .json     .toml      .yaml             └── <tool>/
+                                                          └── <file>
+
+Invariante:
+─────────────
+"Mesmo se um tool listar 'tier3_blocking' em derived_from_tiers,
+ nenhum pattern de tier 3 aparece no output."
+
+Tier 3 SEMPRE exige humano:
+  • git push *
+  • git reset --hard *
+  • rm -rf *
+  • npm publish *
+  • curl * | sh
+  • cloud:publish:*
+  • genome:publish, skill:publish, squad:publish
+```
+
+---
+
+## 4. Ciclo de `doctor --fix`
+
+```
+$ aioson doctor . --fix
+        │
+        ▼
+┌──────────────────────────────────────────────────────────────────┐
+│ runDoctor(targetDir)                                             │
+│  └─ checks[]                                                     │
+│      ├─ file:* (required files)              [severity: error]   │
+│      ├─ design-governance:* (design docs)    [severity: error]   │
+│      ├─ gateway:* (CLAUDE/AGENTS/etc.)       [severity: error]   │
+│      ├─ context:* (project.context.md)       [severity: error]   │
+│      ├─ node:version                         [severity: error]   │
+│      ├─ living-memory:bootstrap_coverage     [severity: warning] │
+│      ├─ living-memory:features_dir           [severity: warning] │
+│      ├─ living-memory:claude_commands        [severity: warning] │
+│      ├─ living-memory:version_drift          [severity: warning] │
+│      └─ living-memory:permissions_in_sync    [severity: warning] │
+│                                                                  │
+│  report.ok = errorCount === 0                                    │
+│  (warnings count em failedCount mas não bloqueiam ok)            │
+└────────────────────────┬─────────────────────────────────────────┘
+                         │
+                         ▼
+┌──────────────────────────────────────────────────────────────────┐
+│ applyDoctorFixes(targetDir, report)                              │
+│  ├─ required_files:        restore from template                 │
+│  ├─ gateway_contracts:     restore from template                 │
+│  ├─ design_governance:     restore from template                 │
+│  ├─ locale_sync:           apply locale to agent prompts         │
+│  ├─ claude_commands:       restore .claude/commands/aioson/*     │
+│  ├─ features_dir:          mkdir .aioson/context/features/       │
+│  ├─ permissions_in_sync:   generatePermissions(targetDir)        │
+│  ├─ bootstrap_coverage:    [advisory] sugere /discover           │
+│  └─ version_drift:         [advisory] sugere npm i / edit ctx    │
+└────────────────────────┬─────────────────────────────────────────┘
+                         │
+                         ▼
+                Re-run runDoctor(targetDir)
+                         │
+                         ▼
+              Print updated report + summary
+```
+
+---
+
+## 5. Anatomia do manifest (`reflect-prompt.json`)
+
+```
+┌────────────────────────────────────────────────────────────────────────┐
+│ reflect-prompt.json                                                    │
+│ ───────────────────                                                    │
+│                                                                        │
+│  version: 1                                                            │
+│  session_id: "dev-2026-05-11T14:30:00.123Z"                            │
+│  trigger_agent: "dev"                                                  │
+│  git_range: "HEAD~3..HEAD"                                             │
+│                                                                        │
+│  heuristic_verdict: "relevant"      ┐                                  │
+│  heuristic_reasons: [               │ ← saída do engine.evaluate       │
+│    "routes/controllers ...",        │                                  │
+│    "features.md changed"            │                                  │
+│  ]                                  ┘                                  │
+│                                                                        │
+│  targets: [                         ┐ ← decidido por                   │
+│    "how-it-works.md",               │   chooseTargetsFromSignals       │
+│    "current-state.md"               │                                  │
+│  ]                                  ┘                                  │
+│                                                                        │
+│  current_bootstrap_snapshot: {      ┐ ← foto agora dos                 │
+│    "what-is.md": "...",             │   4 bootstrap/*.md               │
+│    "how-it-works.md": "...",        │                                  │
+│    "what-it-does.md": "...",        │                                  │
+│    "current-state.md": "..."        │                                  │
+│  }                                  ┘                                  │
+│                                                                        │
+│  snapshot_hash: "237721bf..."       ← SHA-256(snapshot)                │
+│                                       usado para detectar              │
+│                                       concorrência no commit           │
+│                                                                        │
+│  diff_summary: "7 files, +142/-28"                                     │
+│  changed_files: [...]                                                  │
+│  instructions: "Edit only: ..."                                        │
+│                                                                        │
+│  validation_rules: {                                                   │
+│    must_have_frontmatter: true,                                        │
+│    must_update_generated_at: true,                                     │
+│    must_diff_content: true,                                            │
+│    allowed_paths: [                ┐ ← barreira dura no                │
+│      ".aioson/context/bootstrap/   │   commit: escrita fora            │
+│        how-it-works.md",           │   é rejeitada                     │
+│      ".aioson/context/bootstrap/   │                                   │
+│        current-state.md"           │                                   │
+│    ]                               ┘                                   │
+│  }                                                                     │
+│                                                                        │
+│  generated_at: "2026-05-11T14:30:00.123Z"                              │
+└────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 6. Severity model do doctor
+
+```
+                    ┌─────────────────────────────────────┐
+                    │  runDoctor() returns                │
+                    └─────────────┬───────────────────────┘
+                                  │
+              ┌───────────────────┼───────────────────┐
+              ▼                   ▼                   ▼
+        ┌──────────┐        ┌──────────┐       ┌─────────────┐
+        │ checks[] │        │ failed   │       │ ok          │
+        │          │        │ Count    │       │ (boolean)   │
+        │ todos os │        │          │       │             │
+        │ checks   │        │ errors + │       │ errorCount  │
+        │          │        │ warnings │       │  === 0      │
+        └──────────┘        └──────────┘       └─────────────┘
+                                                      ▲
+                                                      │ warnings NÃO afetam
+                                                      │ → backward-compat com
+                                                      │   testes que esperavam
+                                                      │   ok=true pós-install
+                                                      │
+        ┌─────────────────────────────────────────────┴─────────────┐
+        │ Existing checks → severity = 'error' (implicit)           │
+        │   file:*, design-governance:*, gateway:*, context:*, node │
+        │                                                           │
+        │ Living Memory checks → severity = 'warning'               │
+        │   living-memory:bootstrap_coverage                        │
+        │   living-memory:features_dir                              │
+        │   living-memory:claude_commands                           │
+        │   living-memory:version_drift                             │
+        │   living-memory:permissions_in_sync                       │
+        └───────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 7. Telemetria — eventos emitidos
+
+```
+                    .aioson/runtime/aios.sqlite
+                              │
+                              │ agent_events.event_type
+                              ▼
+   ┌──────────────────────────────────────────────────────────────┐
+   │                                                              │
+   │  memory_reflect_prepared     ← manifest escrito              │
+   │  memory_reflect_skipped      ← heurística disse skip         │
+   │  memory_reflect_committed    ← agente terminou com sucesso   │
+   │  memory_reflect_failed       ← validação rejeitou            │
+   │                                                              │
+   │  notify_info                 ← aioson notify --level=info    │
+   │  notify_warn                 ← aioson notify --level=warn    │
+   │  notify_block                ← aioson notify --level=block   │
+   │                                                              │
+   └──────────────────────────────────────────────────────────────┘
+                              │
+                              │ consumido por
+                              ▼
+              ┌─────────────────────────────────┐
+              │  AIOSON Dashboard (app sep.)    │
+              │   /logs                         │
+              │   linha do tempo por feature    │
+              │                                 │
+              │  sqlite3 queries diretas        │
+              │  aioson runtime:logs (futuro)   │
+              └─────────────────────────────────┘
+```
+
+---
+
+## Continue lendo
+
+- [Memória Viva](./memoria-viva.md) — o conceito
+- [Reflexão In-Harness](./reflexao-in-harness.md) — pipeline detalhada
+- [Autonomy Contract](./autonomy-contract.md) — tiers e harnesses
+- [Troubleshooting](./troubleshooting.md) — quando algo não bate