@daniellins/power-claude 0.16.3

package/template/.claude/hooks/context-budget.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * context-budget.cjs — PostToolUse hook (matcher: Read)
+ *
+ * Advisory-only: avisa quando um arquivo lido excede o orçamento de contexto
+ * (> 32KB ≈ 8k tokens). NUNCA bloqueia. Qualquer erro → exit 0 silencioso.
+ * Node puro, sem dependências.
+ */
+'use strict';
+
+const fs = require('fs');
+
+const BUDGET_BYTES = 32 * 1024; // 32KB ~ 8k tokens
+const STDIN_TIMEOUT_MS = 2000;
+
+// Guarda global: nunca deixar o hook pendurar nem falhar com código != 0.
+const killTimer = setTimeout(() => process.exit(0), STDIN_TIMEOUT_MS + 500);
+killTimer.unref();
+
+function main(raw) {
+  try {
+    const input = JSON.parse(raw);
+    const filePath = input && input.tool_input && input.tool_input.file_path;
+    if (!filePath || typeof filePath !== 'string') return process.exit(0);
+
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      return process.exit(0); // arquivo não existe / inacessível → silêncio
+    }
+    if (!stat.isFile() || stat.size <= BUDGET_BYTES) return process.exit(0);
+
+    const sizeKB = Math.round(stat.size / 1024);
+    const approxTokens = Math.round(stat.size / 4 / 1000);
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUse',
+          additionalContext:
+            `[context-budget] O arquivo lido (${filePath}, ~${sizeKB}KB / ~${approxTokens}k tokens) ` +
+            `excede o orçamento de leitura (32KB). Prefira ler por offset/limit apenas o trecho necessário, ` +
+            `ou extrair o essencial para knowledge/ e referenciar de lá.`,
+        },
+      })
+    );
+    return process.exit(0);
+  } catch {
+    return process.exit(0); // advisory: nunca falhar
+  }
+}
+
+try {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => {
+    raw += chunk;
+    if (raw.length > 1024 * 1024) process.exit(0); // input anômalo → silêncio
+  });
+  process.stdin.on('end', () => main(raw));
+  process.stdin.on('error', () => process.exit(0));
+} catch {
+  process.exit(0);
+}

package/template/.claude/hooks/enforce-cycle-authority.cjs

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * POWER CLAUDE — PreToolUse hook: as 2 garantias de AUTORIDADE do ciclo que
+ * não podem depender só de disciplina (`DF-SF12.3-2`).
+ *
+ * Predicado 1 — só o papel QA marca `Status: Done` numa story (`*.story.md`).
+ * Predicado 2 — só o papel QA escreve em `docs/qa/gates/*.yaml`.
+ * Predicado 3 — o papel Dev não edita código enquanto a story associada
+ *               (derivada da branch) está `Draft`.
+ *
+ * Canal de identidade: `input.agent_type` (o `subagent_type` literal do
+ * despacho, ex. "pc-qa") e `input.agent_id` (presente só em subagente —
+ * ausente, não vazio, no main thread). Medido, não deduzido — ver AC41 da
+ * story SF12.3. NUNCA process.env: não é escrevível pela plataforma, e um
+ * agente que editasse `.claude/settings.json` (chave `env`) poderia se
+ * autoproclamar — a mesma razão pela qual `enforce-git-push-authority.cjs`
+ * (Bloco M da mesma story) deixou de usar env var.
+ *
+ * Alcance declarado: tool calls `Edit`/`Write` apenas. Escrita por `Bash`
+ * (`sed -i`, heredoc, `python -c` etc.) e por `MultiEdit` está FORA do
+ * alcance — avaliado e rejeitado estender o matcher a `Bash` (viraria
+ * heurística de texto de comando, falso-positivo caro).
+ *
+ * Matriz allow/deny/ask — roster FECHADO de 7 papéis
+ * ({pc-analyst, pc-planner, pc-architect, pc-po, pc-dev, pc-qa, pc-devops}).
+ * `deny` só quando o papel lido é POSITIVAMENTE conhecido e POSITIVAMENTE
+ * errado (predicados 1/2); identidade ambígua (main thread, fora do roster,
+ * JSON ilegível) NUNCA vira `deny` silencioso — sempre `ask` (ou silêncio
+ * total quando não há nem estrutura para perguntar, predicado 3).
+ *
+ * SEGUNDO EIXO do mesmo contrato (`ADR-032` Emenda 3, story SF13.9): além da
+ * identidade, a EVIDÊNCIA. O predicado 1 lê o `## Status` por TOKEN, com uma
+ * escada de 3 degraus — evidência FIRME (`statusToken === 'done'`) é
+ * deny-capaz; evidência AMBÍGUA (o texto menciona "done" sem que o token seja
+ * `done`: `Not Done`, `~~Done~~`, `QA Done`, `Ready (o QA ainda não marcou
+ * Done)`) vira `ask` com o motivo NOMEADO; ausência vira silêncio. O
+ * `.includes('done')` dos dois lados está SUPERADO — não repetir: ele negava
+ * negações E deixava passar um bypass em dois passos (ver `evaluatePredicate1`).
+ *
+ * Custo: o hook sai em silêncio o MAIS CEDO possível — primeiro `tool_name`,
+ * depois o formato do `file_path`, e só então lê disco/simula a edição.
+ *
+ * Robustez (AC41 medido): `input.agent_type` está AUSENTE (não vazio) no
+ * main thread — nenhum método de string é chamado sobre ele sem checar
+ * presença antes; um TypeError faria o hook não emitir decisão nenhuma
+ * (fail-open silencioso, pior que qualquer `ask`).
+ *
+ * Circuito de destravamento (docs/mecanismos/hooks-de-autoridade-do-ciclo.md
+ * §Destravamento; `.claude/hooks/README.md`): (a) editar o arquivo fora da
+ * sessão do Claude Code; (b) remover/comentar a entrada em
+ * `.claude/settings.json`, corrigir o predicado, reinstalar.
+ *
+ * Sem dependências externas (roda em qualquer instalação limpa).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROSTER = new Set([
+  'pc-analyst',
+  'pc-planner',
+  'pc-architect',
+  'pc-po',
+  'pc-dev',
+  'pc-qa',
+  'pc-devops',
+]);
+
+const MECANISMO_DOC = 'docs/mecanismos/hooks-de-autoridade-do-ciclo.md';
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function parseInput(rawInput) {
+  try {
+    const parsed = JSON.parse(rawInput || '{}');
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isStoryFilePath(filePath) {
+  return /\.story\.md$/i.test(filePath);
+}
+
+function isGateFilePath(filePath) {
+  return /(^|[\\/])docs[\\/]qa[\\/]gates[\\/][^\\/]+\.ya?ml$/i.test(filePath);
+}
+
+function isUnderDocsPath(filePath) {
+  return /(^|[\\/])docs([\\/]|$)/i.test(filePath);
+}
+
+function normalizeStatusText(text) {
+  return String(text || '')
+    .replace(/\*\*/g, '')
+    .toLowerCase()
+    .trim();
+}
+
+// `statusToken` — o TOKEN inicial do `## Status` (`ADR-032` Emenda 3, E3.2).
+// Responde "qual é o token", NUNCA "devo disparar": quem decide quanta
+// evidência cada decisão exige é a ESCADA do sítio de chamada, e as escadas
+// dos dois consumidores (a trava de `Ready` e o P1 daqui) são deliberadamente
+// diferentes porque as decisões que elas emitem custam coisas diferentes
+// (E3.10). Uniformizá-las "por consistência" reverte a decisão.
+//
+// Três passos, cada um com caso alcançável medido: `normalizeStatusText`
+// (INALTERADA) responde por `**Ready**`; o strip de decoração à esquerda
+// responde por `` `Ready` ``; a corrida de letras responde por `Ready (…)`,
+// `Ready — …`, `Ready.` — e pelas negativas `Readyish`/`Not Ready`.
+//
+// Duas restrições NORMATIVAS sobre o conjunto de decoração, cada uma com AC
+// próprio na SF13.9 — leituras anteriores que as afrouxavam estão SUPERADAS,
+// não repetir:
+//   • `~` fica FORA. Com ele dentro, `~~Done~~` daria token `done` ⇒ `deny`
+//     sobre um status que o autor RISCOU. Com ele fora, cai no degrau de
+//     menção e vira `ask` (E3.2, extensão). Preço declarado e aceito:
+//     `~~Ready~~` não dispara a trava de `Ready` (gatilho `T-E3-RISCADO`).
+//   • `#` fica FORA. Com ele dentro, `## Done — selado pelo QA` (texto de
+//     seção VAZADA por `extractStatusSection` quando `## Status` está vazia)
+//     daria token `done` ⇒ `deny` sobre seção que não é a de status. É esta
+//     restrição que contém o vazamento ESTRUTURALMENTE, sem consertar o
+//     extrator (gatilho `T-E3-EXTRATOR`). Nota factual (`ADR-032` Emenda 4,
+//     E4.1): a demonstração `## QA Results — Done` da Emenda 3 é FALSA — com
+//     `#` no strip ela dá token `qa`, não `done`; leitura superada.
+//
+// Este comentário NÃO enumera o roster de status, de propósito: a enumeração
+// que estava escrita aqui vinha do `ADR-032` `E3.2` e estava ERRADA nos dois
+// sentidos — omitia `inprogress`, que é mandatório no ciclo, e incluía um
+// status que nenhum documento do framework define. Leitura SUPERADA, não
+// repetir (`ADR-032` Emenda 5, `E5.1`/`E5.3`/`E5.5`). Nenhum predicado deste
+// hook enumera o roster: P1 compara contra `'done'`, P3 contra `'draft'` — um
+// literal cada, e é assim que deve continuar.
+//
+// Limite honesto: a corrida é `[a-z]` ASCII, então palavra acentuada trunca
+// (`Concluída (Done)` ⇒ `conclu`). Inofensivo porque o token só é comparado
+// contra o roster de status, todo ASCII — cuja FONTE DA VERDADE é
+// `.claude/rules/authority.md` (âncora `<!-- roster:status -->`), nunca este
+// arquivo nem o ADR. Token truncado nunca casa: cai no degrau de menção do P1,
+// nunca em decisão firme.
+function statusToken(text) {
+  const norm = normalizeStatusText(text);
+  const semDecoracao = norm.replace(/^[\s*_`]+/, '');
+  const m = /^[a-z]+/.exec(semDecoracao);
+  return m ? m[0] : '';
+}
+
+// `doneEvidence` — os 3 níveis de evidência de que o status é `Done`
+// (`ADR-032` Emenda 3, E3.9). O token puro NÃO bastaria aqui: trocar
+// `includes('done')` por `statusToken(...) === 'done'` transformaria os falsos
+// positivos em SILÊNCIO, e `QA Done`/`Concluída (Done)` passariam a selar
+// `Done` sem ninguém ver — trocar um falso positivo caro por um falso negativo
+// silencioso é exatamente a troca que este mecanismo existe para não fazer.
+function doneEvidence(sectionText) {
+  if (statusToken(sectionText) === 'done') return 'token'; // firme
+  if (normalizeStatusText(sectionText).includes('done')) return 'mencao'; // ambígua
+  return 'nenhuma';
+}
+
+// Extrai o texto da seção que segue o heading `## Status`, até o próximo
+// heading de nível 1/2 ou o fim do arquivo.
+function extractStatusSection(content) {
+  const match = /^##\s*Status\s*\n([\s\S]*?)(?=\n#{1,2}\s|\s*$)/m.exec(String(content || ''));
+  return match ? match[1] : '';
+}
+
+// Simula o conteúdo resultante de um Edit/Write sem escrever em disco.
+function simulateResult(input) {
+  const filePath = input?.tool_input?.file_path;
+  if (typeof filePath !== 'string' || !filePath) return null;
+
+  let before = '';
+  try {
+    before = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    before = ''; // arquivo novo (Write) — "antes" é string vazia, de propósito
+  }
+
+  let after = before;
+  if (input.tool_name === 'Write') {
+    after = typeof input.tool_input.content === 'string' ? input.tool_input.content : '';
+  } else if (input.tool_name === 'Edit') {
+    const oldStr = input.tool_input.old_string;
+    const newStr = input.tool_input.new_string;
+    if (typeof oldStr === 'string' && typeof newStr === 'string') {
+      if (input.tool_input.replace_all) {
+        after = oldStr === '' ? before : before.split(oldStr).join(newStr);
+      } else {
+        const idx = before.indexOf(oldStr);
+        after = idx === -1 ? before : before.slice(0, idx) + newStr + before.slice(idx + oldStr.length);
+      }
+    }
+  }
+
+  return { filePath, before, after };
+}
+
+function resolveGitDir(cwd) {
+  try {
+    const gitPath = path.join(cwd, '.git');
+    const stat = fs.statSync(gitPath);
+    if (stat.isDirectory()) return gitPath;
+    if (stat.isFile()) {
+      const content = fs.readFileSync(gitPath, 'utf8');
+      const m = /^gitdir:\s*(.+)\s*$/m.exec(content);
+      if (m) {
+        const gitdir = m[1].trim();
+        return path.isAbsolute(gitdir) ? gitdir : path.resolve(cwd, gitdir);
+      }
+    }
+  } catch {
+    // sem repositório resolvível — trata como não resolvido
+  }
+  return null;
+}
+
+// Lê `.git/HEAD` diretamente (nunca spawna `git` — hook roda em caminho
+// quente de todo Edit/Write).
+function resolveBranch(cwd) {
+  const gitDir = resolveGitDir(cwd);
+  if (!gitDir) return null;
+  try {
+    const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+    const m = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+    return m ? m[1] : null; // null em detached HEAD
+  } catch {
+    return null;
+  }
+}
+
+// Token entre a PRIMEIRA barra e o PRIMEIRO hífen seguinte — sem presumir
+// prefixo de tipo (`feat/`) nem prefixo de id (`sf`). Ex.: `docs/sf12.3-x`
+// → `sf12.3`; `feat/1.6-slug` → `1.6`.
+function resolveStoryIdFromBranch(branch) {
+  if (typeof branch !== 'string') return null;
+  const m = /^[a-z]+\/([^/-]+)-/.exec(branch);
+  return m ? m[1] : null;
+}
+
+// Matriz allow/deny/ask (roster fechado). `requiredRole` XOR `forbiddenRole`.
+function decide(agentType, agentId, { requiredRole, forbiddenRole, denyOnMismatch }) {
+  if (agentId === undefined) return 'ask'; // main thread — sem identidade de subagente
+  if (typeof agentType !== 'string' || !ROSTER.has(agentType)) return 'ask'; // fora do roster fechado
+
+  const isMatch = requiredRole ? agentType === requiredRole : agentType !== forbiddenRole;
+  if (isMatch) return 'allow';
+  return denyOnMismatch ? 'deny' : 'ask';
+}
+
+// P1 — a ESCADA DE 3 DEGRAUS (`ADR-032` Emenda 3, E3.9).
+//
+// O predicado anterior — `!before.includes('done') && after.includes('done')`
+// nos DOIS lados — está SUPERADO, não repetir. Ele tinha dois defeitos
+// OPOSTOS, ambos medidos, e consertar só um deles é pior que não consertar:
+//   1. Falso positivo (lado `depois`): `InReview — não está Done ainda` contém
+//      a substring "done", logo NEGAVA uma negação. `deny` não tem caminho de
+//      aprovação dentro da sessão — bloqueia até editar `settings.json`.
+//   2. Bypass em dois passos (lado `antes`): `Ready (aguardando o Done do QA)`
+//      já contém "done" em prosa, então `!before.includes('done')` era falso e
+//      o hook CALAVA — um papel não-QA selava `Done` em duas escritas, sem
+//      interrupção nenhuma. Consertar só o `depois` deixa este lado trivial.
+//
+// A escada é o contrato do próprio hook (cabeçalho, `deny` só sobre alvo
+// "positivamente conhecido e positivamente errado") aplicado a um SEGUNDO
+// eixo: identidade ambígua nunca vira `deny` ⇒ evidência ambígua nunca vira
+// `deny`. Mesmo princípio, não exceção a ele.
+//
+// Devolve `{ decision, evidencia }` para que `main()` classifique a evidência
+// UMA vez e passe o rótulo a `buildMessage` — evitando uma 2ª leitura do mesmo
+// arquivo no caminho quente (TOCTOU: a razão emitida poderia discordar da
+// decisão se o arquivo mudasse entre as duas leituras).
+function classifyPredicate1(input) {
+  const sim = simulateResult(input);
+  if (!sim) return { decision: null, evidencia: null };
+
+  const antes = doneEvidence(extractStatusSection(sim.before));
+  const depois = doneEvidence(extractStatusSection(sim.after));
+
+  if (antes === 'token') return { decision: null, evidencia: depois }; // já estava Done
+  if (depois === 'token') {
+    // evidência FIRME ⇒ deny-capaz (é aqui que o bypass de 2 passos fecha:
+    // menção no "antes" não é token, logo não conta como "já estava Done").
+    return {
+      decision: decide(input.agent_type, input.agent_id, { requiredRole: 'pc-qa', denyOnMismatch: true }),
+      evidencia: 'token',
+    };
+  }
+  if (depois === 'mencao' && antes === 'nenhuma') {
+    // evidência AMBÍGUA ⇒ `ask`, nunca `deny` — e o motivo é NOMEADO em
+    // `buildMessage`, senão é indistinguível do `ask` de identidade ambígua.
+    return {
+      decision: decide(input.agent_type, input.agent_id, { requiredRole: 'pc-qa', denyOnMismatch: false }),
+      evidencia: 'mencao',
+    };
+  }
+  return { decision: null, evidencia: depois }; // ausência de evidência ⇒ silêncio
+}
+
+// Superfície pública estável (a suíte e os oráculos da SF13.9 comparam contra
+// a string nua `'deny'`/`'ask'`/`null`): delega, nunca reimplementa.
+function evaluatePredicate1(input) {
+  return classifyPredicate1(input).decision;
+}
+
+function evaluatePredicate2(input) {
+  return decide(input.agent_type, input.agent_id, { requiredRole: 'pc-qa', denyOnMismatch: true });
+}
+
+function evaluatePredicate3(input) {
+  const cwd = typeof input.cwd === 'string' ? input.cwd : null;
+  if (!cwd) return null; // sem cwd, sem como resolver — pass-through
+
+  const branch = resolveBranch(cwd);
+  const storyId = resolveStoryIdFromBranch(branch);
+  if (!storyId) return null; // branch fora do padrão — pass-through (AC16)
+
+  const storyPath = path.join(cwd, 'docs', 'stories', `${storyId}.story.md`);
+  let storyContent;
+  try {
+    storyContent = fs.readFileSync(storyPath, 'utf8');
+  } catch {
+    return null; // arquivo de story inexistente — pass-through (AC16)
+  }
+
+  // Por TOKEN, não por igualdade estrita (`ADR-032` E3.5): `Draft (aguardando
+  // PO)` é `Draft`, e a igualdade estrita ficava muda diante de qualquer prosa
+  // no `## Status` — leitura SUPERADA, não repetir. Escada de 2 degraus (este
+  // sítio nunca emite `deny`), diferente da do P1, por desenho (E3.10).
+  const status = statusToken(extractStatusSection(storyContent));
+  if (status !== 'draft') return null; // não é Draft — sem interferência (AC17)
+
+  return decide(input.agent_type, input.agent_id, { forbiddenRole: 'pc-dev', denyOnMismatch: false });
+}
+
+function emitDecision(permissionDecision, permissionDecisionReason) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision,
+      permissionDecisionReason,
+    },
+  }));
+}
+
+function agentLabel(input) {
+  return typeof input.agent_type === 'string' && input.agent_type
+    ? input.agent_type
+    : 'desconhecida (main thread ou identidade ausente)';
+}
+
+// `evidencia` é o rótulo já computado por `classifyPredicate1` (`'token'` /
+// `'mencao'` / `'nenhuma'`). Quando ausente (chamada de teste ou de outro
+// consumidor), é recomputado a partir das mesmas funções puras — reuso, não
+// 2ª implementação. Nomear o motivo é obrigatório: sem ele, o `ask` por
+// EVIDÊNCIA ambígua e o `ask` por IDENTIDADE ambígua saem com a mesma
+// redação, e nem o dono nem um AC conseguem distinguir os dois motivos.
+function buildMessage(predicate, filePath, input, evidencia) {
+  const identidade = agentLabel(input);
+  const destravamento = `Se isto é um falso positivo, veja ${MECANISMO_DOC} §Destravamento.`;
+
+  if (predicate === 1) {
+    let ev = evidencia;
+    if (ev === undefined || ev === null) {
+      const sim = simulateResult(input);
+      ev = sim ? doneEvidence(extractStatusSection(sim.after)) : 'nenhuma';
+    }
+    if (ev === 'mencao') {
+      return `Predicado 1 (só QA marca Status: Done): "${filePath}" tem evidência ambígua de Done na seção "## Status" — o texto MENCIONA "done" (negação, riscado, prosa ou palavra colada) sem que o token do status seja "done". Evidência ambígua nunca vira deny: por isso isto é uma pergunta, não um bloqueio. Papel exigido para selar Done: pc-qa. Identidade lida: ${identidade}. ${destravamento}`;
+    }
+    return `Predicado 1 (só QA marca Status: Done): "${filePath}" está transicionando para Done. Papel exigido: pc-qa. Identidade lida: ${identidade}. ${destravamento}`;
+  }
+  if (predicate === 2) {
+    return `Predicado 2 (só QA escreve gate file): "${filePath}" é exclusivo do papel QA. Papel exigido: pc-qa. Identidade lida: ${identidade}. ${destravamento}`;
+  }
+  return `Predicado 3 (Dev não edita sobre story Draft): a story associada à branch atual está Draft e "${filePath}" não é a story nem está sob docs/. Papel exigido: qualquer papel diferente de pc-dev (ou aprovação humana). Identidade lida: ${identidade}. ${destravamento}`;
+}
+
+function main() {
+  const rawInput = readStdin();
+  const input = parseInput(rawInput);
+
+  if (!input) {
+    // Fail-closed proporcional (AC22), assimétrico por predicado:
+    // predicados 1/2 (Done/gate file) — texto bruto aparentando um dos dois → ask, nunca deny;
+    // predicado 3 (Dev × Draft) — sem JSON válido a story ativa não é resolvível → silêncio total.
+    const looksLikeDoneTransition = /status/i.test(rawInput) && /done/i.test(rawInput);
+    const looksLikeGateFile = /docs\/qa\/gates/i.test(rawInput);
+    if (looksLikeDoneTransition || looksLikeGateFile) {
+      emitDecision(
+        'ask',
+        `O hook não conseguiu interpretar o input do PreToolUse e o texto bruto aparenta tocar Status/Done ou um gate file de QA. Aprovação humana necessária. Se isto é um falso positivo, veja ${MECANISMO_DOC} §Destravamento.`,
+      );
+    }
+    return;
+  }
+
+  if (input.tool_name !== 'Edit' && input.tool_name !== 'Write') return;
+
+  const filePath = input?.tool_input?.file_path;
+  if (typeof filePath !== 'string' || !filePath) return;
+
+  let predicate = null;
+  let decision = null;
+  let evidencia = null;
+
+  if (isStoryFilePath(filePath)) {
+    predicate = 1;
+    const classificado = classifyPredicate1(input);
+    decision = classificado.decision;
+    evidencia = classificado.evidencia;
+  } else if (isGateFilePath(filePath)) {
+    predicate = 2;
+    decision = evaluatePredicate2(input);
+  } else if (!isUnderDocsPath(filePath)) {
+    predicate = 3;
+    decision = evaluatePredicate3(input);
+  }
+
+  if (!decision || decision === 'allow') return; // silêncio total
+
+  emitDecision(decision, buildMessage(predicate, filePath, input, evidencia));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  ROSTER,
+  decide,
+  extractStatusSection,
+  normalizeStatusText,
+  statusToken,
+  doneEvidence,
+  simulateResult,
+  resolveGitDir,
+  resolveBranch,
+  resolveStoryIdFromBranch,
+  classifyPredicate1,
+  evaluatePredicate1,
+  evaluatePredicate2,
+  evaluatePredicate3,
+  isStoryFilePath,
+  isGateFilePath,
+  isUnderDocsPath,
+  parseInput,
+  main,
+};