jdi-cli 0.1.0

package/EXTENSION.md

@@ -0,0 +1,141 @@
+# JDI — Extension
+
+Como evoluir o JDI sem inflar. 2 caminhos:
+
+1. **Per-project specialists** (`/jdi-bootstrap`) — gera doer/reviewer customizados pro projeto. Caminho normal.
+2. **Agents/skills genericos no core** (`/jdi-create`) — cria agent ou skill novo no `core/`. So contributors do JDI fonte.
+
+## Caminho 1: `/jdi-bootstrap` (per-project)
+
+Roda no projeto consumindo JDI, apos `/jdi-new`.
+
+```
+cd meu-projeto
+/jdi-new "API REST .NET 10"
+/jdi-bootstrap
+```
+
+Architect modo specialist:
+1. Le `.jdi/PROJECT.md`
+2. Faz 6 perguntas (test framework, build/test commands, coverage min, lint, conventions)
+3. Gera `.jdi/agents/jdi-doer-{slug}.md` e `.jdi/agents/jdi-reviewer-{slug}.md`
+4. Atualiza routing
+5. Commit
+
+Doer/reviewer ficam **pequenos** (~150-200 linhas cada) porque so cobrem 1 stack.
+
+### Multi-stack (frontend + backend)
+
+Atualmente `/jdi-bootstrap` cria 1 doer agregado. Pra projetos com backend + frontend:
+
+**Workaround atual:**
+- Doer agregado conhece ambas stacks (mais verbose, ainda menor que doer 100% generico)
+- OU: rode `/jdi-bootstrap` 2 vezes com slugs distintos (ex: `myapp-backend` + `myapp-frontend`)
+- Doer correto invocado por matching de `files_modified` no PLAN.md (futuro: `/jdi-do` faz routing automatico)
+
+**Roadmap:** multi-doer nativo em versao futura.
+
+## Caminho 2: `/jdi-create` (core)
+
+So contributors do JDI fonte usam. Cria agent ou skill GENERICO no `core/`.
+
+```
+cd /path/to/jdi-source
+/jdi-create "skill com convencoes EF Core 9"
+/jdi-create "specialist pra Rust com cargo + clippy"
+```
+
+Architect modo create:
+1. 8 perguntas (problema, trigger, input, output, reuso, decision-loop, custo, tools)
+2. Classificacao automatica:
+   - `agent` — tem decision loop proprio
+   - `skill` — procedimento reusavel sem loop
+   - `composite` — agent + skill
+3. Validacao com user (approve / edit / cancel)
+4. Geracao em `core/agents/` ou `core/skills/`
+5. Build + install
+6. Commit + audit em `.jdi/registry.md`
+
+## Anti-padroes
+
+Architect bloqueia ou avisa em:
+
+- **Nome generico** ("review-code", "doer", "checker") — pede foco especifico
+- **Specialist por feature** ("auth-specialist") — redireciona pra phase
+- **Skill > 500 linhas estimadas** — sugere agent
+- **Agent sem decision loop** — sugere skill
+- **Soft cap > 15 agents core ou > 25 skills** — avisa, nao bloqueia
+- **Nome colide com agent/skill existente** — obriga renomear
+
+## Quando criar agent vs skill
+
+| Pergunta | Agent | Skill |
+|---|---|---|
+| Tem decision loop? | sim | nao |
+| Multiplos callers? | nao (1 caller fica natural) | sim (varios agents reusam) |
+| Output proprio (file)? | sim | nao (modifica pai) |
+| Privilegios proprios? | sim | herda do pai |
+| Tamanho tipico | 100-500 linhas | 50-200 linhas |
+
+Em duvida -> agent. Refatora pra skill depois se virar reusavel.
+
+## Quando criar specialist vs usar generico
+
+| Cenario | Specialist | Doer generico |
+|---|---|---|
+| Stack conhecida e estavel | x | - |
+| Multi-stack mesmo projeto | x (1 por stack) | - |
+| Convencoes especificas (naming, error handling) | x | - |
+| Codigo legacy com regras unicas | x | - |
+| Projeto experimental, nao definido | - | x |
+| POC rapido (vai jogar fora) | - | x |
+
+JDI default = specialist. Generico eh fallback.
+
+## Checklist pra novo specialist
+
+Apos `/jdi-bootstrap` rodar, conferir:
+
+- [ ] `.jdi/agents/jdi-doer-{slug}.md` existe e tem regras especificas (nao default genericas)
+- [ ] `.jdi/agents/jdi-reviewer-{slug}.md` existe com gates 1-6 customizados
+- [ ] `.jdi/specialists.md` tem linha do doer
+- [ ] `.jdi/reviewers.md` tem linha do reviewer
+- [ ] `.jdi/registry.md` tem entrada R-N audit trail
+- [ ] STATE.md tem `specialists_ready: true`
+
+Se algum falta, rode bootstrap de novo (idempotente — pergunta antes de sobrescrever).
+
+## Checklist pra novo agent core
+
+Apos `/jdi-create` rodar, conferir:
+
+- [ ] `core/agents/jdi-{nome}.md` ou `core/skills/{nome}/SKILL.md` existe
+- [ ] Frontmatter completo (name, description, runtime_intent, tools_canonical, triggers, runtime_overrides)
+- [ ] `<role>`, `<process>`, `<rules>`, `<output>` blocks presentes
+- [ ] Build rodou (runtimes/ tem o agent novo nos 4 runtimes)
+- [ ] Install rodou (runtime ativo tem o agent)
+- [ ] `.jdi/registry.md` tem entrada R-N
+
+## Manutencao
+
+Specialists envelhecem com o projeto (stack muda, conventions evoluem). Pra atualizar:
+
+```
+# Edita manual:
+edit .jdi/agents/jdi-doer-{slug}.md
+
+# OU: regera (perde customizacoes manuais)
+rm .jdi/agents/jdi-doer-{slug}.md
+/jdi-bootstrap
+```
+
+Recomendacao: edita manual pra mudancas pequenas (novas conventions). Regera so se stack mudou drasticamente.
+
+## Limites duros
+
+- Max 5 agents core (atual: 5)
+- Max 4 templates em `core/templates/` (atual: 4)
+- Soft cap 25 skills core (atual: 0 — JDI nao usa skills no core ainda)
+- Per-project: sem limite formal de specialists (mas projeto realista tem 1-3)
+
+JDI cresce **com cuidado**. Se vai passar dos limites, considera fork dedicado em vez de inflar o core.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alison Amorim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MEMORY.md

@@ -0,0 +1,471 @@
+# JDI — State Schema
+
+State em arquivo plano. Sem DB. Sem servidor. Markdown + YAML frontmatter quando precisa.
+
+Decisoes locked ficam em `DECISIONS.md`. Audit trail dos specialists/agents criados ficam em `registry.md`. Aprendizado de phase fica em `SUMMARY.md` e `REVIEW.md` por phase.
+
+## Arvore completa
+
+```
+.jdi/
++-- PROJECT.md           visao + stack + code-design LOCKED. Imutavel apos /jdi-new
++-- ROADMAP.md           phases sequencial, status por linha
++-- STATE.md             current_phase + next_step + flags. Atualizado por comandos
++-- DECISIONS.md         append-only. ADR mini. D-1, D-2, ...
++-- config.json          token/context budget + thresholds. Editavel
++-- specialists.md       routing per-project (gerado por /jdi-bootstrap)
++-- reviewers.md         routing per-project
++-- registry.md          audit trail (R-1, R-2, ...) — tudo que /jdi-create ou /jdi-bootstrap criou
++-- todos.md             scope creep capturado pelo asker (opcional)
++-- agents/              per-project specialists
+|   +-- jdi-doer-{slug}.md
+|   +-- jdi-reviewer-{slug}.md
++-- phases/
+|   +-- 01-setup-api/
+|   |   +-- CONTEXT.md   saida do /jdi-discuss (asker)
+|   |   +-- PLAN.md      saida do /jdi-plan (planner)
+|   |   +-- SUMMARY.md   saida do /jdi-do (doer)
+|   |   +-- REVIEW.md    saida do /jdi-verify (reviewer)
+|   |   +-- LOOP.md      audit trail do /jdi-loop (so se ralph mode foi usado)
+|   +-- 02-...
++-- archive/             phases antigas movidas (opcional)
+```
+
+Nada de `templates-jdi-folder/` copiado pra `.jdi/`. Files sao gerados direto pelos comandos:
+- `/jdi-new` cria PROJECT, ROADMAP, STATE, DECISIONS, config.json, .gitattributes
+- `/jdi-bootstrap` cria specialists.md, reviewers.md, registry.md + agents/*
+
+Excecao: `config.json` eh copiado direto de `templates-jdi-folder/config.json` (defaults estaveis) — `/jdi-new` so copia se ausente. User edita pra customizar budget.
+
+---
+
+## PROJECT.md
+
+```markdown
+# {project_name}
+
+## Visao
+1-3 linhas. O que o projeto resolve.
+
+## Tipo
+web app | cli | api | lib | mobile
+
+## Stack
+- Linguagem: {linguagem + versao}
+- Framework: {framework + versao}
+- Dependencias chave: {lista}
+
+## Code Design
+**LOCKED:** {DDD | Vertical Slice | Hexagonal | Clean | The Method}
+
+Decidido em /jdi-new (D-1). Nao mudar.
+
+## Slug
+{project_slug}     # usado em commits, branches, specialist names
+
+## Research notes (opcional)
+- {fato 1}
+- {fato 2}
+
+## Constraints globais
+- Coverage minimo 80%
+- Conventional Commits
+- Atomic commits por task
+- Idioma: codigo en, discussao pt-BR
+```
+
+**Quem edita:** `/jdi-new` cria. Posterior: edit manual (sem comando dedicado). Agentes nao mexem.
+
+**Tamanho:** max 80 linhas. Conciso.
+
+---
+
+## ROADMAP.md
+
+```markdown
+# {project_name} — Roadmap
+
+## Status
+current_phase: 1
+total_phases: {N}
+
+## Phases
+
+### Phase 1: {nome}
+- **Slug:** 01-{slug}
+- **Status:** done | ready | pending
+- **Goal:** 1 linha
+- **Verdict:** APPROVED | APPROVED_WITH_WARNINGS | BLOCKED  (so apos /jdi-verify)
+```
+
+**Quem edita:** `/jdi-new` cria. `/jdi-ship` atualiza status. `/jdi-discuss` pode editar pra clarificar goal (raro).
+
+---
+
+## STATE.md
+
+```markdown
+# {project_name} — State
+
+project_slug: {slug}
+specialists_ready: true | false
+current_phase: 1
+phase_status: ready | discussed | planned | executed | verified | done | looping | paused | blocked
+phase_verdict: APPROVED | APPROVED_WITH_WARNINGS | BLOCKED  (apos verify)
+next_step: /jdi-discuss 1
+```
+
+**Quem edita:** todos os comandos atualizam apos rodar.
+
+**Lifespan:** sobrescreve a cada commit do orchestrator. Sem historico — git log cobre.
+
+**Status especificos do `/jdi-loop`:**
+- `looping` — `/jdi-loop` em execucao (ralph mode), LOOP.md tem detalhe de iter atual
+- `paused` — user escolheu "Ajustar plano" no human gate, edita PLAN.md/CONTEXT.md e re-roda /jdi-loop
+- `blocked` — `/jdi-verify` retornou BLOCKED OU `/jdi-loop` foi escalated/killed (revisao humana necessaria)
+
+---
+
+## config.json
+
+```json
+{
+  "$schema_version": "1.1",
+  "context_window": 200000,
+  "thresholds": {
+    "warn_pct": 60,
+    "critical_pct": 70
+  },
+  "budgets": {
+    "max_context_chars": 6000,
+    "max_plan_chars": 12000,
+    "max_summary_chars": 8192
+  },
+  "compaction": {
+    "keep_phases": 2,
+    "archive_after": 5
+  },
+  "coverage_min": 80
+}
+```
+
+**Quem edita:** `/jdi-new` escreve direto via Write se ausente (default inline no prompt do comando). `templates-jdi-folder/config.json` eh a referencia canonica do default, shipped pelo pacote npm. User edita manualmente apos. Comandos so leem.
+
+**Campos:**
+- `context_window` — janela do model em uso. 200k = default (Claude Sonnet/Opus). 1_000_000 pra 1M-window models.
+- `thresholds.warn_pct` — quando orchestrator avisa "context aquecendo". Default 60%.
+- `thresholds.critical_pct` — quando orchestrator sugere `/jdi-thread`. Default 70% (zona de fracture, baseado em pesquisa de context rot).
+- `budgets.max_*_chars` — caps usados por commands ao truncar artefatos antes de inline. Heuristica: ~4 chars/token.
+- `compaction.keep_phases` — quantas phases anteriores ficam ativas em `.jdi/phases/`. Resto vai pra `.jdi/archive/`.
+- `compaction.archive_after` — phases acima deste delta movem pra archive (executado por `/jdi-ship`).
+- `coverage_min` — overrideavel por PROJECT.md. Reviewer usa.
+
+**Lifespan:** vida do projeto. Versionado em git.
+
+**Lido por:** `/jdi-do`, `/jdi-plan`, `/jdi-verify`, `/jdi-ship` (para compaction). Specialists (doer/reviewer) leem `coverage_min`.
+
+---
+
+## DECISIONS.md
+
+```markdown
+# {project_name} — Decisoes locked
+
+D-1 (2026-05-09): Code design = Vertical Slice. Justificativa: ...
+D-2 (2026-05-09, phase 1): Tests project setup ja na phase 1. Razao: ...
+D-3 (2026-05-09, phase 1): Connection string via dotnet user-secrets em dev. ...
+D-4 (2026-05-10, phase 2): Validacao via FluentValidation. Razao: ...
+```
+
+**Quem edita:** APPEND-ONLY. `/jdi-new` cria com D-1. `/jdi-discuss` adiciona D-XX por phase.
+
+**Regras:**
+- D-X nunca volta — decisao locked = imutavel
+- Cada D-X tem data + phase (se aplicavel) + justificativa em 1 linha
+
+---
+
+## specialists.md
+
+```markdown
+| Stack | Agent | Trigger |
+|---|---|---|
+| .NET 10 + React 19 (todo-app) | jdi-doer-todo-app | default executor pra phases do todo-app |
+| Rust (rust-cli) | jdi-doer-rust-cli | files *.rs |
+```
+
+**Quem edita:** `/jdi-bootstrap` cria/append. Ou edit manual pra multi-stack.
+
+**Uso:** `/jdi-do N` consulta pra resolver qual doer invocar.
+
+---
+
+## reviewers.md
+
+```markdown
+| Agent | Trigger | Bloqueia ship? |
+|---|---|---|
+| jdi-reviewer-todo-app | /jdi-verify | sim, se BLOCKED |
+```
+
+**Quem edita:** `/jdi-bootstrap` cria/append.
+
+**Uso:** `/jdi-verify N` consulta pra resolver qual reviewer invocar.
+
+---
+
+## registry.md
+
+```markdown
+## R-1 (2026-05-09)
+**Tipo:** specialist (doer + reviewer)
+**Slug:** todo-app
+**Stack:** .NET 10 + React 19
+**Files:** .jdi/agents/jdi-doer-todo-app.md, .jdi/agents/jdi-reviewer-todo-app.md
+
+## R-2 (2026-05-15)
+**Tipo:** agent
+**Nome:** jdi-rust-specialist
+**Criado por:** /jdi-create (no repo JDI)
+**Por que:** demanda real de users com projetos Rust
+**Files:** core/agents/jdi-rust-specialist.md
+**Integration:** .jdi/specialists.md
+```
+
+**Quem edita:** APPEND-ONLY. `/jdi-bootstrap` adiciona R-N. `/jdi-create` adiciona R-N (no repo JDI fonte).
+
+---
+
+## todos.md (opcional)
+
+```markdown
+# Scope creep
+
+- [ ] (phase 2) usuario pediu auth — mover pra phase futura
+- [ ] (phase 3) refactor de N+1 query no GET /todos — issue #42
+```
+
+**Quem edita:** `/jdi-discuss` (asker) append quando user pede coisa fora do escopo.
+
+---
+
+## phases/{NN-slug}/CONTEXT.md
+
+```markdown
+# Phase {N}: {nome} — Context
+
+## Goal (do ROADMAP)
+{texto}
+
+## Decisoes locked desta phase
+
+### D-X: {titulo curto}
+{justificativa 1-3 linhas}
+
+### D-Y: ...
+
+## Canonical refs
+- {url ou path}
+
+## Scope creep capturado em todos.md
+{lista, ou "(nenhum)"}
+```
+
+**Quem edita:** `/jdi-discuss` cria.
+
+**Tamanho:** max 1500 tokens (~80 linhas). Conciso.
+
+---
+
+## phases/{NN-slug}/PLAN.md
+
+```markdown
+# Phase {N}: {nome} — Plan
+
+## Goal
+{do ROADMAP}
+
+## Decisoes locked (do CONTEXT.md)
+- D-X: ...
+- D-Y: ...
+
+## Tasks
+
+### Wave 1 (paralelo possivel)
+
+#### T-{N}.1: {objetivo curto}
+- **Files modified:** `{path1}`, `{path2}`
+- **Acceptance:**
+  - {criterio 1}
+  - {criterio 2}
+- **Dependencies:** none
+- **Test:** {qual teste}
+- **Status:** pending | completed | blocked
+
+### Wave 2
+
+#### T-{N}.2: ...
+  - **Dependencies:** T-{N}.1
+
+## Execution
+- Total tasks: {M}
+- Waves: {W}
+
+## Files modified (todas tasks)
+- {file1}
+- {file2}
+
+## Test requirements
+- {tipo}: {comando}
+- Coverage minimo: {%}
+```
+
+**Quem edita:** `/jdi-plan` cria. `/jdi-do` atualiza `Status:` de cada task.
+
+**Tamanho:** max 200 linhas. Conciso.
+
+---
+
+## phases/{NN-slug}/SUMMARY.md
+
+```markdown
+# Phase {N}: {nome} — Summary
+
+**Status:** complete | partial
+**Tasks:** {done}/{total} completas, {blocked} blocked
+
+## Tasks executadas
+- T-{N}.1: ...
+- T-{N}.2: ...
+
+## Tasks blocked (se houver)
+- T-{N}.X: razao
+
+## Files modified
+- ...
+
+## Tests
+- Backend: dotnet test - {N} passing
+- Frontend: vitest - {N} passing
+- Coverage: {%}
+```
+
+**Quem edita:** `/jdi-do` cria ao final.
+
+---
+
+## phases/{NN-slug}/REVIEW.md
+
+```markdown
+# Phase {N}: Review
+
+**Veredicto:** APPROVED | APPROVED_WITH_WARNINGS | BLOCKED
+
+## Gates
+| Gate | Status | Detalhes |
+|---|---|---|
+| 1. Build | PASS/BLOCK | ... |
+| 2. Tests | PASS/BLOCK | {X}/{Y} passing |
+| 3. Coverage | PASS/BLOCK | {%}, threshold {COVERAGE_MIN}% |
+| 4. Lint | PASS/WARN | ... |
+| 5. Security | PASS/WARN/BLOCK | ... |
+| 6. Consistency | PASS/WARN | ... |
+
+## Blockers (se houver)
+- ...
+
+## Warnings (se houver)
+- ...
+
+## Recomendacao
+{texto curto sobre o que fazer}
+```
+
+**Quem edita:** `/jdi-verify` cria.
+
+---
+
+## phases/{NN-slug}/LOOP.md (opcional, so com /jdi-loop)
+
+```markdown
+---
+phase: {N}
+iter: 3
+total_resets: 1
+status: running | converged | escalated | paused | killed
+max_iter_per_round: 5
+max_resets: 3
+created_at: 2026-05-10T10:30:00-03:00
+---
+
+## History (append-only)
+
+- iter 1: BLOCKED, hash=abc123def4, commit=f8d2a1, ts=2026-05-10T10:31:00-03:00
+- iter 2: BLOCKED, hash=abc123def4, commit=a91c33, ts=2026-05-10T10:33:00-03:00  ← oscillation!
+- iter 3: BLOCKED, hash=de45ef9012, commit=2b3d77, ts=2026-05-10T10:36:00-03:00
+- iter 4: BLOCKED, hash=de45ef9012, commit=8e1c44, ts=2026-05-10T10:38:00-03:00
+- iter 5: BLOCKED, hash=11aa22bb33, commit=4f9e21, ts=2026-05-10T10:40:00-03:00
+--- RESET 1 em 2026-05-10T10:42:00-03:00 ---
+- iter 1: APPROVED_WITH_WARNINGS, hash=00ff11ee22, commit=c1d2e3, ts=2026-05-10T10:45:00-03:00
+```
+
+**Quem edita:** `/jdi-loop` cria/append. Ninguem mais toca.
+
+**Regras:**
+- Frontmatter `iter` + `total_resets` + `status` sao MUTAVEIS (sobrescreve)
+- Bloco `## History` eh APPEND-ONLY (audit trail completo, oscillation detection precisa)
+- `hash` = SHA256 truncado dos blockers/warnings normalizados — pra comparar iter N vs N-1
+- `status: converged` => phase pode prosseguir pra `/jdi-ship`
+- `status: killed` => hard cap atingido, requer revisao humana de PLAN/CONTEXT
+- `status: escalated|paused` => user interveio, re-rodar `/jdi-loop {N}` retoma
+
+**States transitions:**
+```
+running → converged   (verdict APPROVED ou APPROVED_WITH_WARNINGS)
+running → escalated   (user escolheu abort no human gate)
+running → paused      (user escolheu ajustar plan no human gate)
+running → killed      (total_resets >= max_resets)
+escalated|paused → running (re-rodar /jdi-loop retoma)
+```
+
+---
+
+## Niveis de memoria
+
+| Nivel | Arquivo | Lifespan |
+|---|---|---|
+| Projeto | `PROJECT.md` | Vida do projeto (immutable apos /jdi-new) |
+| Roadmap | `ROADMAP.md` | Vida do projeto (atualiza com /jdi-ship) |
+| Config | `config.json` | Vida do projeto, editavel manual |
+| Decisao | `DECISIONS.md` | Append-only, nunca apaga |
+| Routing | `specialists.md`, `reviewers.md` | Append-only |
+| Audit | `registry.md` | Append-only |
+| Sessao | `STATE.md` | Sobrescreve |
+| Phase | `phases/NN/CONTEXT.md`, `PLAN.md`, `SUMMARY.md`, `REVIEW.md` | Vida da phase |
+| Loop | `phases/NN/LOOP.md` | Vida da phase, append-only, so com /jdi-loop |
+| Backlog | `todos.md` | Append-only, opcional |
+
+**Sem MEMORY.md generico (v1).** Era catch-all que ficava bagunçado. Substituido por:
+- DECISIONS.md (decisoes formais)
+- registry.md (criacoes de agents/specialists)
+- SUMMARY.md por phase (aprendizado de execucao)
+- REVIEW.md por phase (warns/blockers como aprendizado)
+
+---
+
+## Read-depth por nivel (token budget)
+
+Regra dura — referencia em `ARCHITECTURE.md > Read-depth scaling`. Resumo aqui pra quem le so MEMORY.md:
+
+| Distancia da phase atual | Read permitido |
+|---|---|
+| Phase atual (`current_phase`) | Corpo inteiro |
+| Phase anterior (`current_phase - 1`) | Frontmatter + veredict do REVIEW apenas |
+| `<= current_phase - 2` | Nao ler corpo. Listar/`head` apenas |
+| `.jdi/archive/` | Tratar como phase distante. Nao ler corpo |
+
+PROJECT.md, ROADMAP.md, DECISIONS.md, config.json: leitura full **permitida** sempre — sao curtos por design e estaveis (bons candidatos a prompt cache prefix).
+
+Excecoes:
+- `jdi-asker` le ate 2 CONTEXT.md anteriores (regra do agent)
+- `jdi-verify N` le PLAN.md de phase N-1 se task atual referencia `D-XX` daquela phase (rastreabilidade)