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.
- package/.claude/agents/governance.md +33 -10
- package/.claude/agents/release-auditor.md +44 -77
- package/CHANGELOG.md +53 -0
- package/docs/agent-harnesses.md +30 -3
- package/docs/token-optimization.md +28 -20
- package/lib/core/checks.mjs +138 -0
- package/lib/core/health.mjs +475 -0
- package/lib/core/registry.mjs +6 -1
- package/lib/core/release.mjs +452 -0
- package/memory/40-delivery/current-sprint.md +13 -7
- package/memory/90-decisions/0023-doctor-como-gate-do-nucleo.md +114 -0
- package/memory/90-decisions/0024-gate-do-tarball.md +103 -0
- package/package.json +4 -1
- package/prompts/governance-agent.md +2 -1
- package/scripts/hook-session-start.mjs +29 -39
- package/scripts/release-check.mjs +56 -0
- package/scripts/spec-cli.mjs +75 -11
- package/scripts/tools-doctor.mjs +65 -10
- package/specs/coerencia-do-sistema/spec.md +122 -0
- package/specs/doctor-do-nucleo/plan.md +165 -0
- package/specs/doctor-do-nucleo/spec.md +139 -0
- package/specs/doctor-do-nucleo/tasks.md +172 -0
- package/specs/release-gate/plan.md +174 -0
- package/specs/release-gate/spec.md +122 -0
- package/specs/release-gate/tasks.md +183 -0
|
@@ -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.
|