@daniellins/power-claude 0.16.3

package/scripts/migration-manifest.test.cjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * migration-manifest.test.cjs — suíte PRÓPRIA do escritor único (Story SF3.1).
+ * NÃO-fake-green: cada recusa é provada por um artefato/estado real, não por relato.
+ * Cobre:
+ *   AC7  escritor único: 7 subcomandos; integrity gravado; hash divergente → exit 3.
+ *   AC8  baseline snapshot no open-line (listagem + sha256 por arquivo).
+ *   AC9  close-line binding: run_id forjado / spec_hash divergente / run_id de OUTRO
+ *        workflow → RECUSA; wf_path RE-EXECUTA validate-pod-workflow (exit 0 exigido).
+ *   AC10 RAIZ DE CONFIANÇA EM CÓDIGO: verify[] = {cmd:true} NÃO muda o veredito.
+ * Mais: retomada idempotente, ordem de fases, coverage, verify re-abre linha stale.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const m = require('./migration-manifest.cjs');
+const g = require('./forge-generate.cjs');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+function refuses(fn, code, label) {
+  let got = null;
+  try { fn(); } catch (e) { got = e.exitCode; }
+  ok(got === code, `${label} (exit ${code}${got === code ? '' : ` — obtido ${got}`})`);
+}
+function tmp(name) { return fs.mkdtempSync(path.join(os.tmpdir(), `mm-${name}-`)); }
+
+// Cenário base: pod real gerado (wf válido para o re-exec do validador) + manifest.
+function scenario() {
+  const dir = tmp('sc');
+  const pod = path.join(dir, 'pod');
+  const spec = { pod: 'testpod', agents: [{ name: 'builder', output: 'pkg', sections: ['## Contexto', '## Output'] }] };
+  const specPath = path.join(dir, 'wf-x.spec.json');
+  fs.writeFileSync(specPath, JSON.stringify(spec));
+  // SF12.4a/ADR-030 Bloco O — pod-base do cenário (bootstrap do fixture) — 'derived'.
+  g.generatePod(spec, pod, { tierOverride: 'STANDARD/COMPLEX', specOrigin: 'derived' });
+  const wfPath = path.join(pod, 'workflows', 'wf-testpod.yaml');
+  const mf = path.join(dir, 'MIGRATION-sq.yaml');
+  const runDir = path.join(dir, 'runs'); fs.mkdirSync(runDir, { recursive: true });
+  const goodRun = path.join(runDir, 'good.json');
+  fs.writeFileSync(goodRun, JSON.stringify({ pod: 'testpod', workflow: 'wf-x', run_id: 'r1', mode: 'auto', steps: { builder: { status: 'done' } }, updated_at: 'T' }));
+  const wrongRun = path.join(runDir, 'wrong.json');
+  fs.writeFileSync(wrongRun, JSON.stringify({ pod: 'testpod', workflow: 'wf-OUTRO', run_id: 'r2', mode: 'auto', steps: {}, updated_at: 'T' }));
+  return { dir, pod, spec, specPath, wfPath, mf, runDir, goodRun, wrongRun };
+}
+// F1 SINTÉTICA (pós-QA sf3.3): open-line agora exige triagem 'migrate' APROVADA
+// INCONDICIONALMENTE (sem caminho dormente). Os unit tests dão aprovação sintética.
+function approveWf(mf, wf) {
+  m.cmdTriageSet(mf, { workflow: wf, disposition: 'migrate', purpose: 'fixture:1', basis: 'dado', now: 'T' });
+  m.cmdTriageApprove(mf, { workflow: wf, approvedBy: 'daniel', now: 'T' });
+}
+function initMf(s) { return m.cmdInit(s.mf, { squad: 'sq', squadDir: s.pod, now: 'T0' }); }
+function toGates(s) {
+  initMf(s);
+  approveWf(s.mf, 'wf-x');
+  m.cmdOpenLine(s.mf, { workflow: 'wf-x', spec: s.specPath, podDir: s.pod, pod: 'testpod', owns: ['workflows/wf-testpod.yaml'], now: 'T1' });
+  for (const p of ['generated', 'distilled', 'linted', 'gates']) m.cmdAdvance(s.mf, { workflow: 'wf-x', to: p, now: 'T' });
+}
+
+// ---------------------------------------------------------------------------
+// AC7 — escritor único: subcomandos, integrity, hash divergente → exit 3.
+// ---------------------------------------------------------------------------
+{
+  const s = scenario();
+  const init = initMf(s);
+  ok(init.action === 'init' && fs.existsSync(s.mf), 'AC7 init cria o manifest em docs/migration/ (aqui: tmp)');
+  ok(/^integrity: "[0-9a-f]{64}"$/m.test(fs.readFileSync(s.mf, 'utf8')), 'AC7 integrity (sha256) gravado a cada escrita');
+  // triage exige colunas de evidência
+  refuses(() => m.cmdTriageSet(s.mf, { workflow: 'wf-x', disposition: 'migrate', now: 'T' }), 2, 'AC7 triage-set sem --purpose/--basis → recusa');
+  m.cmdTriageSet(s.mf, { workflow: 'wf-x', disposition: 'migrate', purpose: 'README.md:12', overlap: 'o.md:3', basis: 'dado', now: 'T' });
+  ok(m.readManifest(s.mf).triage.length === 1, 'AC7 triage-set grava a linha com evidência');
+  // hash divergente → exit 3 (edição à mão)
+  let txt = fs.readFileSync(s.mf, 'utf8').replace('README.md:12', 'ADULTERADO');
+  fs.writeFileSync(s.mf, txt);
+  refuses(() => m.readManifest(s.mf), 3, 'AC7 manifest editado à mão (hash divergente) → exit 3');
+}
+
+// ---------------------------------------------------------------------------
+// AC8 — baseline snapshot no open-line.
+// ---------------------------------------------------------------------------
+{
+  const s = scenario();
+  initMf(s); approveWf(s.mf, 'wf-x');
+  const ol = m.cmdOpenLine(s.mf, { workflow: 'wf-x', spec: s.specPath, podDir: s.pod, pod: 'testpod', owns: ['workflows/wf-testpod.yaml'], now: 'T1' });
+  ok(ol.baseline > 0, 'AC8 open-line grava baseline (listagem da árvore do pod)');
+  const line = m.readManifest(s.mf).lines[0];
+  ok(Array.isArray(line.baseline) && line.baseline.every((e) => e.path && /^[0-9a-f]{64}$/.test(e.sha256)),
+    'AC8 baseline = {path, sha256} por arquivo (para o diff triplo de SF3.3)');
+  ok(line.spec_hash && line.owns.includes('workflows/wf-testpod.yaml') && line.phase === 'spec', 'AC8 open-line grava spec_hash+owns+phase=spec');
+}
+
+// ---------------------------------------------------------------------------
+// AC7 — ordem de fases fail-loud.
+// ---------------------------------------------------------------------------
+{
+  const s = scenario();
+  initMf(s); approveWf(s.mf, 'wf-x');
+  m.cmdOpenLine(s.mf, { workflow: 'wf-x', spec: s.specPath, podDir: s.pod, pod: 'testpod', owns: [], now: 'T1' });
+  refuses(() => m.cmdAdvance(s.mf, { workflow: 'wf-x', to: 'gates', now: 'T' }), 2, 'AC7 advance fora de ordem (spec→gates pulando fases) → recusa');
+  refuses(() => m.cmdAdvance(s.mf, { workflow: 'wf-x', to: 'closed', now: 'T' }), 2, 'AC7 advance não fecha a linha (closed é do close-line)');
+  const a = m.cmdAdvance(s.mf, { workflow: 'wf-x', to: 'generated', now: 'T' });
+  ok(a.hook === null, 'AC7 advance→generated sem hook');
+}
+
+// ---------------------------------------------------------------------------
+// AC9 — close-line binding + re-execução do validador estático.
+// ---------------------------------------------------------------------------
+{
+  const s = scenario(); toGates(s);
+  const gatesHook = m.readManifest(s.mf); // já em gates
+  ok(gatesHook.lines[0].phase === 'gates', 'AC9 linha em gates pronta para close');
+  // run_id forjado (inexistente) → recusa
+  refuses(() => m.cmdCloseLine(s.mf, { workflow: 'wf-x', wfPath: s.wfPath, runIds: [path.join(s.runDir, 'nope.json')], now: 'T' }), 2, 'AC9 run_id inexistente (forjado) → RECUSA');
+  // run_id de OUTRO workflow (binding não confere) → recusa
+  refuses(() => m.cmdCloseLine(s.mf, { workflow: 'wf-x', wfPath: s.wfPath, runIds: [s.wrongRun], now: 'T' }), 2, 'AC9 run_id de OUTRO workflow (binding workflow+pod) → RECUSA');
+  // wf_path que NÃO passa validate-pod-workflow → recusa (re-execução real, não só existência)
+  const badWf = path.join(s.dir, 'wf-bad.yaml'); fs.writeFileSync(badWf, 'isto não é um contrato de workflow válido\n');
+  refuses(() => m.cmdCloseLine(s.mf, { workflow: 'wf-x', wfPath: badWf, runIds: [s.goodRun], now: 'T' }), 2, 'AC9 wf_path inválido: validate-pod-workflow RE-EXECUTADO falha → RECUSA');
+  // evidência válida → fecha
+  const closed = m.cmdCloseLine(s.mf, { workflow: 'wf-x', wfPath: s.wfPath, runIds: [s.goodRun], now: 'T' });
+  ok(closed.phase === 'closed', 'AC9 evidência com binding + wf válido re-executado → FECHA a linha');
+}
+
+// AC9 — spec_hash divergente (spec mudou após open-line) → recusa no close.
+{
+  const s = scenario(); toGates(s);
+  fs.writeFileSync(s.specPath, JSON.stringify({ pod: 'testpod', agents: ['builder', 'novo'] })); // muda a spec no disco
+  refuses(() => m.cmdCloseLine(s.mf, { workflow: 'wf-x', wfPath: s.wfPath, runIds: [s.goodRun], now: 'T' }), 2, 'AC9 spec_hash divergente (spec mudou no disco) → RECUSA');
+}
+
+// ---------------------------------------------------------------------------
+// AC10 — RAIZ DE CONFIANÇA EM CÓDIGO: verify[]={cmd:true} não compra nada.
+// ---------------------------------------------------------------------------
+{
+  const s = scenario(); toGates(s);
+  m.cmdCloseLine(s.mf, { workflow: 'wf-x', wfPath: s.wfPath, runIds: [s.goodRun], now: 'T' });
+  // verify por código confirma a linha íntegra.
+  const v1 = m.cmdVerify(s.mf);
+  ok(v1.stale.length === 0, 'AC10 verify: linha fechada com evidência real re-verifica OK por código');
+  // Atacante recomputa o hash (limite declarado do integrity) e injeta verify[]={cmd:true}
+  // E quebra a evidência real (run_id apontando para arquivo inexistente).
+  const doc = m.readManifest(s.mf);
+  const line = doc.lines.find((l) => l.workflow === 'wf-x');
+  line.verify = [{ cmd: 'true' }];
+  line.run_ids = [path.join(s.runDir, 'apagado.json')]; // evidência dinâmica destruída
+  m.writeManifest(s.mf, doc); // grava com integrity recomputado (válido)
+  ok(m.readManifest(s.mf), 'AC10 integrity recomputado é válido (o hash não é a raiz — limite declarado)');
+  const v2 = m.cmdVerify(s.mf);
+  ok(v2.stale.length === 1, 'AC10 verify[]={cmd:true} NÃO muda o veredito: evidência quebrada → linha STALE (raiz é código)');
+  // e a linha foi REABERTA (stale → phase gates).
+  ok(m.readManifest(s.mf).lines.find((l) => l.workflow === 'wf-x').phase === 'gates', 'AC10 linha stale REABERTA (phase volta a gates)');
+}
+
+// ---------------------------------------------------------------------------
+// coverage — diff squad × manifest (0 sem endereço quando tudo endereçado).
+// ---------------------------------------------------------------------------
+{
+  const s = scenario();
+  const squad = path.join(s.dir, 'squad'); fs.mkdirSync(path.join(squad, 'workflows'), { recursive: true });
+  fs.writeFileSync(path.join(squad, 'workflows', 'wf-x.yaml'), 'steps:\n');
+  fs.writeFileSync(path.join(squad, 'workflows', 'wf-orfa.yaml'), 'steps:\n');
+  m.cmdInit(s.mf, { squad: 'sq', squadDir: s.pod, now: 'T0' });
+  m.cmdTriageSet(s.mf, { workflow: 'wf-x', disposition: 'migrate', purpose: 'p:1', basis: 'dado', now: 'T' });
+  const cov = m.cmdCoverage(s.mf, { squadDir: squad });
+  ok(!cov.clean && cov.unaddressed.some((u) => /wf-orfa/.test(u)), 'coverage detecta o workflow órfão sem endereço (não fecha com diff não-vazio)');
+  m.cmdTriageSet(s.mf, { workflow: 'wf-orfa', disposition: 'dispense', purpose: 'p:2', basis: 'julgamento', now: 'T' });
+  ok(m.cmdCoverage(s.mf, { squadDir: squad }).clean, 'coverage = 0 sem endereço após triar o órfão');
+}
+
+console.log(`\n${passed}/${passed + failures.length} verificações do manifest passaram.`);
+if (failures.length) {
+  console.error('\nSUÍTE migration-manifest (SF3.1) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('Suíte migration-manifest verde (escritor único + integrity + binding + raiz de confiança em código).');
+process.exit(0);

package/scripts/npm-scope-invocation.test.cjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * npm-scope-invocation.test.cjs — suíte do rename do pacote npm para
+ * `@daniellins/power-claude` (Story SF11.9).
+ *
+ * Por que esta suíte existe: o nome NÃO-escopado `power-claude` pertence a um
+ * terceiro no registry público (`neural-llm-io/power-claude`). Toda prosa do
+ * framework que mande alguém rodar `npx power-claude ...` leva o usuário a
+ * BAIXAR E EXECUTAR código alheio. Renomear o pacote nos dá um nome seguro para
+ * recomendar; NÃO torna o nome inseguro menos perigoso caso alguém o digite.
+ * Por isso o sweep (AC8) continua vigiando a string sem escopo para sempre.
+ *
+ * Oráculo COMPORTAMENTAL, não textual (AC7 — fecha a dívida apontada pelo QA da
+ * SF10.20, `docs/stories/sf10.20.story.md:445`): o teste EXECUTA `bin/cli.js`
+ * como processo real e assere sobre o STDOUT/STDERR entregue ao usuário, nunca
+ * sobre o arquivo-fonte. Grepar o fonte provaria que a string existe no disco;
+ * só a execução prova que é ISSO que o usuário lê.
+ *
+ * Cobre: AC1 (name/bin), AC2 (publishConfig.access), AC7 (comportamental),
+ * AC8 (sweep de regressão com allowlist explícita).
+ *
+ * Node >= 18, sem dependências externas. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const CLI = path.join(REPO_ROOT, 'bin', 'cli.js');
+
+const SCOPED = '@daniellins/power-claude';
+
+/**
+ * Padrão do risco: `npx` seguido de `power-claude` SEM escopo.
+ * Deliberadamente NÃO casa:
+ *   - `npx @daniellins/power-claude ...` (o token após `npx` é `@daniellins/...`)
+ *   - `npx github:daniellins/power-claude ...` (instalação por GitHub, não registry)
+ * Ambos os não-casamentos são exercitados por asserção abaixo, para que o
+ * próprio padrão do sweep seja provado — e não presumido.
+ */
+const UNSCOPED_NPX = /\bnpx\s+power-claude\b/;
+
+/** Arquivos/linhas onde a string SEM escopo é esperada e CORRETA: comentários
+ *  que documentam o risco (defesa da SF10.20), não instrução de invocação.
+ *  Preservados pelo AC9 — `git diff` desses arquivos tem de ficar vazio. */
+const SWEEP_ALLOWLIST = [
+  { ref: 'installer/manifest.js:15', mustContain: 'REGISTRY PÚBLICO' },
+  { ref: 'installer/doctor.js:34', mustContain: 'Nunca prescrever' },
+];
+
+const SWEEP_TARGETS = ['bin', 'installer', 'template', 'README.md'];
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+
+// ===========================================================================
+// (AC1/AC2) manifesto do pacote — JSON.parse, não grep de texto
+// ===========================================================================
+console.log('--- (AC1/AC2) package.json: name, bin, publishConfig ---');
+
+const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+
+ok(pkg.name === SCOPED, `name === "${SCOPED}" (recebido: "${pkg.name}")`);
+
+// A CHAVE de `bin` é o nome do EXECUTÁVEL que o npm põe no PATH — independente
+// do nome (escopado) do pacote. Mantê-la é decisão explícita da story, não
+// omissão: o risco de supply-chain vem de `npx <pacote>`, não do nome do binário.
+ok(pkg.bin && pkg.bin['power-claude'] === 'bin/cli.js',
+  'chave de bin permanece "power-claude" -> bin/cli.js (nome do comando, não do pacote)');
+ok(pkg.bin && Object.keys(pkg.bin).length === 1,
+  'bin declara exatamente 1 executável (nenhum alias novo introduzido)');
+
+// A armadilha central: pacote ESCOPADO nasce PRIVADO no npm. Sem isto,
+// `npm publish` falha — ou, pior, publica privado sem ninguém perceber.
+ok(pkg.publishConfig && pkg.publishConfig.access === 'public',
+  'publishConfig.access === "public" (pacote escopado é privado por default)');
+
+// ===========================================================================
+// (AC7) ORÁCULO COMPORTAMENTAL — executa o binário real, lê a saída real
+// ===========================================================================
+console.log('--- (AC7) execução real de bin/cli.js: stdout/stderr entregues ao usuário ---');
+
+const help = spawnSync(process.execPath, [CLI, '--help'], { encoding: 'utf8' });
+
+ok(help.status === 0, `\`node bin/cli.js --help\` sai 0 (recebido: ${help.status})`);
+ok(typeof help.stdout === 'string' && help.stdout.trim() !== '', '--help escreve algo em stdout');
+ok(help.stdout.includes(`npx ${SCOPED}`),
+  `stdout de --help contém "npx ${SCOPED}"`);
+ok(!UNSCOPED_NPX.test(help.stdout),
+  'stdout de --help NÃO contém `npx power-claude` sem escopo (supply-chain)');
+
+// O mesmo HELP chega ao usuário por STDERR nos caminhos de erro do CLI —
+// canal distinto, mesma superfície de orientação. Se o rename tivesse sido
+// aplicado só em parte do texto, este ramo pegaria.
+const bad = spawnSync(process.execPath, [CLI, 'comando-que-nao-existe'], { encoding: 'utf8' });
+ok(bad.status === 2, `argumento desconhecido sai 2 (recebido: ${bad.status})`);
+ok(!UNSCOPED_NPX.test(bad.stderr),
+  'stderr do caminho de erro NÃO contém `npx power-claude` sem escopo');
+ok(bad.stderr.includes(`npx ${SCOPED}`),
+  `stderr do caminho de erro contém "npx ${SCOPED}"`);
+
+const version = spawnSync(process.execPath, [CLI, '--version'], { encoding: 'utf8' });
+ok(version.status === 0, `\`node bin/cli.js --version\` sai 0 (recebido: ${version.status})`);
+ok(version.stdout.trim() === pkg.version,
+  `--version imprime a versão do manifesto renomeado (${pkg.version})`);
+ok(!UNSCOPED_NPX.test(version.stdout),
+  'stdout de --version NÃO contém `npx power-claude` sem escopo');
+
+// ===========================================================================
+// (AC8) SWEEP DE REGRESSÃO — grep programático, allowlist explícita
+// ===========================================================================
+console.log('--- (AC8) sweep: `npx power-claude` sem escopo em bin/, installer/, template/, README.md ---');
+
+// O padrão do sweep é ele próprio testado: se `UNSCOPED_NPX` casasse a forma
+// escopada ou a do GitHub, o sweep viraria ruído e seria desligado por alguém.
+ok(!UNSCOPED_NPX.test(`npx ${SCOPED} install`),
+  'padrão do sweep NÃO casa a forma escopada (senão o sweep seria falso-positivo)');
+ok(!UNSCOPED_NPX.test('npx github:daniellins/power-claude install'),
+  'padrão do sweep NÃO casa `npx github:...` (instalação por GitHub, fora do registry)');
+ok(UNSCOPED_NPX.test('npx power-claude install'),
+  'padrão do sweep CASA a forma perigosa sem escopo (o sweep de fato detecta)');
+
+function isProbablyBinary(buf) {
+  return buf.subarray(0, 8000).includes(0);
+}
+
+function collectFiles(target) {
+  const full = path.join(REPO_ROOT, target);
+  if (!fs.existsSync(full)) return [];
+  const out = [];
+  (function walk(p) {
+    const st = fs.statSync(p);
+    if (st.isFile()) { out.push(p); return; }
+    if (!st.isDirectory()) return;
+    for (const entry of fs.readdirSync(p, { withFileTypes: true })) {
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      walk(path.join(p, entry.name));
+    }
+  })(full);
+  return out;
+}
+
+const hits = [];
+for (const target of SWEEP_TARGETS) {
+  for (const file of collectFiles(target)) {
+    const buf = fs.readFileSync(file);
+    if (isProbablyBinary(buf)) continue;
+    const rel = path.relative(REPO_ROOT, file);
+    buf.toString('utf8').split('\n').forEach((line, i) => {
+      if (UNSCOPED_NPX.test(line)) hits.push({ ref: `${rel}:${i + 1}`, line: line.trim() });
+    });
+  }
+}
+
+console.log(`       ocorrências encontradas: ${hits.length ? hits.map((h) => h.ref).join(', ') : '(nenhuma)'}`);
+
+// Oráculo DECISIVO: o conjunto encontrado é exatamente a allowlist.
+const foundRefs = hits.map((h) => h.ref).sort();
+const allowedRefs = SWEEP_ALLOWLIST.map((a) => a.ref).sort();
+ok(JSON.stringify(foundRefs) === JSON.stringify(allowedRefs),
+  `sweep retorna exatamente a allowlist [${allowedRefs.join(', ')}]`);
+
+// Nenhuma ocorrência sobrevive em bin/, template/ ou README.md — as superfícies
+// de INSTRUÇÃO. A allowlist inteira vive em installer/, e só em comentário.
+const outsideInstaller = hits.filter((h) => !h.ref.startsWith('installer/'));
+ok(outsideInstaller.length === 0,
+  `zero ocorrências em bin/, template/, README.md (sobraram: ${outsideInstaller.map((h) => h.ref).join(', ') || 'nenhuma'})`);
+
+// Cada item da allowlist é COMENTÁRIO que documenta o risco — não instrução de
+// invocação. Se alguém transformar um desses comentários em prosa de uso, o
+// `file:line` continuaria batendo, mas esta asserção quebra.
+for (const allowed of SWEEP_ALLOWLIST) {
+  const hit = hits.find((h) => h.ref === allowed.ref);
+  ok(!!hit && (hit.line.startsWith('*') || hit.line.startsWith('//') || hit.line.startsWith('/*')),
+    `${allowed.ref} é comentário (documenta o risco, não prescreve invocação)`);
+  ok(!!hit && hit.line.includes(allowed.mustContain),
+    `${allowed.ref} preserva o teor de advertência ("${allowed.mustContain}")`);
+}
+
+// ===========================================================================
+console.log('');
+if (failures.length) {
+  console.error(`FALHOU: ${failures.length} asserção(ões) de ${passed + failures.length}`);
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log(`OK: ${passed} asserções passaram (SF11.9 — rename npm escopado).`);
+process.exit(0);