forjajs 1.1.3 → 1.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,165 @@
1
+ # Plan: doctor-do-nucleo
2
+
3
+ - **Spec**: ./spec.md
4
+ - **Status**: done
5
+ - **Criado em**: 2026-07-13
6
+
7
+ > Como vamos construir o que a spec define. Sem código aqui — só estrutura e decisões.
8
+
9
+ ## 1. Abordagem técnica
10
+
11
+ **Extend, não rewrite.** O `tools-doctor.mjs` já tem a forma certa — uma lista declarativa
12
+ (`TOOLS[]`) percorrida por um runner burro. Erramos no *conteúdo* da lista, não na estrutura.
13
+
14
+ Extraímos os checks para `lib/core/health.mjs` como **dados** (`CHECKS[]`), com um runner que os
15
+ executa e devolve resultados estruturados. O `tools-doctor` vira uma das três superfícies de
16
+ apresentação; `SessionStart` vira outra. Nenhuma superfície tem heurística própria — é justamente
17
+ isso que permitiu, hoje, uma delas prescrever a correção errada sozinha.
18
+
19
+ A mudança central de comportamento é **parar de colapsar causas distintas num booleano**. Hoje
20
+ `hook-session-start.mjs:38-45` faz `catch { return null }`, engolindo *sem `node_modules`*,
21
+ *ABI incompatível* e *banco ausente* no mesmo `null` — e a linha 91 prescreve a correção de apenas
22
+ uma das três. Cada probe passa a **classificar a causa** e devolver a correção dela.
23
+
24
+ ## 2. Módulos afetados
25
+
26
+ | Caminho | Mudança | Risco |
27
+ |---|---|---|
28
+ | `lib/core/health.mjs` | **criar** — `CHECKS[]` + runner. Fonte única de verdade | M |
29
+ | `scripts/tools-doctor.mjs` | editar — consome a lib; ganha seção Núcleo + exit code | M |
30
+ | `scripts/hook-session-start.mjs` | editar — remove heurística própria (`resolveDbPath`, `staleIndex`) e a prescrição errada | A |
31
+ | `lib/core/registry.mjs` | editar — `desc` do `tools:doctor` reflete o novo papel | B |
32
+ | `scripts/spec-cli.mjs` | editar — `spec:new` mantém a allow-list do `.gitignore` (AC-11) | B |
33
+ | `test/health.test.js` | **criar** — cada check nos dois estados | B |
34
+ | `memory/90-decisions/0023-doctor-como-gate-do-nucleo.md` | **criar** — ADR | B |
35
+ | `CLAUDE.md`, `docs/` | editar — `tools:doctor` deixa de ser "raio-x de ferramentas" | B |
36
+
37
+ Risco alto no hook: ele roda em **toda** sessão e o ADR-0021 já o marcou como "nunca pode derrubar
38
+ a sessão". Qualquer regressão ali é sentida imediatamente e em todo lugar.
39
+
40
+ ## 3. Diagrama de fluxo
41
+
42
+ ```
43
+ tools:doctor ────┐
44
+ SessionStart ────┼──► lib/core/health.mjs :: runChecks({ scope })
45
+ release-auditor ─┘ │
46
+ ▼
47
+ ┌──────────────── CHECKS[] (declarativo) ────────────────┐
48
+ │ id severity scope dependsOn │
49
+ │ native-abi critical runtime — │
50
+ │ memory-db critical runtime native-abi │
51
+ │ memory-fresh warn runtime memory-db │
52
+ │ workspace warn runtime — │
53
+ │ node-engines warn runtime — │
54
+ │ runtime-deps critical repo — │
55
+ │ mcp-json critical repo — │
56
+ └────────────────────────────────────────────────────────┘
57
+ │
58
+ Result[] { id, status, detail, fix, severity }
59
+ │
60
+ ┌───────────────────┴───────────────────┐
61
+ ▼ ▼
62
+ doctor: 2 seções + exit(1) se hook: só scope=runtime,
63
+ algum critical falhou sempre exit(0), warn no contexto
64
+ ```
65
+
66
+ **Cascata (`dependsOn`)** é o que evita o pior modo de falha de um diagnóstico: com o ABI quebrado,
67
+ `memory-db` e `memory-fresh` também falhariam, e o operador veria **três** erros sem saber qual é a
68
+ raiz. Um check cujo `dependsOn` falhou é reportado como `skipped`, não como `fail`. Uma causa, uma
69
+ linha vermelha, uma correção.
70
+
71
+ ## 4. Contratos (API/CLI/Schema)
72
+
73
+ ```js
74
+ // lib/core/health.mjs
75
+
76
+ /** @typedef {'critical'|'warn'} Severity */
77
+ /** @typedef {'runtime'|'repo'} Scope */
78
+ /** @typedef {'ok'|'warn'|'fail'|'skipped'} Status */
79
+ /** @typedef {{ id, title, severity: Severity, scope: Scope, dependsOn?: string, probe }} Check */
80
+ /** @typedef {{ id, title, severity, status: Status, detail: string, fix: string|null }} Result */
81
+
82
+ export const CHECKS;
83
+
84
+ /** Executa os checks. `scope: 'runtime'` roda só os baratos e portáveis (hook). */
85
+ export async function runChecks(opts); // { scope = 'all', env } -> Promise<Result[]>
86
+
87
+ /** 'fail' se algum critical falhou; senão 'warn' se houver warn; senão 'ok'. */
88
+ export function worstStatus(results); // -> 'ok' | 'warn' | 'fail'
89
+ ```
90
+
91
+ O `probe` recebe um **ambiente injetável** (`env = { root, importModule, fs, workspace }`) e devolve
92
+ `{ status, detail, fix }`. Nunca lança: o runner o envolve em try/catch e converte exceção
93
+ inesperada em `fail` — um check que estoura ao diagnosticar é pior que check nenhum (NFR).
94
+
95
+ **CLI** — `tools:doctor` mantém nome e entrada no registry (ADR-0020). Muda o contrato de saída:
96
+
97
+ | Situação | Antes | Depois |
98
+ |---|---|---|
99
+ | Tudo são | `exit 0` | `exit 0` |
100
+ | Ferramenta opcional ausente | `exit 0` | `exit 0` *(ADR-0018 preservado)* |
101
+ | Índice defasado / workspace ausente | — | `exit 0` + aviso |
102
+ | **Núcleo quebrado** | `exit 0` | **`exit 1`** + correção |
103
+
104
+ ## 5. Decisões e alternativas
105
+
106
+ **D1: Checks como dados, não como funções que imprimem.** Permite três superfícies com uma lógica
107
+ só. Alternativa rejeitada: cada superfície chama helpers e formata do seu jeito — é literalmente o
108
+ que temos hoje, e é a causa da divergência entre o que o doctor diz e o que o hook diz.
109
+
110
+ **D2: Probes classificam a causa; o runner nunca colapsa em booleano.** `ERR_DLOPEN_FAILED` →
111
+ `npm rebuild better-sqlite3`. `ERR_MODULE_NOT_FOUND` → `npm install`. Banco ausente →
112
+ `npm run sync:universal`. Alternativa rejeitada: manter `catch → null` e só melhorar o texto da
113
+ mensagem — daria uma prescrição *genérica*, e o problema de hoje foi precisamente uma prescrição
114
+ genérica aplicada a um caso específico.
115
+
116
+ **D3: `scope: repo | runtime`.** `runtime-deps` e `mcp-json` são checks de **regressão do
117
+ repositório** — não fazem sentido numa instalação `npm i -g forjajs`, onde não há `devDependencies`
118
+ instaladas nem `.mcp.json` versionado. Rodá-los fora do repo produziria falso positivo crítico no
119
+ ambiente do usuário final. Detecção: presença de `.git` + `package.json` com `name: forjajs`.
120
+
121
+ **D4: Só `critical` trava.** `workspace` ausente e `node-engines` abaixo do declarado entram como
122
+ `warn`, não `fail` — o framework funciona sem workspace (só `project:new` não). Um gate que reprova
123
+ o que não impede trabalho é um gate que se aprende a ignorar (risco nº 1 da spec).
124
+
125
+ **D5: Injeção de dependência no probe (`env`).** Testar ABI quebrada exigiria mockar o loader de
126
+ módulos do Node. Com `env.importModule` injetável, o teste passa uma função que lança
127
+ `ERR_DLOPEN_FAILED` e verifica a prescrição — sem mock de módulo, sem corromper `node_modules`.
128
+
129
+ **D6: Doctor diagnostica, não conserta.** Sem `--fix`. Rodar `npm rebuild` sem consentimento é a
130
+ classe de risco oposta à que estamos consertando (spec §5, fora de escopo).
131
+
132
+ D1, D3 e a mudança de contrato de exit code são estruturais → **ADR-0023**
133
+ (`memory/90-decisions/0023-doctor-como-gate-do-nucleo.md`), referenciando ADR-0018 (que ele estende)
134
+ e ADR-0021 (a classe de falha que ele fecha).
135
+
136
+ ## 6. Dependências
137
+
138
+ - **Specs**: nenhuma. Fecha a classe do ADR-0021; não depende de spec aberta.
139
+ - **Pacotes npm**: **nenhum novo.** Tudo com `node:fs`, `node:path` e o `better-sqlite3` que já é
140
+ `dependency`. Adicionar dependência a um módulo cujo propósito é funcionar quando as dependências
141
+ quebram seria autodestrutivo.
142
+ - **Migrações**: nenhuma. Nada de schema, nada de dado.
143
+
144
+ ## 7. Rollout
145
+
146
+ - [ ] Feature flag necessária? **Não.** A mudança é aditiva, exceto pelo exit code — que só passa a
147
+ falhar em ambiente que **já está** quebrado.
148
+ - [ ] Migração de dados existentes? **Não.**
149
+ - [x] Doc/persona impactada? `CLAUDE.md` (tabela de comandos) e `docs/` onde `tools:doctor` é
150
+ descrito como "raio-x de ferramentas". Persona **qa/governança** ganha gate novo.
151
+ - [ ] **Ordem de merge**: `lib/core/health.mjs` + testes primeiro (nada consome ainda), depois as
152
+ superfícies. O hook por último — é o de maior risco e o único que roda sempre.
153
+ - [ ] Validar com `npm run tools:doctor` num Node de major diferente (o cenário de hoje) **antes**
154
+ de fechar. Um doctor de ABI que nunca viu um ABI quebrado não está testado, está escrito.
155
+
156
+ ## 8. Sinais de fracasso (kill criteria)
157
+
158
+ - **O hook fica lento ou instável.** Ele roda em toda sessão e não pode derrubá-la (ADR-0021). Se
159
+ `runChecks({ scope: 'runtime' })` não couber com folga no timeout de 5s, o hook volta a ter
160
+ caminho próprio (mínimo, ainda consumindo a lib) em vez de arrastarmos o custo para toda sessão.
161
+ - **`runtime-deps` vira ruído.** Se o parser estático de imports gerar falso positivo crítico mais
162
+ de uma vez, ele é rebaixado a `warn` — a spec já prevê isso no risco, e um crítico que mente é
163
+ pior que um warning honesto.
164
+ - **O operador passa a rodar `tools:doctor` já sabendo o resultado.** Se o gate vira ritual, erramos
165
+ a calibragem de severidade e voltamos a D4.
@@ -0,0 +1,139 @@
1
+ # Spec: doctor-do-nucleo
2
+
3
+ - **ID**: SPEC-009
4
+ - **Status**: done
5
+ - **Owner**: apk
6
+ - **Criado em**: 2026-07-13
7
+ - **Sprint alvo**: S?
8
+ - **ADRs relacionadas**: [ADR-0018](../../memory/90-decisions/0018-ferramentas-de-processo.md) (tools:doctor), [ADR-0021](../../memory/90-decisions/0021-guardrails-de-harness.md) (guardrails de harness), [ADR-0019](../../memory/90-decisions/0019-workspace-separado.md) (workspace), [ADR-0009](../../memory/90-decisions/0009-claude-hooks-token-economy.md) (economia de tokens)
9
+
10
+ ## 1. Problema
11
+
12
+ O `tools:doctor` audita cinco ferramentas **externas e opcionais** e conclui com a própria
13
+ ressalva: *"ferramentas ausentes apenas desativam seus gates — o fluxo nunca trava por elas."*
14
+ Ele diagnostica exatamente aquilo que não é crítico, e é cego para tudo que é.
15
+
16
+ Em 2026-07-13, com `better-sqlite3` compilado contra o ABI do Node 24 num runtime Node 26,
17
+ a memória universal — a aposta nº 1 da visão, *"memória que sobrevive"* — estava **morta**:
18
+ `query:universal`, `sync:universal`, `context:smart`, `agent:route`, `memory:compress` e
19
+ `project:dashboard` todos inoperantes. O framework reagiu assim:
20
+
21
+ | Superfície | O que fez | O que deveria ter feito |
22
+ |---|---|---|
23
+ | `tools:doctor` | Reportou `2/5 ferramentas disponíveis`, tudo aparentemente normal | Falhar apontando o ABI quebrado |
24
+ | `SessionStart` | Detectou, mas prescreveu `npm install` + `sync:universal` | Prescrever `npm rebuild better-sqlite3` |
25
+ | `npm test` | Stack trace de `ERR_DLOPEN_FAILED` | — (aceitável, mas sem orientação) |
26
+
27
+ A prescrição errada é o pior dos três. `npm install` **não** recompila binário nativo quando o
28
+ lock já bate; quem seguisse a instrução do próprio framework não consertaria nada e concluiria
29
+ que o problema era outro.
30
+
31
+ Esta é a **quinta ocorrência** da classe de falha que o ADR-0021 nomeia — *"erram sem avisar…
32
+ produzem trabalho errado com aparência de trabalho certo"*. As quatro anteriores receberam
33
+ correções pontuais. Falta o gate genérico: **nada valida o núcleo do framework**, e dois dos
34
+ quatro casos já corrigidos (`.mcp.json` com path absoluto; `better-sqlite3` fora de
35
+ `dependencies`) podem reincidir sem que nenhum teste ou gate perceba.
36
+
37
+ ## 2. Proposta de valor
38
+
39
+ Uma única fonte de verdade sobre a saúde do núcleo, consumida por todas as superfícies de
40
+ diagnóstico: **toda quebra do núcleo é detectada na primeira vez que o operador toca o
41
+ framework, com o comando de correção correto ao lado.**
42
+
43
+ ## 3. User stories
44
+
45
+ - **Como** operador, **quero** que `tools:doctor` falhe quando o núcleo está quebrado,
46
+ **para que** eu não descubra por um stack trace de `dlopen` trinta minutos depois.
47
+ - **Como** operador que trocou de versão do Node, **quero** a prescrição certa
48
+ (`npm rebuild better-sqlite3`), **para que** eu não perca tempo seguindo um conselho errado
49
+ do próprio framework.
50
+ - **Como** agente iniciando sessão, **quero** saber que a memória está defasada ou morta antes
51
+ de confiar num `query:universal`, **para que** eu não construa raciocínio sobre contexto vazio.
52
+ - **Como** governança, **quero** um gate que reprove um release em que os invariantes do
53
+ ADR-0021 regrediram, **para que** as correções pontuais não se percam com o tempo.
54
+ - **Como** autor de uma spec do framework, **quero** que ela seja versionada por padrão,
55
+ **para que** eu não a perca sem aviso — hoje o `.gitignore` a descarta calado.
56
+
57
+ ## 4. Critérios de aceite (Definition of Done)
58
+
59
+ - [x] AC-1: Existe `lib/core/health.mjs` exportando os checks de núcleo como dados
60
+ (`{ id, severity, probe, fix }`), sem I/O de apresentação.
61
+ - [x] AC-2: `tools:doctor` reporta **duas seções** — Núcleo e Ferramentas — e sai com código
62
+ **≠ 0** se e somente se algum check `critical` do núcleo falhar. Ausência de ferramenta
63
+ opcional continua sendo `exit 0` (contrato do ADR-0018 preservado).
64
+ - [x] AC-3: Check de **ABI nativa**: com `better-sqlite3` compilado para outro `NODE_MODULE_VERSION`,
65
+ o doctor falha com a mensagem apontando `npm rebuild better-sqlite3`. Testável simulando
66
+ o `ERR_DLOPEN_FAILED`.
67
+ - [x] AC-4: Check de **memória**: distingue os três estados — banco ausente, banco inacessível,
68
+ banco defasado (`memory/` alterado depois do último sync) — cada um com sua correção.
69
+ - [x] AC-5: Check de **workspace**: `lib/workspace.mjs` resolve para diretório existente; se não,
70
+ prescreve `npm run workspace:init`.
71
+ - [x] AC-6: Check de **deps de runtime** (regressão do ADR-0021 §2): todo módulo importado
72
+ estaticamente por scripts sob `files[]` está em `dependencies`, não em `devDependencies`.
73
+ - [x] AC-7: Check de **`.mcp.json`** (regressão do ADR-0021 §1): nenhum path absoluto versionado.
74
+ - [x] AC-8: O hook `SessionStart` consome `lib/core/health.mjs` — **zero heurística própria** — e
75
+ a prescrição errada atual (`npm install`) deixa de existir no código.
76
+ - [x] AC-9: Testes cobrindo cada check nos dois estados (são e quebrado), com a suíte verde.
77
+ - [x] AC-10: ADR registrando a decisão (doctor como gate do núcleo vs. relatório de ferramentas).
78
+ - [x] AC-11: `spec:new` **mantém a allow-list do `.gitignore` sozinho** ao criar uma spec do
79
+ framework. Criar uma spec e rodar `git status` passa a mostrá-la, sem passo manual.
80
+ *(Emenda de 2026-07-13 — ver §5.)*
81
+
82
+ ## 5. Escopo
83
+
84
+ **Dentro**:
85
+ - `lib/core/health.mjs` — os checks como dados, reutilizáveis.
86
+ - `scripts/tools-doctor.mjs` — passa a consumir a lib; ganha seção de núcleo e exit code.
87
+ - `scripts/hook-session-start.mjs` (ou equivalente) — passa a consumir a lib.
88
+ - Os sete checks: ABI nativa, banco presente, banco fresco, workspace resolvido, deps de runtime,
89
+ `.mcp.json` limpo, Node vs. `engines`.
90
+ - `scripts/spec-cli.mjs` — allow-list do `.gitignore` mantida pelo harness (AC-11).
91
+ - ADR + testes.
92
+
93
+ > **Emenda (2026-07-13).** Ao escrever o plano, descobrimos que o `.gitignore` ignora `/specs/*` e
94
+ > mantém uma allow-list manual: **toda spec nova do framework nasce invisível ao git**. O `spec:new`
95
+ > cria, o `spec:check` aprova, e o git descarta calado — aconteceu com esta própria spec. É a mesma
96
+ > classe de falha do ADR-0021, dentro da ferramenta que estamos consertando.
97
+ >
98
+ > Rejeitamos resolver isso com um *check* no doctor (`spec-allowlist` → warn): trocaria uma falha
99
+ > silenciosa por um lembrete recorrente que se aprende a ignorar. Seguimos o próprio ADR-0021 —
100
+ > *"mover a aplicação das regras do texto para o harness"* — e fazemos o `spec:new` manter a lista.
101
+ > A classe de erro deixa de existir em vez de ser reportada.
102
+
103
+ **Fora** (explícito, evita scope creep):
104
+ - **Autocorreção.** O doctor diagnostica e prescreve; não executa `npm rebuild` sozinho.
105
+ Rodar comandos de build sem consentimento é a classe de risco oposta.
106
+ - Novos gates de qualidade de código (lint, cobertura) — não é sobre isso.
107
+ - Alterar o conjunto das cinco ferramentas opcionais do ADR-0018.
108
+ - Reindexação automática da memória (`sync:universal` permanece explícito).
109
+
110
+ ## 6. NFRs / restrições
111
+
112
+ - **Performance**: o doctor completo roda em < 2s. O `SessionStart` não pode ficar perceptivelmente
113
+ mais lento — os checks caros (deps, `.mcp.json`) só entram no doctor, não no hook.
114
+ - **Resiliência**: todo acesso a SQLite permanece *lazy* (ADR-0021). O doctor precisa funcionar
115
+ **sem `node_modules`** — é justamente aí que ele mais importa. Um check que estoura ao
116
+ diagnosticar é pior que check nenhum.
117
+ - **Contrato**: `exit 0` continua significando "posso trabalhar". Ferramenta opcional ausente
118
+ nunca trava; núcleo quebrado sempre trava.
119
+ - **Compatibilidade**: o comando `tools:doctor` mantém nome, entrada no registry (ADR-0020) e
120
+ saída legível.
121
+
122
+ ## 7. Riscos e mitigação
123
+
124
+ | Risco | Probabilidade | Impacto | Mitigação |
125
+ |---|---|---|---|
126
+ | Doctor vira gate ruidoso e o operador aprende a ignorá-lo | M | A | Só `critical` trava. Warning (índice defasado) informa sem falhar |
127
+ | Check de deps de runtime dá falso positivo (import dinâmico, opcional) | M | M | Parser estático conservador: na dúvida, warning e não erro |
128
+ | Detecção de ABI depende de string de erro do Node | M | M | Casar por `err.code === 'ERR_DLOPEN_FAILED'`, não por mensagem |
129
+ | Doctor duplica o que o `release-auditor` já faz | B | B | Agente simula tarball (pré-publicação); doctor valida o repo vivo. `release-auditor` pode passar a consumir a mesma lib |
130
+ | Escopo escorrega para "doctor conserta tudo" | M | A | Autocorreção está explicitamente fora |
131
+
132
+ ## 8. Métricas de sucesso
133
+
134
+ - **Zero** falhas silenciosas da classe ADR-0021 nos 30 dias após o release: toda quebra do núcleo
135
+ aparece no primeiro comando executado, não num sintoma indireto.
136
+ - Tempo entre quebrar o ambiente (ex.: trocar a major do Node) e ter o diagnóstico correto em mãos:
137
+ de *indefinido* (hoje o operador é ativamente mal orientado) para **um comando**.
138
+ - Os quatro invariantes já corrigidos pelo ADR-0021 passam a ter cobertura executável — regressão
139
+ em qualquer um deles reprova o gate em vez de reaparecer em produção.
@@ -0,0 +1,172 @@
1
+ # Tasks: doctor-do-nucleo
2
+
3
+ - **Spec**: ./spec.md
4
+ - **Plan**: ./plan.md
5
+ - **Status**: done
6
+ - **Criado em**: 2026-07-13
7
+
8
+ > Decomposição executável. Cada task tem dono claro, critério de done e referência a arquivos.
9
+
10
+ Convenção de IDs: `T1`, `T2`, … A sequência reflete a **ordem de merge do plano §7**: a lib e os
11
+ testes primeiro (nada a consome ainda), depois as superfícies, e o hook por último — é o de maior
12
+ risco e o único que roda em toda sessão.
13
+
14
+ ---
15
+
16
+ ## T1 — Runner e contrato de `lib/core/health.mjs`
17
+ - **Owner**: Worker
18
+ - **Estimativa**: M
19
+ - **Depende de**: —
20
+ - **Paths**: `lib/core/health.mjs`, `test/health.test.js`
21
+ - **Escopo**: o esqueleto sem nenhum probe real — `CHECKS[]` vazio ou com um probe de fixture.
22
+ - **Done quando**:
23
+ - [x] `runChecks({ scope, env })` e `worstStatus(results)` exportados conforme plano §4 (AC-1)
24
+ - [x] Cascata: check com `dependsOn` que falhou é reportado `skipped`, nunca `fail`
25
+ - [x] Runner blinda o probe: probe que **lança** vira `fail` com o erro no `detail`, e o runner
26
+ continua os demais — nunca propaga exceção (NFR de resiliência)
27
+ - [x] `worstStatus` só devolve `fail` para `critical`; `warn` nunca escala
28
+ - [x] `env` injetável (`{ root, importModule, fs, workspace }`) com default real (D5)
29
+ - [x] `test/health.test.js` cobre cascata, blindagem e `worstStatus` com probes de fixture
30
+ - [x] Zero dependências novas (plano §6)
31
+
32
+ ## T2 — Probes de memória: `native-abi`, `memory-db`, `memory-fresh`
33
+ - **Owner**: Worker
34
+ - **Estimativa**: M
35
+ - **Depende de**: T1
36
+ - **Paths**: `lib/core/health.mjs`, `test/health.test.js`
37
+ - **Escopo**: os três checks que teriam pego a quebra de hoje. É o núcleo do núcleo.
38
+ - **Done quando**:
39
+ - [x] `native-abi` (critical) classifica por `err.code`, **não** por string de mensagem (risco da
40
+ spec): `ERR_DLOPEN_FAILED` → `npm rebuild better-sqlite3`; `ERR_MODULE_NOT_FOUND` →
41
+ `npm install` (AC-3)
42
+ - [x] `memory-db` (critical, `dependsOn: native-abi`) distingue **ausente** de **inacessível**,
43
+ cada um com sua correção (AC-4)
44
+ - [x] `memory-fresh` (**warn**, `dependsOn: memory-db`): `memory/` alterado depois do último sync
45
+ → `npm run sync:universal`. Reaproveita a lógica de `newestMemoryMtime` que hoje vive no
46
+ hook (AC-4)
47
+ - [x] Teste do ABI quebrado injeta `env.importModule` que lança `ERR_DLOPEN_FAILED` — sem mock de
48
+ módulo, sem corromper `node_modules` (D5)
49
+ - [x] Cada probe testado nos dois estados: são e quebrado (AC-9)
50
+
51
+ ## T3 — Probes de ambiente: `workspace`, `node-engines`
52
+ - **Owner**: Worker
53
+ - **Estimativa**: P
54
+ - **Depende de**: T1
55
+ - **Paths**: `lib/core/health.mjs`, `test/health.test.js`
56
+ - **Done quando**:
57
+ - [x] `workspace` (**warn**, D4) usa `getWorkspaceInfo()` de `lib/workspace.mjs`; se não resolve
58
+ para diretório existente → `npm run workspace:init`. Reporta também a **origem** da
59
+ resolução (`FORJA_WORKSPACE` / `~/.forjarc.json` / default), que é metade do diagnóstico
60
+ quando o workspace certo existe mas não é o que está sendo usado (AC-5)
61
+ - [x] `node-engines` (**warn**) compara `process.versions.node` com `engines.node` do
62
+ `package.json`
63
+ - [x] Ambos testados nos dois estados via `env.fs` / `env.workspace` injetados
64
+
65
+ ## T4 — Probes de regressão do repo: `runtime-deps`, `mcp-json`
66
+ - **Owner**: Worker
67
+ - **Estimativa**: M
68
+ - **Depende de**: T1
69
+ - **Paths**: `lib/core/health.mjs`, `test/health.test.js`
70
+ - **Escopo**: converte em gate executável os dois invariantes que o ADR-0021 corrigiu à mão e que
71
+ hoje podem reincidir sem que nada perceba.
72
+ - **Done quando**:
73
+ - [x] Ambos com `scope: 'repo'` — **não** rodam fora do repo do framework, onde produziriam falso
74
+ positivo crítico na máquina do usuário final (D3). Detecção: `.git` + `package.json` com
75
+ `name: forjajs`
76
+ - [x] `runtime-deps` (critical): todo módulo importado **estaticamente** por script sob `files[]`
77
+ está em `dependencies`, não em `devDependencies` (AC-6). Parser **conservador**: import
78
+ dinâmico ou não resolvido → `warn`, nunca `fail` (risco da spec)
79
+ - [x] `mcp-json` (critical): nenhum path absoluto versionado em `.mcp.json` (AC-7)
80
+ - [x] Teste com fixture de `package.json`/`.mcp.json` quebrados, via `env.fs` e `env.root`
81
+ - [x] Teste garantindo que ambos são `skipped` quando `scope: 'runtime'`
82
+
83
+ ## T5 — `tools:doctor` consome a lib e vira gate
84
+ - **Owner**: Worker
85
+ - **Estimativa**: M
86
+ - **Depende de**: T2, T3, T4
87
+ - **Paths**: `scripts/tools-doctor.mjs`
88
+ - **Done quando**:
89
+ - [x] Duas seções na saída: **Núcleo** e **Ferramentas** (AC-2)
90
+ - [x] `exit 1` **se e somente se** algum check `critical` do núcleo falhar. Ferramenta opcional
91
+ ausente segue `exit 0` — contrato do ADR-0018 preservado (AC-2, D4)
92
+ - [x] `TOOLS[]` das cinco ferramentas opcionais permanece intocado (spec §5, fora de escopo)
93
+ - [x] Cada falha imprime o comando de correção ao lado
94
+ - [x] Roda em < 2s (NFR)
95
+ - [x] Funciona **sem `node_modules`** — é justamente aí que ele mais importa (NFR)
96
+
97
+ ## T6 — `SessionStart` consome a lib e perde a heurística própria
98
+ - **Owner**: Worker
99
+ - **Estimativa**: M
100
+ - **Depende de**: T2, T3
101
+ - **Paths**: `scripts/hook-session-start.mjs`
102
+ - **Escopo**: a task de maior risco. O hook roda em toda sessão e o ADR-0021 o marcou como "nunca
103
+ pode derrubar a sessão".
104
+ - **Done quando**:
105
+ - [x] `resolveDbPath()` e `staleIndex()` **deixam de existir** — o `catch { return null }` que
106
+ colapsa três causas distintas é a raiz do problema (plano §1)
107
+ - [x] A prescrição errada (`npm install` para ABI quebrado, linha 91) não existe mais no código
108
+ (AC-8)
109
+ - [x] Chama `runChecks({ scope: 'runtime' })` — zero heurística própria (AC-8)
110
+ - [x] **Sempre `exit 0`**: o hook reporta, nunca trava a sessão (ADR-0021)
111
+ - [x] Cabe com folga no timeout de 5s; se não couber, ver kill criteria do plano §8
112
+ - [x] `test/hooks.test.js` estendido: sem `node_modules` o hook degrada, não estoura
113
+
114
+ ## T7 — ADR-0023
115
+ - **Owner**: SDD Architect
116
+ - **Estimativa**: P
117
+ - **Depende de**: T5, T6
118
+ - **Paths**: `memory/90-decisions/0023-doctor-como-gate-do-nucleo.md`
119
+ - **Done quando**:
120
+ - [x] Registra D1 (checks como dados), D3 (`scope` repo/runtime) e a mudança de contrato do exit
121
+ code (AC-10)
122
+ - [x] Referencia ADR-0018 (que estende) e ADR-0021 (a classe de falha que fecha)
123
+ - [x] Segue `memory/90-decisions/_template.md`
124
+
125
+ ## T8 — Registry e documentação
126
+ - **Owner**: Worker
127
+ - **Estimativa**: P
128
+ - **Depende de**: T5
129
+ - **Paths**: `lib/core/registry.mjs`, `CLAUDE.md`, `docs/`
130
+ - **Done quando**:
131
+ - [x] `desc` do `tools:doctor` no registry reflete o novo papel (deixa de ser só "ferramentas de
132
+ processo")
133
+ - [x] `CLAUDE.md` e `docs/` onde o comando é descrito como "raio-x de ferramentas"
134
+ - [x] `npm test` verde, incluindo `test/forja-core.test.js` (integridade do registry, ADR-0020)
135
+
136
+ ## T9 — Validação no cenário real
137
+ - **Owner**: Governance
138
+ - **Estimativa**: P
139
+ - **Depende de**: T5, T6, T7, T8
140
+ - **Paths**: —
141
+ - **Done quando**:
142
+ - [x] `tools:doctor` roda sob um Node de **major diferente** e reporta o ABI quebrado com a
143
+ prescrição certa. Um doctor de ABI que nunca viu um ABI quebrado não está testado, está
144
+ escrito (plano §7)
145
+ - [x] `npm run project:check` e `npm test` verdes
146
+ - [x] `gitleaks detect --no-banner` limpo
147
+ - [x] Suíte completa verde (AC-9); spec → `done`
148
+
149
+ ## T10 — `spec:new` mantém a allow-list do `.gitignore`
150
+ - **Owner**: Worker
151
+ - **Estimativa**: P
152
+ - **Depende de**: — *(independente da lib; pode ir primeiro)*
153
+ - **Paths**: `scripts/spec-cli.mjs`, `test/spec-cli.test.js`
154
+ - **Contexto**: descoberto ao escrever o plano. O `.gitignore` ignora `/specs/*` e mantém uma
155
+ allow-list manual; **toda spec nova do framework nasce invisível ao git**. Aconteceu com esta
156
+ própria spec. Emenda de 2026-07-13 à spec (AC-11).
157
+ - **Done quando**:
158
+ - [x] `spec:new <slug>` acrescenta `!/specs/<slug>` ao bloco de allow-list do `.gitignore`
159
+ - [x] **Idempotente**: rodar duas vezes não duplica a linha
160
+ - [x] Insere **dentro do bloco existente** (após a última `!/specs/…`), não no fim do arquivo —
161
+ as regras seguintes do `.gitignore` dependem da ordem
162
+ - [x] Se o bloco não existir (ou o `.gitignore` sumir), **não falha** a criação da spec: avisa e
163
+ segue. Criar spec é o trabalho; manter o gitignore é o efeito colateral
164
+ - [x] Teste: cria spec num `.gitignore` de fixture e verifica a linha, a idempotência e a posição
165
+ - [x] `git status` mostra a spec recém-criada, sem passo manual (AC-11)
166
+
167
+ ---
168
+
169
+ ## Handoffs entre agentes
170
+
171
+ Este conjunto atravessa Worker (T1-T6, T8, T10), SDD Architect (T7) e Governance (T9). Registrar
172
+ handoff a cada fronteira via `npm run agent:route` — 7 campos obrigatórios (ADR-0005).
@@ -0,0 +1,174 @@
1
+ # Plan: release-gate
2
+
3
+ - **Spec**: ./spec.md
4
+ - **Status**: done
5
+ - **Criado em**: 2026-07-14
6
+
7
+ > Como vamos construir o que a spec define. Sem código aqui — só estrutura e decisões.
8
+
9
+ ## 1. Abordagem técnica
10
+
11
+ **O runner já existe.** `runChecks({ checks, env })` em `lib/core/health.mjs` foi escrito genérico
12
+ — recebe a lista de checks por parâmetro e já é exercitado com fixtures nos testes. O gate de
13
+ release não precisa de máquina nova: precisa de **outro catálogo de checks** rodando na mesma
14
+ máquina.
15
+
16
+ Então extraímos o runner para `lib/core/checks.mjs` e deixamos dois catálogos: `health.mjs` (o
17
+ núcleo, fronteira *repo*) e `release.mjs` (o tarball, fronteira *pacote publicado*). Mesma
18
+ severidade, mesma cascata, mesmo contrato de `fix`. Uma máquina, duas fronteiras.
19
+
20
+ A diferença essencial em relação ao doctor: o gate de release **não inspeciona; ele instala**. Grep
21
+ não prova ausência — instalação prova. O `release-auditor` já diz isso, e é a razão de o gate ser
22
+ lento e de tudo bem ser lento.
23
+
24
+ ## 2. Módulos afetados
25
+
26
+ | Caminho | Mudança | Risco |
27
+ |---|---|---|
28
+ | `lib/core/checks.mjs` | **criar** — runner extraído de `health.mjs` (`runChecks`, `worstStatus`) | M |
29
+ | `lib/core/health.mjs` | editar — passa a importar o runner; re-exporta para não quebrar consumidores | M |
30
+ | `lib/core/release.mjs` | **criar** — catálogo dos checks de tarball | M |
31
+ | `scripts/release-check.mjs` | **criar** — apresentação + exit code | B |
32
+ | `lib/core/registry.mjs` | editar — `release:check` (ADR-0020) | B |
33
+ | `package.json` | editar — `prepublishOnly` | **A** |
34
+ | `.github/workflows/ci.yml` | editar — steps `tools:doctor` e `release:check` | B |
35
+ | `.claude/agents/release-auditor.md` | reescrever — consome o gate, não reimplementa | B |
36
+ | `test/release.test.js` | **criar** — os três bugs históricos como fixture | B |
37
+
38
+ Risco alto no `prepublishOnly`: se ele falhar indevidamente, **ninguém consegue publicar**. É o
39
+ único ponto onde um falso positivo trava a operação inteira em vez de só incomodar.
40
+
41
+ ## 3. Diagrama de fluxo
42
+
43
+ ```
44
+ npm run release:check [--publish]
45
+ │
46
+ ▼
47
+ ┌─ preflight ───────────────────────────────────────┐
48
+ │ árvore limpa? --publish → fail senão → warn │ ← v1.1.1 morreu aqui
49
+ └───────────────────────────────────────────────────┘
50
+ │
51
+ ▼
52
+ npm pack → /tmp/forja-release-<pid>/
53
+ │
54
+ ▼
55
+ npm init + npm i <tgz> (isolado: sem NODE_PATH, sem node_modules do repo)
56
+ │
57
+ ▼
58
+ ┌──────────── RELEASE_CHECKS[] (lib/core/release.mjs) ──────────┐
59
+ │ id severity o que prova │
60
+ │ tree-clean critical* tarball == commit (*warn sem --publish)
61
+ │ install critical o pacote instala do zero │
62
+ │ registry-scripts critical os 41 comandos existem no tarball │
63
+ │ smoke-commands critical os comandos EXECUTAM (não só help) │
64
+ │ reprova por stderr, não exit code │
65
+ │ deps-declared critical importado ⊆ dependencies │
66
+ │ deps-unused warn dependency que ninguém importa │
67
+ │ imports-resolve critical import relativo resolve no tarball │
68
+ └───────────────────────────────────────────────────────────────┘
69
+ │
70
+ ▼
71
+ re-check árvore limpa ← a aprovação é perecível
72
+ │
73
+ ▼
74
+ exit 0 / exit 1 + limpa o /tmp
75
+ ```
76
+
77
+ ## 4. Contratos (API/CLI/Schema)
78
+
79
+ ```js
80
+ // lib/core/checks.mjs — o runner, sem opinião sobre o que checa
81
+ export async function runChecks(opts); // { checks, scope, env } -> Result[]
82
+ export function worstStatus(results); // -> 'ok' | 'warn' | 'fail'
83
+
84
+ // lib/core/health.mjs — inalterado para quem consome
85
+ export { runChecks, worstStatus } from './checks.mjs'; // re-export: tools-doctor e o hook seguem iguais
86
+ export const CHECKS; // os 7 do núcleo
87
+
88
+ // lib/core/release.mjs
89
+ export const RELEASE_CHECKS;
90
+ export async function withCleanInstall(fn); // empacota, instala isolado, executa, limpa. Sempre limpa.
91
+ ```
92
+
93
+ **CLI**:
94
+
95
+ | Comando | Árvore suja | Uso |
96
+ |---|---|---|
97
+ | `npm run release:check` | `warn` | Dev quer o smoke test sem commitar. Reprova o resto normalmente. |
98
+ | `npm run release:check -- --publish` | **`fail`** | `prepublishOnly` e CI de release. |
99
+
100
+ A distinção existe porque um gate que reprova todo desenvolvimento local vira um gate que se
101
+ contorna — a lição que o CI nos deu na SPEC-009, quando `memory-db` reprovava qualquer clone novo.
102
+ Mas na hora de publicar, árvore suja é **fatal**: foi assim que `otplib` e `qrcode` entraram na
103
+ v1.1.1 sem existirem no git.
104
+
105
+ ## 5. Decisões e alternativas
106
+
107
+ **D1: Extrair o runner em vez de duplicá-lo.** `health.mjs` já tem cascata, blindagem de probe e
108
+ `worstStatus` testados. Copiar tudo para `release.mjs` criaria duas máquinas que divergem com o
109
+ tempo — exatamente o defeito que a SPEC-009 matou quando o doctor e o hook divergiram. Alternativa
110
+ rejeitada: `release.mjs` importar de `health.mjs`, deixando o núcleo dono de um runner que não é
111
+ dele.
112
+
113
+ **D2: Instalar, não inspecionar.** O gate faz `npm pack` + `npm i` de verdade. Alternativa
114
+ rejeitada: análise estática do tarball — foi o que eu fiz à mão hoje e produziu **falso positivo
115
+ imediato** (os geradores contêm `import` dentro de template string). Grep não prova ausência.
116
+
117
+ **D3: Template literals são removidos antes do parse.** Onde a análise estática for inevitável
118
+ (`deps-declared`), o conteúdo entre crases é apagado do fonte antes de casar `import`. Os geradores
119
+ *escrevem* código NestJS; não o executam. Sem isso, o check acusa `@nestjs/core` como dependência
120
+ não declarada — e é o bug latente que já existe hoje no `runtime-deps` (AC-11).
121
+
122
+ **D4: Dois modos (`--publish`).** Ver §4. Severidade do `tree-clean` muda com o contexto; o resto
123
+ é idêntico.
124
+
125
+ **D5: A aprovação é perecível.** O `git status` é reconferido **ao final**, porque a auditoria vale
126
+ para o disco no instante em que rodou. Um `npm install` entre o check e o publish invalida tudo — e
127
+ essa foi literalmente a causa da v1.1.1.
128
+
129
+ **D6: O gate nunca publica.** Ele autoriza. `npm publish` continua sendo um ato humano deliberado.
130
+
131
+ **D7: `deps-unused` é `warn`, não `fail`.** Peso morto no tarball incomoda, não quebra. Reprovar um
132
+ release por causa disso é o tipo de rigor que ensina o time a usar `--no-verify`.
133
+
134
+ **D8: `smoke-commands` reprova por padrão no stderr, nunca por exit code.** Numa instalação limpa
135
+ não existe workspace nem `universal.db` — então `query:universal` sai com código ≠ 0 *legitimamente*,
136
+ e `tools:doctor` avisa sobre memória não indexada. Isso é o pacote **funcionando**. O que denuncia
137
+ tarball quebrado é a assinatura do carregamento: `ERR_MODULE_NOT_FOUND`, `ERR_DLOPEN_FAILED`,
138
+ `Cannot find module`. Reprovar por exit code faria o gate reprovar um pacote saudável — é a mesma
139
+ armadilha do `memory-db` na SPEC-009, um nível acima.
140
+
141
+ **D9: `prepublishOnly`, nunca `prepack`.** O gate roda `npm pack`. Amarrá-lo ao `prepack` faria o
142
+ `npm pack` do gate disparar o `prepack`, que chama o gate, que roda `npm pack`… `npm pack` **não**
143
+ dispara `prepublishOnly`, então o hook correto é o único seguro. Vale um comentário no
144
+ `package.json`: a alternativa "óbvia" é uma bomba-relógio.
145
+
146
+ D1 e a mudança de contrato do `prepublishOnly` são estruturais → **ADR-0024**, referenciando
147
+ ADR-0023 (mesma filosofia, fronteira seguinte) e ADR-0021 (a classe que ambos fecham).
148
+
149
+ ## 6. Dependências
150
+
151
+ - **Specs**: SPEC-009 (`lib/core/health.mjs` é a base do runner). Já em `done`.
152
+ - **Pacotes npm**: **nenhum novo.** `npm pack`/`npm i` via `child_process`.
153
+ - **Migrações**: nenhuma.
154
+
155
+ ## 7. Rollout
156
+
157
+ - [ ] **Ordem**: `checks.mjs` extraído + suíte verde (refactor puro, nada muda de comportamento) →
158
+ `release.mjs` + testes → `release-check.mjs` → CI → `prepublishOnly` **por último**.
159
+ - [x] Doc/persona impactada: `docs/publishing.md`, `CLAUDE.md`, persona **governança**.
160
+ - [ ] **Validar reintroduzindo os três bugs históricos** (better-sqlite3 em devDeps; arquivo fora do
161
+ `files[]`; árvore suja). Cada um deve reprovar. Um gate que nunca viu a falha que promete
162
+ pegar não está testado — está escrito.
163
+ - [ ] `prepublishOnly` entra **depois** de o gate rodar verde no CI por um ciclo. Ele é a única
164
+ peça que, com falso positivo, impede publicar qualquer coisa.
165
+
166
+ ## 8. Sinais de fracasso (kill criteria)
167
+
168
+ - **O gate reprova um release saudável.** Um falso positivo no `prepublishOnly` trava a operação
169
+ inteira. Se acontecer uma vez, o `tree-clean` estrito sai do `prepublishOnly` e fica só no CI.
170
+ - **`deps-declared` volta a acusar os geradores.** Se o D3 não bastar, o check é rebaixado a `warn`
171
+ e a cobertura passa a vir do `smoke-commands` (que executa e não mente).
172
+ - **O gate leva minutos.** O custo real não é o `npm pack` — é o `npm i` compilando o
173
+ `better-sqlite3` do zero (o CI já gasta ~1min45 nisso). Se ficar caro demais, o gate sai do fluxo
174
+ de PR e fica só no release: a instalação limpa é inegociável, a frequência não.