novyr 0.1.2 → 0.2.0

package/README.md

@@ -43,6 +43,25 @@ novyr scan      # oportunidades de economia ainda não capturadas
 
 Qualquer outro subcomando é repassado ao engine.
 
+## Pipeline da ideia ao PR
+
+O `novyr pipeline "<task>"` leva uma task em linguagem natural **da ideia ao PR**:
+o host conduz `plan → dev → gate (lint/test/build) → PR`, chamando o modelo por
+etapa. Com `--review`, liga o **gate de qualidade** (review + QA bloqueiam).
+
+```bash
+novyr login                         # linka sua conta (modelo gerenciado, plano Pro)
+novyr pipeline "adicione X com testes"
+novyr pipeline --review "corrija o bug Y"   # com gate de qualidade
+```
+
+Requer o **opencode** (harness que o pipeline conduz) — não vem no pacote por ser
+um binário grande:
+
+```bash
+npm i -g opencode-ai
+```
+
 ## Privacidade
 
 A compressão é **local** — o `novyr` não envia seu código a lugar nenhum; ele só
@@ -54,5 +73,5 @@ já usa.
 O engine de compressão é o [**rtk**](https://github.com/rtk-ai/rtk) (Apache-2.0),
 distribuído num build rebrandado para `nvr`. Veja `NOTICE` para a atribuição.
 
-> A esteira de agentes autônoma (task → PR) é um produto à parte e **não** está
-> neste pacote.
+O pipeline de agentes roda sobre o [**opencode**](https://opencode.ai) (instalado à
+parte), com a config e os agentes do Novyr embutidos neste pacote.

package/bin/cli.js

@@ -104,16 +104,32 @@ if (sub === "logout") {
   process.exit(0);
 }
 
-if (sub === "pipeline") {
-  // Namespace: este pacote é o companion (compressão + economia no Claude Code).
-  // A esteira de agentes (Caminho 2, sobre o opencode) é um produto à parte e
-  // não vai neste pacote — reservamos o nome pra não confundir com o engine.
-  console.error(
-    "novyr: a esteira de agentes (pipeline / Caminho 2, opencode) não está " +
-      "incluída neste pacote.\nEste pacote é o companion: compressão + economia " +
-      "de tokens no Claude Code (`novyr setup`, `novyr line`, `novyr stats`)."
-  );
-  process.exit(1);
+if (sub === "pipeline" || sub === "ship") {
+  // Esteira de agentes "ideia → PR" — orquestrador DETERMINÍSTICO: o host conduz
+  // os estágios (plan→dev→gate→PR) e o modelo é chamado por etapa via opencode.
+  // Requer `opencode` instalado + a config do bundle (cli/config).
+  const task = argv.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+  if (!task) {
+    console.error('uso: novyr pipeline "<descrição da task>"');
+    process.exit(1);
+  }
+  const noIssue = argv.includes("--no-issue");
+  const review = argv.includes("--review"); // opt-in: review/qa/security (mais lento)
+  const { run } = require("../lib/pipeline.js");
+  run(task, { noIssue, review })
+    .then((r) => {
+      console.log("\nnovyr: pipeline concluído.");
+      if (r.issueUrl) console.log(`  Issue: ${r.issueUrl}`);
+      console.log(`  Branch: ${r.branch}`);
+      if (r.prUrl) console.log(`  PR: ${r.prUrl}`);
+      console.log(`  Gate: ${r.gatePassou ? "✓" : "—"} · Review: ${r.advisory.review || "?"} · QA: ${r.advisory.qa || "?"} · Security: ${r.advisory.security || "?"}`);
+      process.exit(0);
+    })
+    .catch((e) => {
+      console.error(`novyr: pipeline falhou: ${e.message || e}`);
+      process.exit(1);
+    });
+  return;
 }
 
 if (sub === "setup") {

package/config/opencode/AGENTS.md

@@ -0,0 +1,38 @@
+# Novyr
+
+Você é o **Novyr** — um agente de codificação de terminal que leva uma task
+**da ideia ao merge**. Não é um assistente genérico: é um engenheiro que abre
+issues, escreve código no padrão do repositório, revisa criticamente o próprio
+trabalho, roda os testes e entrega um Pull Request.
+
+## Postura
+- **Direto e pragmático.** Sem rodeios, sem elogios vazios. Faça o trabalho.
+- **PT-BR** por padrão na comunicação; código e identificadores no idioma do repo.
+- **Respeite o repositório.** Antes de escrever, leia `AGENTS.md`/`CLAUDE.md` do
+  projeto, a estrutura e as convenções existentes. Seu código deve ler como o
+  código ao redor.
+- **Critério antes de velocidade.** "Se funciona, atende os requisitos e não
+  quebra nada, está pronto." Não invente problemas; não deixe passar bugs reais.
+
+## O pipeline (full loop)
+Quando a task pede uma feature ou fix completo, você opera em estágios — cada um
+com um subagente especializado: **Planner → Dev → Reviewer → QA → Security → Merge**.
+Use o comando `/ship` para rodar o ciclo inteiro. Para passos isolados, invoque o
+subagente correspondente.
+
+## Ferramentas
+- Use `gh` (GitHub CLI) para issues e PRs. Sempre informe a URL completa.
+- Convenções de PR: branch `<issue-id>-<slug>`, PR com `Closes #<id>`, merge squash.
+
+## nvr — contexto comprimido (faça isto)
+Comandos de saída pesada **devem** ser rodados via `nvr` (compressor em Rust que
+corta 60–90% dos tokens sem perder o essencial). Quando `nvr` estiver no PATH,
+prefixe:
+- `nvr git status` / `nvr git diff` / `nvr git log`
+- `nvr grep "<padrão>" <path>`  ·  `nvr find <path>`  ·  `nvr ls`
+- `nvr npm test` / `nvr vitest` / `nvr tsc` / `nvr lint`
+- `nvr read <arquivo>` para arquivos longos
+Comandos que mudam estado (commit, push, gh) rodam normalmente. Confie na saída
+comprimida — ela preserva erros, paths e contagens.
+
+Você é o Novyr. Aja como dono do resultado.

package/config/opencode/agent/dev.md

@@ -0,0 +1,30 @@
+---
+description: Implementa a task no padrão do repositório, com testes quando fizer sentido.
+mode: all
+temperature: 0.1
+color: accent
+tools:
+  write: true
+  edit: true
+  bash: true
+---
+
+Você é o **Dev** do pipeline Novyr. Implementa a feature/fix descrita no plano.
+
+## Princípios
+- Leia antes de escrever. Seu código deve ler como o código ao redor — mesmos
+  padrões, nomes e idioms. Não introduza dependências ou abstrações sem necessidade.
+- Trilhas afinadas: **web** (Next.js/TypeScript/React) e **backend**; caia num modo
+  genérico para outras stacks, sempre seguindo as convenções do repo.
+
+> **O host do pipeline é dono do git.** Ele já criou a branch e fará o commit e o
+> PR. **Não** rode `git checkout`/`git branch`/`git commit` nem crie branches —
+> apenas edite os arquivos na branch atual. Mexer no git quebra o determinismo.
+
+## Passos
+1. Implemente a mudança mínima que satisfaz os critérios de aceite.
+2. Adicione/ajuste testes quando o projeto tiver suíte de testes.
+3. Rode build/lint/testes locais e corrija o que quebrar (pode usar bash para isso).
+
+## Saída
+Resumo do que mudou (arquivos + diff resumido) e estado de build/testes. PT-BR.

package/config/opencode/agent/merge.md

@@ -0,0 +1,34 @@
+---
+description: Abre o PR via gh, acompanha o CI e fecha o ciclo da issue.
+mode: all
+temperature: 0.1
+color: accent
+tools:
+  write: false
+  edit: false
+  bash: true
+---
+
+Você é o **Merge** do pipeline Novyr. Conduz o PR do push ao merge.
+
+## Passos
+1. Garanta que a branch está pushada: `git push -u origin <branch>`.
+2. Abra o PR:
+   ```bash
+   gh pr create --base main --title "<título da issue>" --body "<corpo>"
+   ```
+   O corpo DEVE conter:
+   - `## O que foi feito` — resumo
+   - `## Como testar` — passos
+   - `## Checklist` — itens verificados (review + QA + security)
+   - `Closes #<id>`
+3. Acompanhe o CI: `gh pr checks <id>`.
+4. Se Review, QA e Security aprovaram **e** o CI está verde, faça o merge **apenas
+   se o usuário autorizou auto-merge**:
+   ```bash
+   gh pr merge <id> --squash --delete-branch
+   ```
+   Caso contrário, deixe o PR pronto para revisão humana e informe a URL.
+
+## Saída
+URL completa do PR + estado (aberto/mergeado) + resultado do CI. PT-BR.

package/config/opencode/agent/planner.md

@@ -0,0 +1,34 @@
+---
+description: Quebra a task em escopo e critérios de aceite e define o plano do PR.
+mode: all
+temperature: 0.2
+color: success
+tools:
+  write: false
+  edit: false
+  bash: true
+---
+
+Você é o **Planner** do pipeline Novyr. Seu trabalho: transformar uma task em
+linguagem natural num plano de PR acionável.
+
+> **O host do pipeline é dono do git/GitHub.** Ele abre a issue, cria a branch e o
+> PR a partir do seu plano. **Não** rode `gh issue create` nem `git`/`gh` de escrita
+> — só produza o texto do plano abaixo.
+
+## Passos
+1. Leia `AGENTS.md`/`CLAUDE.md` do projeto se existirem (pode usar bash só p/ leitura).
+2. Esclareça o escopo da task: o que muda, quais arquivos prováveis, o que está fora.
+3. Defina **critérios de aceite** verificáveis (lista curta, objetiva).
+4. Proponha um nome de branch curto em kebab-case.
+
+## Saída (obrigatória)
+```
+## Plano — <título>
+Branch sugerida: <slug-curto>
+Critérios de aceite:
+- [ ] ...
+Arquivos prováveis: ...
+Fora de escopo: ...
+```
+Não implemente nada. Só planeje. PT-BR.

package/config/opencode/agent/qa.md

@@ -0,0 +1,41 @@
+---
+description: Roda testes, lint e cobertura; mapeia critérios de aceite contra testes.
+mode: all
+temperature: 0.1
+color: success
+tools:
+  write: false
+  edit: false
+  bash: true
+---
+
+Você é o **QA** do pipeline Novyr. Valida que a mudança é segura e testada.
+Princípio guia: **"80% de cobertura real > 100% com mocks vazios."**
+
+## Passos
+1. Descubra os comandos do projeto (package.json scripts, Makefile, CLAUDE.md/README).
+   Por stack: Node → `npm test`/`npx vitest` + `npx eslint`; Ruby → `bundle exec rspec` +
+   `rubocop`; ajuste ao que o projeto documenta.
+2. Rode, na ordem disponível: testes, lint, type-check, build.
+3. Detecte regressões: algo que passava e agora falha.
+4. Mapeie cada critério de aceite da issue contra um teste que o cobre.
+   Se um critério não tem teste, aponte como **LACUNA**.
+
+## Metas de cobertura (ajuste à doc do projeto)
+| Camada | Alvo |
+|---|---|
+| Serviços / lógica de negócio | 80%+ |
+| Controllers / handlers | happy path + erros |
+| Policies / permissões | 100% |
+| Models / entidades | validações, scopes |
+
+## Saída (obrigatória)
+```
+## QA — <issue>
+Testes: <passou/falhou> (<n> testes, <n> falhas)
+Lint: <ok/erros>  · Type-check: <ok/erros> · Build: <ok/erros>
+Critério → teste:
+- <critério>: <teste que cobre | LACUNA>
+Veredicto: APROVADO | REPROVADO
+```
+REPROVADO se houver falha de teste/lint/build ou regressão. PT-BR.

package/config/opencode/agent/reviewer.md

@@ -0,0 +1,43 @@
+---
+description: Review crítico do diff contra os critérios de aceite. Veredicto APROVADO/REPROVADO.
+mode: all
+temperature: 0.1
+color: warning
+tools:
+  write: false
+  edit: false
+  bash: true
+---
+
+Você é o **Reviewer** do pipeline Novyr — pragmático e rigoroso.
+Princípio guia: **"Se funciona, atende os requisitos e não quebra nada, aprova."**
+
+## Passos
+1. Use o contexto da task que o host fornece no prompt (escopo + critérios). Se houver
+   issue citada, `gh issue view <id>` é opcional.
+2. Pegue o diff contra a BASE que o host informa no prompt:
+   `git diff <base>...HEAD` e `git diff <base>...HEAD --name-only`. NÃO assuma `main`.
+3. Leia os arquivos tocados (e os que eles afetam).
+4. Para cada critério de aceite: **atendido / parcial / não atendido** + justificativa.
+5. Análise técnica: bugs reais, lógica incorreta, segurança, quebra de integração,
+   over-engineering, dead code. **Não** reporte formatação/estilo.
+
+## Severidades
+- **ALTA**: bug, requisito não atendido, vulnerabilidade, quebra de contrato.
+- **MÉDIA**: duplicação, pattern incorreto, dead code relevante.
+- **BAIXA**: naming, import não usado, simplificação.
+
+## Veredicto
+- **REPROVADO** se houver qualquer ALTA ou critério não atendido.
+- **APROVADO** caso contrário (MÉDIA/BAIXA viram sugestões).
+
+## Saída (obrigatória)
+```
+## Review — <issue> (<URL>)
+Veredicto: APROVADO | REPROVADO
+Critérios: ...
+Findings:
+| Severidade | arquivo:linha | descrição |
+Resumo: <1-2 frases>
+```
+Direto, fundamentado (arquivo:linha + impacto real). PT-BR.

package/config/opencode/agent/security.md

@@ -0,0 +1,49 @@
+---
+description: Varredura de segurança (OWASP Top 10 + segredos + deps) no diff antes do PR.
+mode: all
+temperature: 0.1
+color: error
+tools:
+  write: false
+  edit: false
+  bash: true
+---
+
+Você é o **Security** do pipeline Novyr — analista pragmático.
+Princípio guia: **"Sem evidência, sem finding."** Nada de vulnerabilidade hipotética;
+cada finding tem `arquivo:linha`, CVE ou regra OWASP observada no código.
+
+## Passos
+1. `git diff <base>...HEAD` (e `--name-only`) contra a BASE que o host informa no
+   prompt — analise só o que mudou. NÃO assuma `main`.
+2. **Audit de dependências** (conforme a stack, se houver deps novas):
+   - Node/JS: `npm audit` · Ruby: `bundle audit check` · Python: `pip-audit`
+3. **Segredos**: API keys, tokens, senhas, `.env` versionado no diff.
+4. **OWASP Top 10** — busque evidência (Grep/Read) nas categorias relevantes ao diff:
+
+| # | Risco | Verificar |
+|---|---|---|
+| A01 | Broken Access Control | autorização em rotas, escopo por tenant, menor privilégio |
+| A02 | Cryptographic Failures | dados sensíveis cifrados, sem secret hardcoded |
+| A03 | Injection | SQL/command/XSS por concatenação de input não sanitizado |
+| A04 | Insecure Design | rate limiting, funções admin isoladas |
+| A05 | Misconfiguration | CORS, headers de segurança, SSL |
+| A06 | Vulnerable Components | CVE em dependência (ver audit acima) |
+| A07 | Auth Failures | validação de token, rate limit no auth |
+| A08 | Data Integrity | validação de upload, CSP |
+| A09 | Logging Failures | falha de auth logada, sem dado pessoal em log |
+| A10 | SSRF | URL de usuário validada / allowlist |
+
+## Severidades
+- **CRÍTICA**: segredo exposto, RCE, auth bypass.
+- **ALTA**: injeção plausível, dado sensível vazando, CVE explorável.
+- **MÉDIA/BAIXA**: hardening, boa prática.
+
+## Saída (obrigatória)
+```
+## Security — <issue>
+Veredicto: APROVADO | REPROVADO
+Findings:
+| Severidade | arquivo:linha | descrição + remediação |
+```
+REPROVADO se houver CRÍTICA ou ALTA. Só evidência concreta. PT-BR.

package/config/opencode/opencode.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "instructions": ["./AGENTS.md"],
+  "provider": {
+    "novyr": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Novyr (serverless)",
+      "options": {
+        "baseURL": "{env:NOVYR_BASE_URL}",
+        "apiKey": "{env:NOVYR_API_KEY}"
+      },
+      "models": {
+        "managed": {
+          "name": "Novyr · modelo gerenciado (Pro)",
+          "tools": true
+        },
+        "qwen3-coder": {
+          "name": "Novyr · Qwen3-Coder (self-host)",
+          "tools": true
+        }
+      }
+    }
+  },
+  "model": "{env:NOVYR_MODEL}",
+  "small_model": "{env:NOVYR_SMALL_MODEL}",
+  "disabled_providers": ["opencode"],
+  "permission": {
+    "edit": "allow",
+    "bash": "ask",
+    "webfetch": "allow"
+  }
+}

package/lib/__tests__/pipeline.test.js

@@ -0,0 +1,54 @@
+"use strict";
+const { test } = require("node:test");
+const assert = require("node:assert");
+const { parseVerdict, stripAnsi, slugify, detectScripts, buildPrBody } = require("../pipeline.js");
+const models = require("../pipeline-models.js");
+
+test("parseVerdict: lê APROVADO/REPROVADO em vários formatos", () => {
+  assert.strictEqual(parseVerdict("Veredicto: APROVADO"), "APROVADO");
+  assert.strictEqual(parseVerdict("**Veredicto:** REPROVADO"), "REPROVADO");
+  assert.strictEqual(parseVerdict("veredicto aprovado"), "APROVADO");
+  assert.strictEqual(parseVerdict("\x1b[32mVeredicto: APROVADO\x1b[0m"), "APROVADO");
+  assert.strictEqual(parseVerdict("texto sem veredicto"), null);
+});
+
+test("stripAnsi: remove códigos de cor", () => {
+  assert.strictEqual(stripAnsi("\x1b[1m\x1b[32mok\x1b[0m"), "ok");
+});
+
+test("slugify: acentos, espaços, especiais, vazio e tamanho", () => {
+  assert.strictEqual(slugify("Adicionar Rate Limit no Login"), "adicionar-rate-limit-no-login");
+  assert.strictEqual(slugify("Cão & Café!!"), "cao-cafe");
+  assert.strictEqual(slugify(""), "task");
+  assert.strictEqual(slugify("!!!"), "task");
+  assert.ok(slugify("x".repeat(100)).length <= 40);
+});
+
+test("detectScripts: só scripts existentes; null seguro", () => {
+  assert.deepStrictEqual(detectScripts({ scripts: { test: "node --test", lint: "eslint" } }).sort(), ["lint", "test"]);
+  assert.deepStrictEqual(detectScripts({ scripts: {} }), []);
+  assert.deepStrictEqual(detectScripts(null), []);
+  assert.deepStrictEqual(detectScripts({ scripts: { build: "tsc", foo: "bar" } }), ["build"]);
+});
+
+test("buildPrBody: inclui task, Closes #id e veredictos", () => {
+  const body = buildPrBody("minha task", "plano X", { review: { verdict: "APROVADO" }, qa: { verdict: "REPROVADO" } }, 42);
+  assert.match(body, /minha task/);
+  assert.match(body, /Closes #42/);
+  assert.match(body, /review.*APROVADO/);
+  assert.match(body, /qa.*REPROVADO/);
+});
+
+test("pipeline-models: default managed + overrides por env", () => {
+  delete process.env.NOVYR_PIPELINE_MODEL;
+  delete process.env.NOVYR_PIPELINE_MODEL_REVIEW;
+  assert.strictEqual(models.modelFor("dev"), "novyr/managed");
+  process.env.NOVYR_PIPELINE_MODEL = "openrouter/qwen/qwen3-coder";
+  assert.strictEqual(models.modelFor("dev"), "openrouter/qwen/qwen3-coder");
+  process.env.NOVYR_PIPELINE_MODEL_REVIEW = "anthropic/claude-sonnet-4-6";
+  assert.strictEqual(models.modelFor("review"), "anthropic/claude-sonnet-4-6");
+  assert.strictEqual(models.modelFor("dev"), "openrouter/qwen/qwen3-coder"); // outras etapas seguem o default global
+  delete process.env.NOVYR_PIPELINE_MODEL;
+  delete process.env.NOVYR_PIPELINE_MODEL_REVIEW;
+  assert.strictEqual(models.modelFor("review"), "novyr/managed");
+});

package/lib/pipeline-models.js

@@ -0,0 +1,28 @@
+"use strict";
+// Modelo por etapa do pipeline — o ponto único pra trocar de modelo.
+//
+// Default: TODAS as etapas no modelo gerenciado (qwen via gateway), pra preservar
+// margem. Trocar de modelo NÃO exige refatorar nada — só mudar aqui ou via env:
+//
+//   NOVYR_PIPELINE_MODEL=<provider/model>            → default global
+//   NOVYR_PIPELINE_MODEL_REVIEW=<provider/model>     → override só do review
+//   (idem PLAN, DEV, QA, SECURITY, MERGE)
+//
+// Os agents do opencode NÃO fixam modelo (frontmatter sem `model:`), então o host
+// passa `-m <modelo>` por etapa e o pipeline fica plugável por design.
+
+const STAGES = ["plan", "dev", "review", "qa", "security", "merge"];
+
+const DEFAULT_MODEL = "novyr/managed";
+
+function defaultModel() {
+  return process.env.NOVYR_PIPELINE_MODEL || DEFAULT_MODEL;
+}
+
+// Modelo da etapa: override específico > default global > managed.
+function modelFor(stage) {
+  const env = process.env["NOVYR_PIPELINE_MODEL_" + String(stage).toUpperCase()];
+  return env || defaultModel();
+}
+
+module.exports = { STAGES, DEFAULT_MODEL, defaultModel, modelFor };

package/lib/pipeline.js

@@ -0,0 +1,271 @@
+"use strict";
+// Orquestrador DETERMINÍSTICO do pipeline "ideia → PR".
+//
+// O HOST conduz a sequência e os gates (git/gh/lint/test/build); o modelo é
+// chamado UMA vez por etapa, com o agent certo, via `opencode run --agent X -m M`.
+// Isso tira a orquestração das mãos do modelo (qwen é bom coder, fraco
+// orquestrador) e deixa tudo plugável por modelo (ver pipeline-models.js).
+//
+// v1 (enxuto): plan → (issue) → dev → gate(lint/test/build, com retry) → PR.
+//   review/qa/security rodam como ADVISORY (comentários no PR), não bloqueiam.
+// v2 (futuro): review/qa/security viram gates bloqueantes.
+
+const { spawnSync, spawn } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const { modelFor } = require("./pipeline-models");
+
+const STAGE_AGENT = {
+  plan: "planner", dev: "dev", review: "reviewer",
+  qa: "qa", security: "security", merge: "merge",
+};
+
+// ---- helpers puros (testáveis sem chamar modelo) ---------------------------
+
+function stripAnsi(s) {
+  // eslint-disable-next-line no-control-regex
+  return String(s).replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function slugify(s) {
+  const base = String(s)
+    .normalize("NFD").replace(/[̀-ͯ]/g, "")
+    .toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+    .slice(0, 40).replace(/-+$/g, "");
+  return base || "task";
+}
+
+// Lê o veredicto estruturado que os agents emitem ("Veredicto: APROVADO|REPROVADO").
+function parseVerdict(text) {
+  const m = stripAnsi(text).match(/Veredicto\s*:?\s*\**\s*(APROVADO|REPROVADO)/i);
+  return m ? m[1].toUpperCase() : null;
+}
+
+// Scripts determinísticos presentes no repo (só os que existem viram gate).
+function detectScripts(pkg) {
+  const s = (pkg && pkg.scripts) || {};
+  return ["lint", "test", "build"].filter((n) => typeof s[n] === "string" && s[n].trim());
+}
+
+function buildPrBody(task, planText, advisory, issueNum) {
+  const adv = Object.entries(advisory)
+    .map(([k, v]) => `- **${k}**: ${v.verdict || "(sem veredicto)"}`)
+    .join("\n");
+  return [
+    `## Task`, task, "",
+    issueNum ? `Closes #${issueNum}` : "",
+    "", `## Plano`, (planText || "").trim().slice(0, 2000),
+    "", `## Análises (advisory)`, adv || "(nenhuma)",
+    "", `🤖 Gerado pelo pipeline Novyr (determinístico).`,
+  ].filter((x) => x !== null && x !== undefined).join("\n");
+}
+
+// ---- execução --------------------------------------------------------------
+
+function sh(cmd, args, cwd, env) {
+  return spawnSync(cmd, args, {
+    cwd, env: env || process.env, encoding: "utf8", maxBuffer: 1024 * 1024 * 64,
+  });
+}
+
+function readPkg(cwd) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Ambiente p/ o opencode: config do novyr + wiring do modelo gerenciado + bash
+// liberado (headless não tem como responder "ask").
+function wireEnv() {
+  const userXdg = process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || "", ".config");
+  const env = { ...process.env };
+  env.XDG_CONFIG_HOME = path.join(__dirname, "..", "config"); // cli/config (opencode)
+  if (!env.NOVYR_BASE_URL) {
+    try {
+      const j = JSON.parse(fs.readFileSync(path.join(userXdg, "novyr", "telemetry.json"), "utf8"));
+      if (j.accountKey) {
+        env.NOVYR_BASE_URL = env.NOVYR_GATEWAY_URL || "https://novyr.dev/api/gateway/v1";
+        env.NOVYR_API_KEY = j.accountKey;
+      }
+    } catch { /* sem login — validado em run() */ }
+  }
+  env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+    disabled_providers: ["opencode"],
+    permission: { bash: "allow", edit: "allow", webfetch: "allow" },
+  });
+  return env;
+}
+
+// Etapas de análise (plan/review/qa/security) são single-shot e rápidas. O DEV é
+// iterativo (write→test→fix→retest) e, em provider upstream mais lento, 5min cortava
+// a iteração legítima no meio — gerando "0 arquivos". Por isso o dev tem budget maior.
+const STAGE_TIMEOUT_MS = Number(process.env.NOVYR_PIPELINE_STAGE_TIMEOUT_MS) || 360000; // 6min/etapa
+const DEV_TIMEOUT_MS = Number(process.env.NOVYR_PIPELINE_DEV_TIMEOUT_MS) || 900000; // 15min p/ o dev (TDD)
+
+function runAgent(stage, prompt, { cwd, env, timeoutMs = STAGE_TIMEOUT_MS }) {
+  const model = modelFor(stage);
+  const t0 = Date.now();
+  const r = spawnSync("opencode", ["run", "--agent", STAGE_AGENT[stage], "-m", model, prompt], {
+    cwd, env, encoding: "utf8", timeout: timeoutMs, maxBuffer: 1024 * 1024 * 64,
+  });
+  const secs = ((Date.now() - t0) / 1000).toFixed(0);
+  const killed = r.signal === "SIGTERM" || r.status === null;
+  return { ok: r.status === 0, killed, secs, out: stripAnsi(r.stdout || ""), err: stripAnsi(r.stderr || ""), model };
+}
+
+// Versão assíncrona — usada pra rodar as análises advisory EM PARALELO (são
+// independentes; cortar latência é o que destrava o run dentro do timeout).
+function runAgentAsync(stage, prompt, { cwd, env, timeoutMs = STAGE_TIMEOUT_MS }) {
+  const model = modelFor(stage);
+  const t0 = Date.now();
+  return new Promise((resolve) => {
+    const p = spawn("opencode", ["run", "--agent", STAGE_AGENT[stage], "-m", model, prompt], { cwd, env });
+    let out = "", err = "", killed = false;
+    const t = setTimeout(() => { killed = true; p.kill("SIGKILL"); }, timeoutMs);
+    p.stdout.on("data", (d) => (out += d));
+    p.stderr.on("data", (d) => (err += d));
+    const done = (ok) => { clearTimeout(t); resolve({ ok, killed, secs: ((Date.now() - t0) / 1000).toFixed(0), out: stripAnsi(out), err: stripAnsi(err), model }); };
+    p.on("close", (code) => done(code === 0));
+    p.on("error", (e) => { err += String(e && e.message); done(false); });
+  });
+}
+
+// Roda o pipeline. opts: { cwd, log, noIssue, maxDevRounds }
+async function run(task, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const log = opts.log || ((m) => process.stdout.write(m + "\n"));
+  if (!task || !String(task).trim()) throw new Error("task vazia");
+
+  if (sh("git", ["rev-parse", "--is-inside-work-tree"], cwd).status !== 0) {
+    throw new Error("não é um repositório git");
+  }
+  // O pipeline conduz o `opencode` (harness headless). Ele NÃO vem no pacote npm
+  // (binário grande); checa a presença e orienta a instalar.
+  const oc = sh("opencode", ["--version"], cwd);
+  if (oc.error || oc.status !== 0) {
+    throw new Error("o pipeline requer o 'opencode' — instale com: npm i -g opencode-ai");
+  }
+  const env = wireEnv();
+  // se alguma etapa usa o modelo gerenciado (novyr/*), exige login
+  const usaManaged = ["plan", "dev", "review", "qa", "security"].some((s) => modelFor(s).startsWith("novyr/"));
+  if (usaManaged && !env.NOVYR_BASE_URL) {
+    throw new Error("modelo gerenciado requer login — rode: novyr login (ou defina NOVYR_PIPELINE_MODEL=<provider/model>)");
+  }
+
+  const base = (sh("git", ["symbolic-ref", "--short", "HEAD"], cwd).stdout || "main").trim() || "main";
+
+  // 1. PLAN
+  log("▸ planner");
+  const plan = runAgent("plan", `Planeje a task: escopo, critérios de aceite e um nome de branch curto (kebab-case). Texto direto, sem abrir issue/branch (o host faz isso).\n\nTASK: ${task}`, { cwd, env });
+  log(`  planner: ${plan.secs}s${plan.killed ? " (TIMEOUT)" : ""}`);
+
+  // branch determinística (host)
+  const branch = `novyr/${slugify(task)}-${Date.now().toString(36).slice(-4)}`;
+  if (sh("git", ["checkout", "-b", branch], cwd).status !== 0) throw new Error("falha ao criar branch");
+  log(`  branch: ${branch}`);
+
+  // issue (host, via gh) — opcional
+  let issueNum = null, issueUrl = null;
+  if (!opts.noIssue) {
+    const r = sh("gh", ["issue", "create", "--title", `[novyr] ${String(task).slice(0, 70)}`, "--body", (plan.out || task).slice(0, 4000)], cwd);
+    if (r.status === 0) { issueUrl = (r.stdout || "").trim(); issueNum = (issueUrl.match(/\/(\d+)\s*$/) || [])[1] || null; log(`  issue: ${issueUrl}`); }
+    else log(`  (issue não criada: ${(r.stderr || "").trim().slice(0, 120)})`);
+  }
+
+  // 2. DEV + gate determinístico (lint/test/build) com retry
+  const maxRounds = opts.maxDevRounds || 2;
+  let gatePassou = false;
+  let gateOutput = "";
+  for (let round = 1; round <= maxRounds; round++) {
+    log(`▸ dev (rodada ${round})`);
+    const devPrompt = round === 1
+      ? `Implemente a task na branch atual, com testes quando fizer sentido.${issueNum ? ` Issue #${issueNum}.` : ""}\n\nTASK: ${task}\n\nPLANO:\n${(plan.out || "").slice(0, 3000)}`
+      : `Os gates falharam. Corrija mantendo o escopo. Saídas:\n${gateOutput}`;
+    const d = runAgent("dev", devPrompt, { cwd, env, timeoutMs: DEV_TIMEOUT_MS });
+    log(`  dev: ${d.secs}s${d.killed ? " (TIMEOUT)" : ""}`);
+
+    const scripts = detectScripts(readPkg(cwd));
+    if (scripts.length === 0) { gatePassou = true; log("  (sem scripts lint/test/build — gate pulado)"); break; }
+    const fails = [];
+    for (const s of scripts) {
+      const r = sh("npm", ["run", s, "--silent"], cwd); // env original (não o do opencode)
+      if (r.status !== 0) fails.push(`[${s}]\n${((r.stdout || "") + (r.stderr || "")).slice(-1500)}`);
+    }
+    if (fails.length === 0) { gatePassou = true; log(`  gate ✓ (${scripts.join(", ")})`); break; }
+    gateOutput = fails.join("\n\n");
+    log(`  gate ✗ (${fails.length} falha[s]) — devolvendo ao dev`);
+  }
+
+  // O dev roda com bash liberado e PODE ter criado a própria branch e commitado
+  // nela (o modelo não respeita "fique na branch atual" de forma confiável). Pra
+  // manter a garantia determinística, força a branch do host a apontar pro estado
+  // final — capturando commits que o modelo fez em branch própria — e só então
+  // commita o que sobrou no working tree. `-B` reescreve o ref pra HEAD atual sem
+  // tocar a árvore (já bate com o commit), então não há perda.
+  sh("git", ["checkout", "-B", branch], cwd);
+  sh("git", ["add", "-A"], cwd);
+  sh("git", ["commit", "-m", `feat: ${String(task).slice(0, 60)}${issueNum ? ` (#${issueNum})` : ""}`], cwd);
+
+  // 3. GATE DE QUALIDADE (opt-in via --review). review + qa BLOQUEIAM: REPROVADO
+  // devolve ao dev com o feedback, re-roda os scripts e re-commita (até maxQualityRounds).
+  // security é ADVISORY (comenta no PR mas não bloqueia — evita falso-positivo travar).
+  // Default OFF porque ~triplica o custo de tokens; com ele, o "PR confiável" tem peso.
+  const advisory = {};
+  let qualityPassed = true;
+  if (opts.review) {
+    const maxQ = opts.maxQualityRounds || 2;
+    for (let q = 1; q <= maxQ; q++) {
+      log(`▸ gate de qualidade (rodada ${q}): review + qa + security`);
+      const ctx = `BASE do diff: ${base} (use \`git diff ${base}...HEAD\`).${issueNum ? ` Issue #${issueNum}.` : ""}\nTASK: ${task}`;
+      // SEQUENCIAL (não paralelo): rodar 3 instâncias do opencode ao mesmo tempo no
+      // mesmo projeto faz elas brigarem pelo estado/sessão (~/.local/share/opencode),
+      // e todas saíam sem produzir output. Sequencial é mais lento mas confiável.
+      const rev = runAgent("review", `${ctx}\nFaça o review crítico e emita o veredicto no formato do agent reviewer.`, { cwd, env });
+      const qa = runAgent("qa", `${ctx}\nRode testes/lint/build e emita o veredicto no formato do agent qa.`, { cwd, env });
+      const sec = runAgent("security", `${ctx}\nFaça a varredura e emita o veredicto no formato do agent security.`, { cwd, env });
+      advisory.review = { text: rev.out, verdict: parseVerdict(rev.out) };
+      advisory.qa = { text: qa.out, verdict: parseVerdict(qa.out) };
+      advisory.security = { text: sec.out, verdict: parseVerdict(sec.out) };
+      log(`  review:${advisory.review.verdict || "?"} · qa:${advisory.qa.verdict || "?"} · security:${advisory.security.verdict || "?"} (advisory)`);
+
+      const blockers = ["review", "qa"].filter((s) => advisory[s].verdict === "REPROVADO");
+      if (blockers.length === 0) { qualityPassed = true; log("  gate de qualidade ✓"); break; }
+      qualityPassed = false;
+      if (q === maxQ) { log(`  gate de qualidade ✗ após ${maxQ} rodadas — PR sai marcado p/ revisão humana`); break; }
+
+      const feedback = blockers.map((s) => `### ${s}\n${(advisory[s].text || "").slice(0, 2500)}`).join("\n\n");
+      log(`  ✗ REPROVADO (${blockers.join(", ")}) — devolvendo ao dev`);
+      runAgent("dev", `O gate de qualidade reprovou. Corrija mantendo o escopo e os critérios. Feedback:\n${feedback}\n\nTASK: ${task}`, { cwd, env, timeoutMs: DEV_TIMEOUT_MS });
+      for (const s of detectScripts(readPkg(cwd))) sh("npm", ["run", s, "--silent"], cwd);
+      sh("git", ["checkout", "-B", branch], cwd);
+      sh("git", ["add", "-A"], cwd);
+      sh("git", ["commit", "-m", `fix: ajustes do gate de qualidade (rodada ${q})`], cwd);
+    }
+  }
+
+  // 4. PR (host, via gh) + comentários advisory — env ORIGINAL (gh autenticado;
+  // NÃO o env do opencode, que sobrescreve XDG_CONFIG_HOME e esconde a auth do gh).
+  let prUrl = null;
+  if (sh("git", ["push", "-u", "origin", branch], cwd).status === 0) {
+    // `--head` explícito: NÃO confiar na branch atual (o modelo pode ter movido o
+    // HEAD pra uma branch própria); o PR sempre sai da branch do host.
+    const pr = sh("gh", ["pr", "create", "--title", `[novyr] ${String(task).slice(0, 70)}`, "--body", buildPrBody(task, plan.out, advisory, issueNum), "--head", branch, "--base", base], cwd);
+    if (pr.status === 0) {
+      prUrl = (pr.stdout || "").trim();
+      for (const stage of Object.keys(advisory)) {
+        const t = (advisory[stage].text || "").trim();
+        if (t) sh("gh", ["pr", "comment", prUrl, "--body", `### ${stage}\n\n${t.slice(0, 5000)}`], cwd);
+      }
+      log(`▸ PR: ${prUrl}`);
+    } else log(`  (PR não criado: ${(pr.stderr || "").trim().slice(0, 150)})`);
+  } else log("  (push falhou — sem remote?)");
+
+  return {
+    branch, base, issueUrl, prUrl, gatePassou, qualityPassed,
+    advisory: Object.fromEntries(Object.entries(advisory).map(([k, v]) => [k, v.verdict])),
+  };
+}
+
+module.exports = { run, parseVerdict, stripAnsi, slugify, detectScripts, buildPrBody };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "novyr",
-  "version": "0.1.2",
-  "description": "Novyr — corte 60-90% dos tokens do seu Claude Code. Traz o nvr (engine de compressão) e mostra a economia em tempo real na statusline.",
+  "version": "0.2.0",
+  "description": "Novyr — corte 60-90% dos tokens do seu Claude Code (engine nvr) + pipeline de agentes da ideia ao PR. Economia em tempo real na statusline.",
   "license": "MIT",
   "homepage": "https://novyr.dev",
   "bin": {
@@ -17,7 +17,10 @@
     "lib/",
     "scripts/postinstall.js",
     "README.md",
-    "NOTICE"
+    "NOTICE",
+    "config/opencode/opencode.json",
+    "config/opencode/AGENTS.md",
+    "config/opencode/agent"
   ],
   "optionalDependencies": {
     "@novyr/nvr-linux-x64": "0.1.2",