@daniellins/power-claude 0.16.3 → 0.16.4

package/scripts/build-public-tree.cjs

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * build-public-tree.cjs — monta a árvore do repositório PÚBLICO, REPO-ONLY.
+ *
+ * Um verbo único que: lê a fronteira decidida (Opção B) de UM manifesto, monta a
+ * árvore correspondente num diretório alvo, roda o gate de dado pessoal DENTRO
+ * da árvore montada — não no repositório privado — e se recusa a declarar
+ * sucesso quando qualquer etapa reprova. Story SF15.8; invariantes I1/I2 do
+ * ADR-037.
+ *
+ * ┌─ ESTE ARQUIVO NÃO VIAJA PARA INSTALAÇÃO ─────────────────────────────────┐
+ * │ Está no `exclude` de `installer/motor-scripts.json`, mesma classe de      │
+ * │ `owner-layer.cjs` e `validate-git-vetor.cjs` (que ele importa).           │
+ * └──────────────────────────────────────────────────────────────────────────┘
+ *
+ * CLI
+ *   --out <dir>              (obrigatório no modo montagem) diretório alvo
+ *   --root <dir>             (opcional) raiz-fonte; default = raiz deste repo
+ *   --report <path>          (opcional) grava o relatório JSON; default = stdout
+ *   --verify-only <dir>      (modo alternativo) re-audita uma árvore JÁ montada
+ *   --allow-nonempty-out     opt-in explícito para sobrescrever um `--out`
+ *                            existente e não-vazio (fail-closed por default)
+ *
+ * TODO — dono: `--expect-sha <sha>` (tripwire I3 do ADR-037) é ponto de extensão
+ * RESERVADO e NÃO implementado nesta story. I3 só passa a valer da 2ª publicação
+ * em diante (não há HEAD remoto para divergir no primeiro push) e pertence ao
+ * mecanismo de sincronização contínua (SF15.9+). Quem o implementar estende este
+ * verbo; não precisa redesenhá-lo.
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+// I1 — manifesto ÚNICO: as entradas varridas pelo gate vêm por IMPORT, nunca
+// redeclaradas aqui (lição SF13.9/SF13.10 — roster copiado 3×, uma errada).
+const gitVetor = require('./validate-git-vetor.cjs');
+
+// As 3 entradas que a Opção B COPIA mas que o gate de branding não VARRE por
+// conteúdo — coisas diferentes, decisões diferentes, não fundidas aqui:
+//  • `scripts` — fora do escopo varrido por decisão da SF15.7 (Escopo OUT #1,
+//    auto-referência: o próprio validate-branding.js carrega os termos como
+//    literal). Fica fora do CONTEÚDO varrido, nunca fora do repositório público.
+//  • `LICENSE` — nunca esteve no escopo varrido, por desenho anterior a esta story.
+//  • `package.json` — decisão do dono sobre `m9` (2026-08-10): incluído para que
+//    o clone vire projeto funcional (bin/ e installer/ dependem dele em runtime).
+const ADDITIONAL_MANIFEST_ENTRIES = ['scripts', 'LICENSE', 'package.json'];
+const PUBLIC_MANIFEST = [...gitVetor.SCAN_TARGETS, ...ADDITIONAL_MANIFEST_ENTRIES];
+
+// I2 — o gate é invocado por caminho RELATIVO, com `cwd` na árvore montada.
+// `REPO_ROOT` do gate é `path.resolve(__dirname, '..')`, relativo ao PRÓPRIO
+// arquivo: como o diretório de scripts está dentro do manifesto copiado, o gate
+// reancora na árvore montada sozinho. Caminho absoluto do repositório aqui seria
+// o mutante do falso verde (o gate varreria a fonte, não a montagem).
+const GATE_SCRIPT = 'scripts/validate-git-vetor.cjs';
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+const COBERTURA_GATE =
+  `o gate composto varre ${gitVetor.SCAN_TARGETS.length} das ${PUBLIC_MANIFEST.length} entradas do manifesto; ` +
+  `${ADDITIONAL_MANIFEST_ENTRIES.join(', ')} não são varridas por conteúdo ` +
+  `(auto-referência — SF15.7 Escopo OUT #1). Um sucesso aqui significa "montada e auditada nesse limite", ` +
+  `nunca "sem dado pessoal em toda a árvore".`;
+
+/* ------------------------------------------------------------------ *
+ * Níveis permitidos — DERIVADOS do manifesto em runtime, nunca escritos
+ * à mão (escrever os nomes aqui recriaria a 2ª lista que I1 existe para
+ * impedir, e reprovaria o AC-1 por cópia literal).
+ * ------------------------------------------------------------------ */
+function manifestLevels(manifest) {
+  const top = new Set();
+  const nested = new Map();
+  for (const entry of manifest) {
+    const parts = entry.split('/');
+    top.add(parts[0]);
+    if (parts.length > 1) {
+      if (!nested.has(parts[0])) nested.set(parts[0], new Set());
+      nested.get(parts[0]).add(parts[1]);
+    }
+  }
+  return { top, nested };
+}
+
+function git(root, args) {
+  const r = spawnSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+  if (r.error) throw new Error(`git ${args[0]} falhou: ${r.error.message}`);
+  if (r.status !== 0) {
+    throw new Error(`git ${args[0]} saiu com ${r.status}: ${String(r.stderr || '').trim()}`);
+  }
+  return String(r.stdout || '');
+}
+
+function gitZ(root, args) {
+  return git(root, args).split('\0').filter(Boolean);
+}
+
+/* ------------------------------------------------------------------ *
+ * Checagem estrutural: PRESENÇA de todas as entradas do manifesto E
+ * ausência de qualquer coisa a mais, em todo nível onde o manifesto
+ * corta. Reusada pelo modo montagem e pelo --verify-only (M5/B1).
+ * ------------------------------------------------------------------ */
+function auditStructure(dir) {
+  const problemas = [];
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    problemas.push(`diretório não encontrado: ${dir}`);
+    return problemas;
+  }
+
+  const { top, nested } = manifestLevels(PUBLIC_MANIFEST);
+
+  for (const entry of PUBLIC_MANIFEST) {
+    if (!fs.existsSync(path.join(dir, ...entry.split('/')))) {
+      problemas.push(`entrada do manifesto ausente na árvore montada: ${entry}`);
+    }
+  }
+
+  const raiz = fs.readdirSync(dir).sort();
+  if (raiz.length === 0) problemas.push(`árvore vazia: nenhuma das ${PUBLIC_MANIFEST.length} entradas do manifesto está presente`);
+  for (const nome of raiz) {
+    if (!top.has(nome)) problemas.push(`entrada de 1º nível fora do manifesto: ${nome}`);
+  }
+
+  for (const [topSeg, permitidos] of nested) {
+    const sub = path.join(dir, topSeg);
+    if (!fs.existsSync(sub)) continue;
+    for (const nome of fs.readdirSync(sub).sort()) {
+      if (!permitidos.has(nome)) {
+        problemas.push(`entrada fora do manifesto sob ${topSeg}/: ${topSeg}/${nome}`);
+      }
+    }
+  }
+
+  return problemas;
+}
+
+/* ------------------------------------------------------------------ *
+ * Gate composto, com `cwd` na árvore auditada (I2). Código de saída
+ * fail-closed: `status === null` (filho morto por sinal) e `error`
+ * contam como FALHA — nunca 0 (B4).
+ * ------------------------------------------------------------------ */
+function runGate(dir) {
+  const r = spawnSync(process.execPath, [GATE_SCRIPT], { cwd: dir, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+  if (r.stdout) process.stdout.write(r.stdout);
+  if (r.stderr) process.stderr.write(r.stderr);
+  const code = r.error ? 1 : (r.status === 0 ? 0 : (r.status || 1));
+  if (r.error) process.stderr.write(`gate não pôde ser executado: ${r.error.message}\n`);
+  if (r.status === null && !r.error) {
+    process.stderr.write(`gate encerrado por sinal (${r.signal}) — tratado como reprovação, nunca como sucesso.\n`);
+  }
+  return code;
+}
+
+function relatorioExclusoes(root) {
+  const { top, nested } = manifestLevels(PUBLIC_MANIFEST);
+  const rastreados = gitZ(root, ['ls-files', '-z']);
+
+  const excluidos = [];
+
+  const raizVistos = new Set();
+  for (const file of rastreados) {
+    const seg = file.split('/')[0];
+    if (top.has(seg) || raizVistos.has(seg)) continue;
+    raizVistos.add(seg);
+    excluidos.push({ nivel: 'raiz', path: seg, regra: 'fora das entradas de 1º nível do manifesto público' });
+  }
+
+  for (const [topSeg, permitidos] of nested) {
+    const vistos = new Set();
+    for (const file of rastreados) {
+      const parts = file.split('/');
+      if (parts[0] !== topSeg || parts.length < 2) continue;
+      if (permitidos.has(parts[1]) || vistos.has(parts[1])) continue;
+      vistos.add(parts[1]);
+      excluidos.push({
+        nivel: `${topSeg}/`,
+        path: `${topSeg}/${parts[1]}`,
+        regra: `fora das entradas permitidas sob ${topSeg}/ pelo manifesto público`,
+      });
+    }
+  }
+
+  excluidos.sort((a, b) => (a.nivel + a.path).localeCompare(b.nivel + b.path));
+  return excluidos;
+}
+
+/* ------------------------------------------------------------------ *
+ * Montagem por ÍNDICE do git, nunca por disco (B2). Arquivo não-rastreado
+ * (inclusive ignorado) não aparece na enumeração e, por construção, nunca
+ * entra na árvore montada.
+ * ------------------------------------------------------------------ */
+function copiarDoIndice(root, destino) {
+  const arquivos = gitZ(root, ['ls-files', '-z', '--', ...PUBLIC_MANIFEST]);
+  for (const rel of arquivos) {
+    const origem = path.join(root, rel);
+    const alvo = path.join(destino, rel);
+    fs.mkdirSync(path.dirname(alvo), { recursive: true });
+    fs.copyFileSync(origem, alvo);
+  }
+  return arquivos;
+}
+
+function checarSujeira(root) {
+  // `--untracked-files=no` é OBRIGATÓRIO: sem ele, arquivo NUNCA rastreado
+  // apareceria aqui e a montagem seria recusada por debris local. A regra é
+  // sobre COMMIT pendente, não sobre debris: arquivo rastreado com edição
+  // pendente recusa; arquivo não-rastreado é excluído em silêncio pelo índice.
+  const linhas = gitZ(root, ['status', '--porcelain', '-z', '--untracked-files=no', '--', ...PUBLIC_MANIFEST]);
+  return linhas.map((l) => l.trim()).filter(Boolean);
+}
+
+function limpar(alvo) {
+  try {
+    fs.rmSync(alvo, { recursive: true, force: true });
+  } catch (e) {
+    /* melhor esforço — a recusa já foi comunicada */
+  }
+}
+
+function estaDentro(pai, filho) {
+  const rel = path.relative(pai, filho);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function dirNaoVazio(dir) {
+  return fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.readdirSync(dir).length > 0;
+}
+
+function parseArgs(argv) {
+  const opts = { out: null, root: null, report: null, verifyOnly: null, allowNonEmptyOut: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--out') opts.out = argv[++i];
+    else if (a === '--root') opts.root = argv[++i];
+    else if (a === '--report') opts.report = argv[++i];
+    else if (a === '--verify-only') opts.verifyOnly = argv[++i];
+    else if (a === '--allow-nonempty-out') opts.allowNonEmptyOut = true;
+    else throw new Error(`argumento desconhecido: ${a}`);
+  }
+  return opts;
+}
+
+/* ------------------------------------------------------------------ *
+ * Modo --verify-only: re-audita uma árvore JÁ montada. Estrutura
+ * (presença ∧ contenção) primeiro, gate composto depois — auditoria de
+ * conteúdo real, não só estrutural (B1/M5).
+ * ------------------------------------------------------------------ */
+function verifyOnly(dirArg) {
+  const dir = path.resolve(dirArg);
+  const problemas = auditStructure(dir);
+  if (problemas.length > 0) {
+    for (const p of problemas) process.stderr.write(`${p}\n`);
+    process.stderr.write(`\n${problemas.length} problema(s) estrutural(is) em ${dir}. Auditoria vermelha.\n`);
+    return 1;
+  }
+  const code = runGate(dir);
+  if (code !== 0) {
+    process.stderr.write(`\nGate composto reprovou a árvore em ${dir}. Auditoria vermelha.\n`);
+    return code;
+  }
+  process.stdout.write(`Cobertura do gate: ${COBERTURA_GATE}\n`);
+  process.stdout.write(`Árvore auditada em ${dir}: contenção, presença e gate composto verdes.\n`);
+  return 0;
+}
+
+function montar(opts) {
+  // ── Validação de argumentos ANTES de criar qualquer `.partial` (M6) ──
+  if (!opts.out) throw new Error('--out <dir> é obrigatório (ou use --verify-only <dir>)');
+  const root = path.resolve(opts.root || REPO_ROOT);
+  const out = path.resolve(opts.out);
+  if (!fs.existsSync(root)) throw new Error(`--root não encontrado: ${root}`);
+  if (estaDentro(root, out)) {
+    process.stderr.write(`--out não pode ficar dentro de --root (auto-cópia): ${out} está sob ${root}\n`);
+    return 2;
+  }
+  if (dirNaoVazio(out) && !opts.allowNonEmptyOut) {
+    process.stderr.write(`--out existe e não está vazio: ${out}\n`);
+    process.stderr.write('Recusado sem apagar nada. Use --allow-nonempty-out para autorizar a sobrescrita explicitamente.\n');
+    return 2;
+  }
+
+  // ── Sujeira sob o manifesto: fail-closed (B2) ──
+  const sujos = checarSujeira(root);
+  if (sujos.length > 0) {
+    process.stderr.write('modificação não-commitada sob o manifesto — o que se publica é um commit, não o estado da mesa de alguém:\n');
+    for (const s of sujos) process.stderr.write(`  ${s}\n`);
+    return 3;
+  }
+
+  const partial = `${out}.partial`;
+  limpar(partial);
+  fs.mkdirSync(partial, { recursive: true });
+
+  let arquivos;
+  try {
+    arquivos = copiarDoIndice(root, partial);
+  } catch (e) {
+    limpar(partial);
+    throw e;
+  }
+
+  // ── Gate composto DENTRO da árvore montada (I2) ──
+  const gateCode = runGate(partial);
+  if (gateCode !== 0) {
+    limpar(partial);
+    process.stderr.write(`\nGate composto reprovou a árvore montada a partir de ${root}. Nada foi publicado.\n`);
+    return gateCode;
+  }
+
+  // ── Contenção COM presença, sobre a mesma árvore (M5) ──
+  const problemas = auditStructure(partial);
+  if (problemas.length > 0) {
+    for (const p of problemas) process.stderr.write(`${p}\n`);
+    limpar(partial);
+    process.stderr.write(`\n${problemas.length} problema(s) estrutural(is) na árvore montada. Nada foi publicado.\n`);
+    return 1;
+  }
+
+  // ── Só agora o rename: ele É o marcador de conclusão (M6/AC-20). ──
+  // `renameSync` sobre um alvo existente e não-vazio falha com ENOTEMPTY, então
+  // o alvo é removido antes — só se chegou aqui, ou seja, ou estava vazio, ou
+  // --allow-nonempty-out autorizou explicitamente.
+  if (fs.existsSync(out)) fs.rmSync(out, { recursive: true, force: true });
+  fs.renameSync(partial, out);
+
+  const relatorio = {
+    gerado_em: new Date().toISOString(),
+    root,
+    out,
+    arquivos_copiados: arquivos.length,
+    entradas_manifesto: PUBLIC_MANIFEST,
+    cobertura_gate: `Cobertura do gate: ${COBERTURA_GATE}`,
+    excluidos: relatorioExclusoes(root),
+    nao_rastreados_excluidos: gitZ(root, ['ls-files', '--others', '-z', '--', ...PUBLIC_MANIFEST]),
+  };
+
+  const json = JSON.stringify(relatorio, null, 2);
+  if (opts.report) {
+    fs.mkdirSync(path.dirname(path.resolve(opts.report)), { recursive: true });
+    fs.writeFileSync(path.resolve(opts.report), `${json}\n`);
+    process.stdout.write(`Relatório em ${path.resolve(opts.report)}\n`);
+  } else {
+    process.stdout.write(`${json}\n`);
+  }
+
+  process.stdout.write(`Cobertura do gate: ${COBERTURA_GATE}\n`);
+  process.stdout.write(`Árvore pública pronta em ${out}.\n`);
+  return 0;
+}
+
+function main() {
+  let code = 1;
+  try {
+    const opts = parseArgs(process.argv.slice(2));
+    if (opts.verifyOnly) {
+      if (opts.out) throw new Error('--verify-only e --out são modos distintos; use um de cada vez');
+      code = verifyOnly(opts.verifyOnly);
+    } else {
+      code = montar(opts);
+    }
+  } catch (e) {
+    process.stderr.write(`${e && e.message ? e.message : e}\n`);
+    code = 1;
+  }
+  process.exit(typeof code === 'number' && Number.isInteger(code) ? code : 1);
+}
+
+module.exports = { PUBLIC_MANIFEST, ADDITIONAL_MANIFEST_ENTRIES, COBERTURA_GATE };
+
+if (require.main === module) main();

package/scripts/derive-ready-transitions.cjs

@@ -46,6 +46,7 @@
 //        [--since <ref|data>] [--stories-dir <dir>]
 // ---------------------------------------------------------------------------
 
+const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
@@ -89,6 +90,23 @@ function gitOrNull(repo, args) {
   }
 }
 
+// `F-4` do gate `SF13.8`: "binário `git` ausente do PATH" e "o path não existe /
+// não é repo git" são causas DISTINTAS, e a mensagem antiga tratava as duas como
+// a mesma coisa — acertava por acidente, via o parêntese "(ou o path não existe)".
+// `ENOENT` no spawn é o único sinal que separa as duas: qualquer outro erro
+// significa que o binário existe e falhou por outro motivo.
+function gitBinarioAusente() {
+  try {
+    execFileSync('git', ['--version'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return false;
+  } catch (err) {
+    return Boolean(err) && err.code === 'ENOENT';
+  }
+}
+
 // --- CLI ---------------------------------------------------------------
 
 function parseArgv(argv) {
@@ -186,7 +204,15 @@ function main(argv) {
   const repo = path.resolve(opts.repoPath);
   const topo = gitOrNull(repo, ['rev-parse', '--show-toplevel']);
   if (topo === null) {
-    diagnostico(`"${repo}" não é um repositório git acessível (ou o path não existe) — nada a derivar.`);
+    // Três causas distintas, nomeadas separadamente (`F-4` do gate `SF13.8`).
+    if (gitBinarioAusente()) {
+      const pathEnv = process.env.PATH ? process.env.PATH.slice(0, 200) : '(vazia)';
+      diagnostico(`binário \`git\` ausente do PATH (PATH=${pathEnv}) — o alvo "${repo}" não foi sequer consultado; sem git não há histórico a derivar.`);
+    } else if (!fs.existsSync(repo)) {
+      diagnostico(`o path "${repo}" não existe — nada a derivar.`);
+    } else {
+      diagnostico(`"${repo}" existe e o git está disponível, mas não é um repositório git acessível — nada a derivar.`);
+    }
     return;
   }
   const repoRoot = topo.trim();
@@ -310,9 +336,19 @@ function main(argv) {
   }
 }
 
-// D4: `exit 0` SEMPRE. A rede é aqui, e é a única — nenhuma rota interna tem
-// try/catch próprio para a mesma classe de falha, senão esta nunca seria
-// exercitada e viraria letra morta (mesma disciplina de `runWithFailSafe`).
+// D4: `exit 0` SEMPRE. Esta é a rede EXTERNA, e ela existe para o IMPREVISTO.
+// Há, sim, 2 try/catch internos, e eles tratam classes ESPERADAS e DISTINTAS
+// desta, cada uma com diagnóstico declarado: `gitOrNull()` (git indisponível ou
+// comando que falha ⇒ `null`, tratado no ponto de uso com causa nomeada) e o
+// replay de `evaluateReadyOracles` no laço (avaliação que lança ⇒ veredito
+// `ERRO` visível, jamais contado como `silencio`). Nenhum deles cobre a classe
+// desta rede, então ela não é redundante — mas também não é exercitada por
+// teste: o `F-2` do gate `SF13.8` registrou 5 tentativas de alcançá-la, todas
+// capturadas antes, com diagnóstico. Fica por desenho (mesma disciplina de
+// `runWithFailSafe`): a garantia é `exit 0` mesmo no que ninguém previu.
+// Leitura superada, não repetir: a formulação anterior deste comentário NEGAVA
+// a existência dos 2 try/catch internos acima — o desenho estava certo, a prosa
+// é que afirmava mais do que o código faz.
 if (require.main === module) {
   try {
     main(process.argv.slice(2));

package/scripts/validate-branding.js

@@ -44,14 +44,24 @@ function collectFiles(target) {
   return out.sort();
 }
 
-function scanFile(filePath) {
+/**
+ * scanFile(filePath, terms) — varre um arquivo por termos proibidos.
+ *
+ * O 2º parâmetro é opcional e defaulta para `FORBIDDEN_TERMS` deste módulo:
+ * `main()` daqui continua se comportando exatamente como antes. Ele existe
+ * para que um gate REPO-ONLY (`scripts/validate-git-vetor.cjs`, SF15.7) possa
+ * REUSAR esta varredura com uma lista composta, em vez de fazer uma 2ª cópia
+ * da lógica. Sem o parâmetro, `scanFile` fecharia sobre a lista de 5 deste
+ * módulo e o composto varreria com a lista errada — bug silencioso.
+ */
+function scanFile(filePath, terms = FORBIDDEN_TERMS) {
   const buf = fs.readFileSync(filePath);
   if (isProbablyBinary(buf)) return [];
   const violations = [];
   const lines = buf.toString('utf8').split(/\r?\n/);
   lines.forEach((line, idx) => {
     const lower = line.toLowerCase();
-    for (const term of FORBIDDEN_TERMS) {
+    for (const term of terms) {
       if (lower.includes(term)) {
         violations.push({ line: idx + 1, term, text: line.trim() });
       }
@@ -79,6 +89,12 @@ function main() {
   process.exit(0);
 }
 
-module.exports = { FORBIDDEN_TERMS, SCAN_TARGETS };
+// Exports ADITIVOS (SF15.7): `FORBIDDEN_TERMS`/`SCAN_TARGETS` são o contrato
+// que `scripts/validate-no-clone.cjs` importa e que VIAJA para toda instalação
+// (`installer/motor-scripts.json`) — inalterados. `collectFiles`,
+// `isProbablyBinary` e `scanFile` passam a ser exportados para reuso local do
+// repositório; este arquivo NÃO ganha nenhum `require` novo (um require para
+// módulo repo-only aqui crasharia toda instalação — medido, SF15.7 `B1`).
+module.exports = { FORBIDDEN_TERMS, SCAN_TARGETS, collectFiles, isProbablyBinary, scanFile };
 
 if (require.main === module) main();

package/scripts/validate-git-vetor.cjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-git-vetor.cjs — guard-rail do VETOR GIT (commits/PRs), REPO-ONLY.
+ *
+ * O vetor `npm pack` já tem guarda (`scripts/owner-layer.cjs` + `npm-scope`);
+ * o vetor `git` — o que um repositório PÚBLICO expõe a cada commit — não tinha.
+ * Esta é a ampliação medida na `SF15.7`: o gate de branding
+ * (`scripts/validate-branding.js`) já PROIBIA os nomes que vazaram na `SF15.6`,
+ * mas não OLHAVA para `docs/adr/` nem `docs/research/`, que era onde eles
+ * estavam. "Não era ausência de regra: era vão de superfície."
+ *
+ * ┌─ ESTE ARQUIVO NÃO VIAJA PARA INSTALAÇÃO — e é por isso que ele existe ────┐
+ * │ Está no `exclude` de `installer/motor-scripts.json`, mesma classe de      │
+ * │ `owner-layer.cjs` e `derive-ready-transitions.cjs`. A dependência corre   │
+ * │ REPO-ONLY → DISTRIBUÍDO (este arquivo importa `validate-branding.js`),    │
+ * │ nunca o contrário: um `require('./owner-layer.cjs')` DENTRO de            │
+ * │ `validate-branding.js` crasharia com `MODULE_NOT_FOUND` toda instalação   │
+ * │ de terceiro que roda `validate-no-clone.cjs` (medido, `SF15.7` `B1`).     │
+ * │ Por isso as 2 listas são COMPOSTAS aqui por import, e o contrato          │
+ * │ distribuído (`FORBIDDEN_TERMS`/`SCAN_TARGETS` de `validate-branding.js`)  │
+ * │ fica intocado — 5 termos, 5 alvos, exatamente como antes.                 │
+ * └──────────────────────────────────────────────────────────────────────────┘
+ *
+ * ┌─ FRONTEIRA HONESTA — o que este gate NÃO detecta, por desenho ───────────┐
+ * │ O gate reprova SE E SOMENTE SE um dos literais enumerados aparecer, em    │
+ * │ forma literal contígua, no conteúdo de um arquivo regular sob um dos      │
+ * │ alvos enumerados. Nome de arquivo, symlink, forma não-literal             │
+ * │ (espaçamento, ênfase, quebra de linha, `~`, URL-encode) e diretório fora  │
+ * │ de `SCAN_TARGETS` NÃO são cobertos, por desenho. Classe nova — termo,     │
+ * │ alvo ou forma — entra por CURADORIA HUMANA, com dono declarado; o         │
+ * │ mecanismo não promete detectar o desconhecido.                            │
+ * │                                                                          │
+ * │ DONO DAS LISTAS: `EXTRA_TARGETS`/`EXTRA_TERMS` (as 2 listas que a         │
+ * │ `SF15.7` acrescenta) são mantidas por quem editar ESTE arquivo.           │
+ * │ `SCAN_TARGETS`/`FORBIDDEN_TERMS` de origem continuam com o dono de sempre │
+ * │ (`scripts/validate-branding.js`, que hoje não tem cabeçalho de manutenção │
+ * │ formal — acrescentar um está fora do escopo da `SF15.7`).                 │
+ * └──────────────────────────────────────────────────────────────────────────┘
+ *
+ * Node >= 18, sem dependências externas. Exit 1 listando arquivo:linha de cada
+ * ocorrência; exit 0 = vetor git limpo.
+ */
+
+const path = require('node:path');
+
+const branding = require('./validate-branding.js');
+const { patternByRole } = require('./owner-layer.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+// Alvos que o gate distribuído não varre e que o repositório público expõe.
+const EXTRA_TARGETS = ['docs/adr', 'docs/research'];
+
+// Termos que NÃO entram no contrato distribuído:
+//  • `venturus` / `executive circle` — identidade de terceiro medida na `SF15.6`
+//    (`F-8`), ainda ausente do denylist de clone;
+//  • slug e path de máquina do DONO do framework — IMPORTADOS de
+//    `owner-layer.cjs` por papel (`patternByRole`), nunca copiados como literal:
+//    uma 3ª cópia derivaria em silêncio (lição `SF13.9`/`SF13.10`). Não entram
+//    em `FORBIDDEN_TERMS` distribuído por erro de categoria: o path do autor do
+//    framework não é "identidade de clone" (`SF15.7` `B1`, nota semântica).
+//  • `patternByRole('nome-civil')` NÃO entra — varrer por nome do dono foi
+//    aposentado como proxy por decisão dele (`owner-layer.cjs`, cabeçalho da
+//    seção 2; `ADR-027` Emenda 2).
+const EXTRA_TERMS = [
+  'venturus',
+  'executive circle',
+  patternByRole('slug').toLowerCase(),
+  patternByRole('path-maquina').toLowerCase(),
+];
+
+const SCAN_TARGETS = [...branding.SCAN_TARGETS, ...EXTRA_TARGETS];
+const FORBIDDEN_TERMS = [...branding.FORBIDDEN_TERMS, ...EXTRA_TERMS];
+
+function main() {
+  let total = 0;
+  for (const target of SCAN_TARGETS) {
+    // `collectFiles` e `scanFile` vêm de `validate-branding.js` — nenhuma 2ª
+    // implementação da varredura, só uma 2ª LISTA.
+    for (const filePath of branding.collectFiles(target)) {
+      const rel = path.relative(REPO_ROOT, filePath);
+      for (const v of branding.scanFile(filePath, FORBIDDEN_TERMS)) {
+        total++;
+        console.error(`${rel}:${v.line}: termo proibido "${v.term}" — ${v.text.slice(0, 100)}`);
+      }
+    }
+  }
+  if (total > 0) {
+    console.error(`\n${total} ocorrência(s) no vetor git (branding + identidade de terceiro + padrões do dono). Gate vermelho.`);
+    process.exit(1);
+  }
+  console.log('Vetor git limpo.');
+  process.exit(0);
+}
+
+module.exports = { SCAN_TARGETS, FORBIDDEN_TERMS, EXTRA_TARGETS, EXTRA_TERMS };
+
+if (require.main === module) main();

package/template/.claude/agents/pc-devops.md

@@ -2,7 +2,7 @@
 name: pc-devops
 description: "Papel DevOps do ciclo POWER CLAUDE — o ÚNICO autorizado a publicar (git push, PR, merge, release). Use para: gate pre-push completo, push fast-forward, criar PR com o porquê, merge-back de branches de wave, release com tag semver e changelog."
 model: sonnet
-budget_tokens: 1450
+budget_tokens: 1500
 tools: Read, Grep, Glob, Write, Edit, Bash
 permissionMode: acceptEdits
 ---
@@ -27,6 +27,7 @@ Você é o papel **DevOps** do ciclo POWER CLAUDE — o único autorizado a publ
 
 - **Superfície (5 arquivos), resposta POR ARQUIVO escrita na story da release, nunca um "sim" global** (`DF-SF13.5-5`): `README.md`, `template/pods/README.md`, `BACKLOG.md`, `CHANGELOG.md` e este arquivo (`pc-devops.md`) — os 2 últimos entraram porque a classe já ocorreu neles (`ADR-036`). Para cada um: "revisado; linha `<path>:<n>` reconciliada" ou "revisado; nada a mudar porque `<razão>`".
 - **Todo achado carregado é pré-condição, não nota** (`DF-SF13.5-6`): antes da tag, abrir o `docs/qa/gates/release-*.yaml` mais recente e responder na story, uma a uma e na mesma forma acima, as entradas com `dono: pc-devops` de desfecho não fechado. Sem momento obrigatório o achado reaparece: o `F-1` da `0.16.1` voltou idêntico na `0.16.2`.
+- **Espelho público (Vitrine, `ADR-037`)**, depois do `npm publish`: siga `docs/mecanismos/espelho-publico-vitrine.md` — monta com `build-public-tree.cjs`, sincroniza o remoto de NOME DISTINTIVO (nunca `origin`) e empurra por `git push` explícito, jamais dentro de script: só assim o hook vê o comando e pede `ask` (`I4`). Cadência hoje: release.
 
 ## Publicação no npm — 3 lições operacionais (`0.16.0`, 2026-08-04)