novyr 0.1.0

package/NOTICE

@@ -0,0 +1,18 @@
+novyr
+Copyright (c) Novyr
+
+Este produto inclui e distribui um build MODIFICADO do engine "rtk" (rtk-ai/rtk),
+licenciado sob a Apache License 2.0.
+
+  rtk — https://github.com/rtk-ai/rtk
+  Licença: Apache License 2.0 — https://www.apache.org/licenses/LICENSE-2.0
+
+Modificações (NOTICE conforme Apache-2.0, seção 4):
+  O código do rtk é compilado a partir de uma versão pinada (ver RTK_VERSION no
+  workflow de release) com um patch de rebrand aplicado no build
+  (cli/scripts/rebrand-rtk.sh), que renomeia a identidade visual de "rtk" para
+  "nvr" (nome do binário, prefixo de reescrita de comandos, mensagens, arquivo de
+  awareness e diretório de config). O mecanismo de compressão de tokens é do rtk.
+
+Cada pacote de plataforma (@novyr/nvr-<os>-<cpu>) contém esse binário; os termos
+da Apache-2.0 (incluindo esta atribuição) se aplicam a ele.

package/README.md

@@ -0,0 +1,54 @@
+# novyr
+
+**Corte 60–90% dos tokens do seu Claude Code.** O `novyr` instala o engine de
+compressão (`nvr`) e mostra, em tempo real, quanto você economizou — sem API key,
+usando a sua assinatura Claude Code (ou API, se preferir).
+
+```bash
+npm install -g novyr
+```
+
+Só isso. Em instalação global, o `novyr` já ativa tudo no Claude Code (hook de
+compressão + statusLine de economia) num passo só. Recarregue o Claude Code e o
+rodapé passa a mostrar:
+
+```
+novyr ⚡ ~68% · 4.1M poupados
+```
+
+## O que ele faz
+
+O Claude Code gasta a maior parte dos tokens lendo saída de comando (`git status`,
+`cargo test`, `grep`, `ls`…). O `novyr` intercepta esses comandos por um hook e
+entrega a saída **comprimida** antes de chegar ao modelo — 60–90% menos tokens,
+sem perder o que importa. E te dá a visão do que foi economizado.
+
+- **Compressão** — engine `nvr` (Rust, <10ms) via hook `PreToolUse`.
+- **Economia visível** — statusLine no Claude Code, atualizando enquanto você usa.
+- **Sem API key** — funciona na sua assinatura Claude Code Pro/Max.
+- **Model/harness-agnostic** — opera na camada de saída do shell.
+
+## Comandos
+
+```bash
+novyr setup     # (re)ativa o hook + statusLine no Claude Code
+novyr line      # a linha de economia (usada pela statusLine)
+novyr stats     # dashboard de economia (hoje / histórico / por comando)
+novyr scan      # oportunidades de economia ainda não capturadas
+```
+
+Qualquer outro subcomando é repassado ao engine.
+
+## Privacidade
+
+A compressão é **local** — o `novyr` não envia seu código a lugar nenhum; ele só
+encolhe a saída de comando antes de ela entrar no contexto do modelo que **você**
+já usa.
+
+## Sob o capô
+
+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.

package/bin/cli.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+"use strict";
+// novyr — camada sobre o engine de compressão (rtk oficial; fork nvr na
+// transição). Os nomes `novyr`, `nvr` e `rtk` apontam todos para este shim
+// (ver "bin" no package.json), porque o hook do Claude Code chama o engine
+// puro no PATH (`<engine> agent claude`) e a statusLine chama `nvr line`.
+//
+// Despacho:
+//   novyr line   → lê o JSON do engine (gain/stats) e imprime a statusLine
+//   novyr setup  → ativa hook + statusLine no Claude Code
+//   *            → repassa pro binário do engine (inclui o hook `agent claude`)
+
+const { runEngine, engineJsonFirst } = require("../lib/engine.js");
+const { formatLine } = require("../lib/format-line.js");
+
+const argv = process.argv.slice(2);
+const sub = argv[0];
+
+if (sub === "line") {
+  // Statusline: nunca pode "errar" — na dúvida, imprime o estado ocioso.
+  let json = null;
+  try {
+    json = engineJsonFirst([
+      ["gain", "--format", "json"], // rtk
+      ["stats", "--format", "json"], // fork nvr
+    ]);
+  } catch {
+    json = null;
+  }
+  process.stdout.write(formatLine(json) + "\n");
+  // Telemetria opt-in: dispara um worker destacado (não trava a statusLine).
+  try {
+    require("../lib/telemetry.js").maybeSendInBackground();
+  } catch {
+    /* telemetria nunca quebra a statusLine */
+  }
+  process.exit(0);
+}
+
+if (sub === "telemetry") {
+  // Opt-in de telemetria agregada (privacy-clean). Ver lib/telemetry.js.
+  const tel = require("../lib/telemetry.js");
+  const action = argv[1];
+  if (action === "on") {
+    tel.enable();
+    console.log(
+      "novyr: telemetria LIGADA — só contadores agregados, nunca código.\n" +
+        `  Endpoint: ${tel.endpoint()}\n` +
+        `  Config:   ${tel.configPath()}\n` +
+        "  Desligue quando quiser: novyr telemetry off"
+    );
+    process.exit(0);
+  }
+  if (action === "off") {
+    tel.disable();
+    console.log("novyr: telemetria DESLIGADA.");
+    process.exit(0);
+  }
+  if (action === "status") {
+    console.log(JSON.stringify(tel.status(), null, 2));
+    process.exit(0);
+  }
+  if (action === "send") {
+    // Worker interno (disparado pela statusLine). Best-effort, silencioso.
+    tel.runSend().finally(() => process.exit(0));
+  } else {
+    console.error(
+      "uso: novyr telemetry <on|off|status>\n" +
+        "  on      compartilha contadores agregados de economia (opt-in)\n" +
+        "  off     para de compartilhar\n" +
+        "  status  mostra estado atual"
+    );
+    process.exit(action ? 1 : 0);
+  }
+  return;
+}
+
+if (sub === "login") {
+  // Linka o CLI a uma conta cloud. Sem key, faz o device flow (abre o navegador
+  // pra autorizar); com key, linka direto. Salva a accountKey em
+  // ~/.config/novyr/telemetry.json — é o token que o launcher do pipeline usa
+  // pra falar com o gateway do modelo gerenciado.
+  const tel = require("../lib/telemetry.js");
+  tel
+    .login(argv[1])
+    .then((r) => {
+      console.log(
+        "novyr: conta linkada.\n" +
+          `  Dashboard: ${r.dashboardUrl}\n` +
+          "  Modelo gerenciado (Pro): selecione com `novyr provider glm`."
+      );
+      process.exit(0);
+    })
+    .catch((e) => {
+      console.error(`novyr: login falhou: ${e.message || e}`);
+      process.exit(1);
+    });
+  return;
+}
+
+if (sub === "logout") {
+  require("../lib/telemetry.js").logout();
+  console.log("novyr: conta deslinkada (para de enviar ao dashboard).");
+  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 === "setup") {
+  // require tardio: só carrega o setup quando necessário (mantém o hook leve).
+  const { runSetup } = require("../lib/setup.js");
+  try {
+    runSetup();
+    process.exit(0);
+  } catch (err) {
+    console.error(`novyr: setup falhou: ${err.message || err}`);
+    process.exit(1);
+  }
+}
+
+// Tudo o mais → engine (inclui o hook do Claude Code, que repassa stdin/stdout).
+// `stats` é alias amigável pro `gain` do engine (mantém o README e o hábito).
+const forwardArgs = sub === "stats" ? ["gain", ...argv.slice(1)] : argv;
+let result;
+try {
+  result = runEngine(forwardArgs);
+} catch (err) {
+  console.error(err.message || String(err));
+  process.exit(1);
+}
+if (result.error) {
+  console.error(`novyr: falha ao executar o engine: ${result.error.message}`);
+  process.exit(1);
+}
+process.exit(result.status === null ? 1 : result.status);

package/lib/engine.js

@@ -0,0 +1,53 @@
+"use strict";
+// Wrapper de execução do engine (rtk oficial; durante a transição, o fork nvr).
+// O shim resolve o binário empacotado e repassa; este módulo concentra as
+// chamadas que o wrapper faz por conta própria (statusline, setup).
+
+const { spawnSync } = require("node:child_process");
+const { resolveBinary } = require("./resolve-binary.js");
+
+// Executa o engine repassando stdio (uso geral / forward).
+function runEngine(args, opts = {}) {
+  const bin = resolveBinary();
+  return spawnSync(bin, args, { stdio: "inherit", ...opts });
+}
+
+// Executa candidatos de subcomando até um sair 0 com JSON válido no stdout.
+// Cobre a divergência de nomes entre rtk (`gain`) e o fork (`stats`).
+function engineJsonFirst(candidates) {
+  const bin = resolveBinary();
+  for (const args of candidates) {
+    const r = spawnSync(bin, args, { encoding: "utf8" });
+    if (r.status === 0 && r.stdout) {
+      try {
+        return JSON.parse(r.stdout);
+      } catch {
+        /* tenta o próximo candidato */
+      }
+    }
+  }
+  return null;
+}
+
+// Executa o primeiro candidato de argv que sair com sucesso (status 0/null).
+// Cobre rtk (`init -g`) vs fork (`setup --global`). O stdout do candidato é
+// repassado (a mensagem de sucesso aparece), mas o stderr das tentativas que
+// falham é engolido — só vaza se TODOS falharem.
+function runEngineFirst(candidates) {
+  const bin = resolveBinary();
+  let lastErr = "";
+  for (const args of candidates) {
+    const r = spawnSync(bin, args, {
+      stdio: ["inherit", "inherit", "pipe"],
+      encoding: "utf8",
+    });
+    if (!r.error && (r.status === 0 || r.status === null)) {
+      return true;
+    }
+    lastErr = (r.stderr || "").toString();
+  }
+  if (lastErr) process.stderr.write(lastErr);
+  return false;
+}
+
+module.exports = { runEngine, engineJsonFirst, runEngineFirst, resolveBinary };

package/lib/format-line.js

@@ -0,0 +1,51 @@
+"use strict";
+// Formata a linha de economia da statusLine a partir do JSON do `gain`/`stats`
+// do engine. Texto neutro e honesto: "~" porque a contagem de tokens é
+// estimativa (heurística de chars), e a economia em R$ é uma *equivalência de
+// custo de API* — vale como ordem de grandeza, não como fatura.
+//
+// IMPORTANTE (honestidade da claim): o valor em R$ é "quanto custaria, em API,
+// os tokens que o novyr evitou de mandar pro modelo". Quem está em assinatura
+// flat (ex.: Claude Pro) não paga isso diretamente; e prompt caching do provider
+// reduz o custo real de tokens repetidos. Por isso o "~" e o rótulo "equiv.".
+
+// Preço padrão por milhão de tokens economizados, em BRL. Os tokens poupados são
+// essencialmente *input* (saída de comando que entraria no contexto). Default
+// ancorado em input de modelo de ponta (~US$3/Mtok × ~R$5,4/US$ ≈ R$16/Mtok).
+// Sobrescrevível por `NOVYR_BRL_PER_MTOK` (ex.: outro modelo/câmbio).
+const DEFAULT_BRL_PER_MTOK = 16;
+
+function brlPerMtok() {
+  const v = Number(process.env.NOVYR_BRL_PER_MTOK);
+  return Number.isFinite(v) && v > 0 ? v : DEFAULT_BRL_PER_MTOK;
+}
+
+function formatTokens(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + "K";
+  return String(n);
+}
+
+// R$ a partir de tokens poupados. Compacto: "R$ 81", "R$ 1,2k".
+function savedBRL(savedTokens) {
+  return (savedTokens / 1_000_000) * brlPerMtok();
+}
+function formatBRL(value) {
+  if (value >= 1000) return "R$ " + (value / 1000).toFixed(1).replace(".", ",") + "k";
+  return "R$ " + Math.round(value);
+}
+
+// json: shape do engine → { summary: { total_commands, total_saved, avg_savings_pct, ... } }
+function formatLine(json) {
+  const s = json && json.summary;
+  if (!s || !s.total_commands) {
+    return "novyr ⚡ pronto";
+  }
+  const pct = Math.round(s.avg_savings_pct || 0);
+  const saved = formatTokens(s.total_saved || 0);
+  const brl = formatBRL(savedBRL(s.total_saved || 0));
+  // novyr ⚡ ~R$ 81 · ~80% · 5.0M tok
+  return `novyr ⚡ ~${brl} · ~${pct}% · ${saved} tok`;
+}
+
+module.exports = { formatLine, formatTokens, formatBRL, savedBRL, brlPerMtok };

package/lib/resolve-binary.js

@@ -0,0 +1,46 @@
+"use strict";
+// Resolves the path to the bundled `nvr` binary for the current platform.
+//
+// The binary is delivered as a per-platform optional dependency
+// (@novyr/nvr-<os>-<cpu>) — the esbuild/biome/turbo pattern. npm installs only
+// the package whose os/cpu match the host, so exactly one is present.
+
+const targets = require("./targets.cjs");
+
+const SCOPE = "@novyr";
+const BIN = "nvr";
+
+function platformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function packageName(key = platformKey()) {
+  return `${SCOPE}/${BIN}-${key}`;
+}
+
+// Returns the absolute path to the nvr binary, or throws a helpful error.
+function resolveBinary() {
+  const key = platformKey();
+  const target = targets[key];
+  if (!target) {
+    throw new Error(
+      `novyr: plataforma não suportada (${key}).\n` +
+        `Alvos disponíveis: ${Object.keys(targets).join(", ")}.`
+    );
+  }
+
+  const pkg = packageName(key);
+  const file = `${BIN}${target.exe}`;
+  try {
+    // The platform package ships the binary at its package root.
+    return require.resolve(`${pkg}/${file}`);
+  } catch (_e) {
+    throw new Error(
+      `novyr: binário do nvr não encontrado para ${key} (${pkg}).\n` +
+        `Reinstale com:  npm install -g novyr\n` +
+        `Se você instalou com --ignore-scripts ou atrás de um proxy, veja NPM_PACKAGING.md.`
+    );
+  }
+}
+
+module.exports = { resolveBinary, packageName, platformKey, targets };

package/lib/setup.js

@@ -0,0 +1,250 @@
+"use strict";
+// `novyr setup`: ativa o engine no Claude Code e crava a statusLine de economia.
+//
+// 1) Roda o setup NATIVO do engine (rtk `init -g` / fork `setup --global`), que
+//    escreve o hook correto para aquela versão + a awareness + filtros.
+// 2) Acrescenta nossa statusLine (`nvr line`) no ~/.claude/settings.json —
+//    idempotente, com backup .bak, sem clobberar uma statusLine custom.
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { runEngineFirst } = require("./engine.js");
+const { resolveBinary } = require("./resolve-binary.js");
+
+// Usa o nome de marca `novyr` (evita conflito com um `nvr`/`rtk` pré-existente
+// no PATH; em produção os dois resolvem pro mesmo shim).
+const STATUSLINE_COMMAND = "novyr line";
+const ENGINE_NAMES = new Set(["nvr", "rtk", "novyr"]);
+
+function claudeDir() {
+  // Mesmo override que o engine respeita, pra permitir teste isolado.
+  return process.env.TKF_CLAUDE_DIR || path.join(os.homedir(), ".claude");
+}
+
+function runSetup() {
+  // 1. Setup nativo do engine (instala o hook da versão correta + awareness).
+  const ok = runEngineFirst([
+    ["init", "-g", "--auto-patch"], // rtk
+    ["setup", "--global", "--auto-patch"], // fork nvr
+  ]);
+  if (!ok) {
+    console.error(
+      "novyr: não consegui rodar o setup do engine — verifique a instalação."
+    );
+  }
+
+  // 2. Tira o node do hot-path: o hook passa a chamar o binário por caminho
+  // absoluto (o setup do engine o escreve com nome bare, que iria pelo shim) e
+  // com o subcomando que o engine RESOLVIDO realmente entende. Falha aqui não é
+  // silenciosa: sem o hook normalizado o filtro pode nem rodar.
+  try {
+    rewriteHook(resolveBinary());
+  } catch (err) {
+    const msg = (err && err.message) || String(err);
+    console.error(
+      `novyr: não consegui normalizar o hook (${msg}).\n` +
+        "  O engine pode não estar instalado via npm — rode `npm install -g novyr` e `novyr setup` de novo."
+    );
+  }
+
+  // 2.5. Multi-tool: instala o hook do nvr nas OUTRAS ferramentas de coding que
+  // o usuário já tem (Cursor/Windsurf/Gemini). Tira o risco de apostar só no
+  // Claude Code. Só roda pra ferramenta presente (config dir existe) — não cria
+  // config pra tool que o usuário não usa.
+  setupExtraAgents();
+
+  // 3. Nossa statusLine (específica do Claude Code).
+  ensureStatusLine();
+}
+
+// Agents extras que o engine 0.42.4 configura de forma LIMPA e GLOBAL.
+// Só Gemini entra hoje: `--gemini` instala um hook global em ~/.gemini (exit 0,
+// sem efeito colateral). Cursor e Windsurf ficam de fora de propósito:
+//   - `--agent cursor`  reescreve ~/.claude (re-registra o hook do Claude) —
+//     desfaria o nosso hook único/absoluto. Pior que não fazer nada.
+//   - `--agent windsurf` grava `.windsurfrules` *project-local* no cwd, não um
+//     hook global — efeito colateral indesejado num `setup` global.
+// Reavaliar quando o engine ganhar suporte global de verdade pra esses dois.
+const EXTRA_AGENTS = [
+  { name: "gemini", probe: [".gemini"], args: ["init", "-g", "--auto-patch", "--gemini"] },
+];
+
+function homeHas(rel) {
+  try {
+    return fs.existsSync(path.join(os.homedir(), rel));
+  } catch {
+    return false;
+  }
+}
+
+// Quais agents extras configurar. Default: auto-detecta pelas ferramentas
+// presentes. Override explícito por `NOVYR_SETUP_AGENTS=cursor,windsurf`
+// (string vazia => nenhum extra, útil pra ambiente limpo/teste).
+function extraAgentsToSetup() {
+  const forced = process.env.NOVYR_SETUP_AGENTS;
+  if (forced != null) {
+    const want = new Set(forced.split(",").map((s) => s.trim()).filter(Boolean));
+    return EXTRA_AGENTS.filter((a) => want.has(a.name));
+  }
+  return EXTRA_AGENTS.filter((a) => a.probe.some(homeHas));
+}
+
+function setupExtraAgents() {
+  let bin;
+  try {
+    bin = resolveBinary();
+  } catch {
+    return; // sem engine resolvido: nada a fazer
+  }
+  for (const agent of extraAgentsToSetup()) {
+    const r = spawnSync(bin, agent.args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    if (!r.error && (r.status === 0 || r.status === null)) {
+      console.log(`  ${agent.name}: hook do nvr instalado`);
+    } else {
+      const why = ((r.stderr || (r.error && r.error.message) || "").trim().split("\n")[0]) || "erro";
+      console.error(`  ${agent.name}: setup falhou (${why}) — ignorado`);
+    }
+  }
+}
+
+function firstToken(cmd) {
+  return (cmd.trim().split(/\s+/)[0] || "").replace(/^["']|["']$/g, "");
+}
+function isEngineCommand(cmd) {
+  const base = firstToken(cmd).split(/[\\/]/).pop();
+  return ENGINE_NAMES.has(base);
+}
+function subcmdOf(cmd) {
+  return cmd.trim().split(/\s+/).slice(1).join(" ");
+}
+
+// Descobre qual subcomando de hook o engine RESOLVIDO entende, perguntando ao
+// próprio binário em vez de confiar em entradas antigas do settings (que podem
+// ser de um engine já desinstalado). Engines divergem: o rtk/oficial usa
+// `hook claude`, o fork usa `agent claude`. Testamos cada candidato com um input
+// de PreToolUse e aceitamos o que devolver o JSON de rewrite esperado.
+function detectHookSubcmd(absEngine) {
+  const probe = JSON.stringify({
+    tool_name: "Bash",
+    tool_input: { command: "git status" },
+  });
+  for (const subcmd of ["hook claude", "agent claude"]) {
+    const r = spawnSync(absEngine, subcmd.split(" "), {
+      input: probe,
+      encoding: "utf8",
+    });
+    if (r.status !== 0 || !r.stdout) continue;
+    try {
+      if (JSON.parse(r.stdout).hookSpecificOutput) return subcmd;
+    } catch {
+      /* não é o subcomando certo: tenta o próximo */
+    }
+  }
+  return null;
+}
+
+// Herda o subcomando de uma entrada de engine já existente no settings.
+function existingSubcmd(pre) {
+  for (const entry of pre) {
+    if (!entry || !Array.isArray(entry.hooks)) continue;
+    for (const h of entry.hooks) {
+      const cmd = (h && h.command) || "";
+      if (isEngineCommand(cmd)) {
+        const s = subcmdOf(cmd);
+        if (s) return s;
+      }
+    }
+  }
+  return "";
+}
+
+// Reescreve o hook do engine para o caminho absoluto do binário e DEDUPA.
+// Idempotente: como o setup do engine re-adiciona o comando bare a cada run
+// (não reconhece o nosso absoluto), aqui colapsamos TODAS as entradas de engine
+// — de qualquer engine/subcomando — numa única, com o subcomando correto.
+function rewriteHook(absEngine) {
+  const file = path.join(claudeDir(), "settings.json");
+  if (!fs.existsSync(file)) return;
+  let root;
+  try {
+    root = JSON.parse(fs.readFileSync(file, "utf8") || "{}");
+  } catch {
+    return;
+  }
+  const pre = root && root.hooks && root.hooks.PreToolUse;
+  if (!Array.isArray(pre)) return;
+
+  // Subcomando: pergunta ao engine; se não der, herda do settings; por fim,
+  // cai no default do rtk.
+  const subcmd =
+    detectHookSubcmd(absEngine) || existingSubcmd(pre) || "hook claude";
+
+  // Remove toda entrada de engine (qualquer subcomando) — recriamos uma só.
+  for (const entry of pre) {
+    if (!entry || !Array.isArray(entry.hooks)) continue;
+    entry.hooks = entry.hooks.filter(
+      (h) => !isEngineCommand((h && h.command) || "")
+    );
+  }
+  // Mantém entradas de terceiros; descarta as que ficaram vazias.
+  root.hooks.PreToolUse = pre.filter(
+    (e) => e && Array.isArray(e.hooks) && e.hooks.length > 0
+  );
+
+  root.hooks.PreToolUse.push({
+    matcher: "Bash",
+    hooks: [{ type: "command", command: `"${absEngine}" ${subcmd}` }],
+  });
+
+  fs.writeFileSync(file, JSON.stringify(root, null, 2) + "\n");
+}
+
+function ensureStatusLine() {
+  const dir = claudeDir();
+  const file = path.join(dir, "settings.json");
+
+  let root = {};
+  if (fs.existsSync(file)) {
+    const content = fs.readFileSync(file, "utf8");
+    if (content.trim()) {
+      try {
+        root = JSON.parse(content);
+      } catch {
+        console.error(`novyr: ${file} inválido — statusLine não adicionada.`);
+        return;
+      }
+    }
+  } else {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Respeita uma statusLine existente; só a nossa é idempotente.
+  if (root.statusLine) {
+    const cmd = (root.statusLine.command || "").toString();
+    if (!(cmd.includes("nvr") && cmd.includes("line"))) {
+      console.log(
+        "  settings.json: statusLine custom mantida (economia via `novyr stats`)"
+      );
+    }
+    return;
+  }
+
+  if (fs.existsSync(file)) {
+    try {
+      fs.copyFileSync(file, file + ".bak");
+    } catch {
+      /* backup best-effort */
+    }
+  }
+
+  root.statusLine = { type: "command", command: STATUSLINE_COMMAND };
+  fs.writeFileSync(file, JSON.stringify(root, null, 2) + "\n");
+  console.log("  settings.json: statusLine de economia adicionada (novyr line)");
+}
+
+module.exports = { runSetup, ensureStatusLine, STATUSLINE_COMMAND };

package/lib/targets.cjs

@@ -0,0 +1,43 @@
+// Single source of truth for the platforms we ship the nvr binary for.
+//
+// key  = "<node-platform>-<node-arch>" (process.platform + process.arch),
+//        also used to name the npm package: @novyr/nvr-<key>
+// rustTarget = the Rust target triple CI cross-compiles for
+// os/cpu     = npm package fields so npm installs only the matching one
+// exe        = binary extension on that platform
+//
+// Used by: lib/resolve-binary.js (runtime), scripts/build-platform-packages.mjs
+// (CI assembly), and mirrored in package.json optionalDependencies.
+module.exports = {
+  "linux-x64": {
+    // rtk publica o linux-x64 como musl (estático/portátil); arm64 é gnu.
+    rustTarget: "x86_64-unknown-linux-musl",
+    os: "linux",
+    cpu: "x64",
+    exe: "",
+  },
+  "linux-arm64": {
+    rustTarget: "aarch64-unknown-linux-gnu",
+    os: "linux",
+    cpu: "arm64",
+    exe: "",
+  },
+  "darwin-x64": {
+    rustTarget: "x86_64-apple-darwin",
+    os: "darwin",
+    cpu: "x64",
+    exe: "",
+  },
+  "darwin-arm64": {
+    rustTarget: "aarch64-apple-darwin",
+    os: "darwin",
+    cpu: "arm64",
+    exe: "",
+  },
+  "win32-x64": {
+    rustTarget: "x86_64-pc-windows-msvc",
+    os: "win32",
+    cpu: "x64",
+    exe: ".exe",
+  },
+};

package/lib/telemetry.js

@@ -0,0 +1,306 @@
+"use strict";
+// Telemetria de economia — OPT-IN e privacy-clean. É a fundação do produto:
+// sem dado agregado não dá pra mostrar economia na nuvem nem benchmark entre
+// times. Mas a promessa é zero-retention de código, então aqui SÓ trafegam
+// contadores agregados + um id anônimo aleatório. Nunca: trechos de código,
+// caminhos de arquivo, nomes de repo, texto de comando.
+//
+// Fluxo:
+//   `novyr telemetry on|off|status`  → gerencia o opt-in
+//   `novyr line`                     → se ligado e "vencido", dispara um worker
+//                                       destacado (`novyr telemetry send`) sem
+//                                       travar a statusLine
+//   `novyr telemetry send`           → o worker: lê o JSON do engine, monta o
+//                                       payload agregado e faz POST
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const { spawn } = require("node:child_process");
+
+const DEFAULT_BASE = "https://novyr.dev";
+const SEND_INTERVAL_MS = 6 * 60 * 60 * 1000; // no máximo 1 envio a cada 6h
+
+function apiBase() {
+  return process.env.NOVYR_API_BASE || DEFAULT_BASE;
+}
+function deviceCodeUrl() {
+  return apiBase() + "/api/cli/device-code";
+}
+function tokenUrl() {
+  return apiBase() + "/api/cli/token";
+}
+// Dashboard é autenticado por sessão (Clerk) — não carrega mais a key na URL.
+function dashboardUrl() {
+  return apiBase() + "/dashboard";
+}
+
+function configDir() {
+  const base =
+    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(base, "novyr");
+}
+function configPath() {
+  return path.join(configDir(), "telemetry.json");
+}
+function endpoint() {
+  return process.env.NOVYR_TELEMETRY_URL || apiBase() + "/api/telemetry";
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(configPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(cfg) {
+  fs.mkdirSync(configDir(), { recursive: true });
+  fs.writeFileSync(configPath(), JSON.stringify(cfg, null, 2) + "\n");
+}
+
+// id anônimo estável por máquina — aleatório, não derivado de nada do usuário.
+function ensureAnonId(cfg) {
+  if (!cfg.anonId) {
+    cfg.anonId = crypto.randomUUID();
+    saveConfig(cfg);
+  }
+  return cfg.anonId;
+}
+
+function isEnabled() {
+  return loadConfig().enabled === true;
+}
+function enable() {
+  const cfg = loadConfig();
+  cfg.enabled = true;
+  ensureAnonId(cfg);
+  saveConfig(cfg);
+}
+function disable() {
+  const cfg = loadConfig();
+  cfg.enabled = false;
+  saveConfig(cfg);
+}
+function status() {
+  const cfg = loadConfig();
+  return {
+    enabled: cfg.enabled === true,
+    anonId: cfg.anonId || null,
+    accountKey: cfg.accountKey || null,
+    dashboardUrl: cfg.accountKey ? dashboardUrl() : null,
+    lastSentAt: cfg.lastSentAt || null,
+    endpoint: endpoint(),
+  };
+}
+
+// POST JSON best-effort com timeout. Lança em falha (login precisa saber).
+async function postJson(url, body) {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), 8000);
+  try {
+    const r = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body || {}),
+      signal: ac.signal,
+    });
+    if (!r.ok) throw new Error("HTTP " + r.status);
+    return await r.json();
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Abre o navegador na URL de autorização (best-effort). Se falhar, o usuário
+// abre manualmente — o código/URL já foram impressos.
+function tryOpenBrowser(url) {
+  try {
+    let cmd, args;
+    if (process.platform === "darwin") {
+      cmd = "open";
+      args = [url];
+    } else if (process.platform === "win32") {
+      cmd = "cmd";
+      args = ["/c", "start", "", url];
+    } else {
+      cmd = "xdg-open";
+      args = [url];
+    }
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    /* sem navegador disponível; segue no manual */
+  }
+}
+
+// Device flow (estilo OAuth device code): pede um par device/user code, manda o
+// usuário autorizar no navegador (logado no Clerk) e faz polling até liberar a
+// key. Retorna { key }.
+async function deviceFlow() {
+  const start = await postJson(deviceCodeUrl(), {});
+  if (!start || !start.device_code || !start.user_code) {
+    throw new Error("resposta inválida do device-code");
+  }
+  const openUrl = start.verification_uri_complete || start.verification_uri;
+  console.log(
+    "\nPra autorizar este CLI, abra no navegador (logado na novyr):\n" +
+      "  " + (start.verification_uri || openUrl) + "\n" +
+      "  código: " + start.user_code + "\n"
+  );
+  tryOpenBrowser(openUrl);
+
+  const intervalMs = Math.max(2, Number(start.interval) || 5) * 1000;
+  const deadline = Date.now() + (Number(start.expires_in) || 600) * 1000;
+  process.stdout.write("Aguardando autorização");
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    process.stdout.write(".");
+    let poll;
+    try {
+      poll = await postJson(tokenUrl(), { device_code: start.device_code });
+    } catch (e) {
+      // 410 = expirado/inexistente; demais erros são transitórios (segue).
+      if (String(e.message || e).includes("410")) break;
+      continue;
+    }
+    if (poll && poll.status === "authorized" && poll.key) {
+      process.stdout.write("\n");
+      return { key: poll.key };
+    }
+  }
+  process.stdout.write("\n");
+  throw new Error("autorização expirou — rode `novyr login` de novo");
+}
+
+// `novyr login [key]`: linka o CLI a uma conta cloud. Sem key, faz o device flow
+// (abre o navegador pra autorizar). Com key, linka direto (fallback manual / CI).
+// Linkar implica ligar a telemetria (é o que alimenta o dashboard).
+// Retorna { key, dashboardUrl }.
+async function login(providedKey) {
+  const cfg = loadConfig();
+  let key = providedKey;
+  if (!key) {
+    const res = await deviceFlow();
+    key = res.key;
+  }
+  cfg.accountKey = key;
+  cfg.enabled = true;
+  ensureAnonId(cfg);
+  saveConfig(cfg);
+  return { key, dashboardUrl: dashboardUrl() };
+}
+
+// Desliga o vínculo com a conta (para de mandar dado pro dashboard). Não mexe
+// no opt-in geral de telemetria.
+function logout() {
+  const cfg = loadConfig();
+  delete cfg.accountKey;
+  saveConfig(cfg);
+}
+
+function isDue(cfg) {
+  if (!cfg.lastSentAt) return true;
+  return Date.now() - Number(cfg.lastSentAt) >= SEND_INTERVAL_MS;
+}
+
+// Monta o payload AGREGADO. Lista de campos é um allowlist explícito: nada além
+// de contadores numéricos sai daqui.
+function buildPayload(json, anonId) {
+  const s = (json && json.summary) || {};
+  const num = (x) => (Number.isFinite(Number(x)) ? Number(x) : 0);
+  return {
+    v: 1,
+    anonId,
+    ts: Date.now(),
+    platform: `${process.platform}-${process.arch}`,
+    summary: {
+      total_commands: num(s.total_commands),
+      total_input: num(s.total_input),
+      total_output: num(s.total_output),
+      total_saved: num(s.total_saved),
+      avg_savings_pct: num(s.avg_savings_pct),
+      total_time_ms: num(s.total_time_ms),
+    },
+  };
+}
+
+// POST best-effort com timeout curto. Nunca lança (telemetria não pode quebrar
+// o fluxo do usuário).
+async function postPayload(payload) {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), 4000);
+  try {
+    await fetch(endpoint(), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: ac.signal,
+    });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+// Worker (`novyr telemetry send`): roda destacado, lê o engine, envia, marca.
+async function runSend() {
+  const cfg = loadConfig();
+  if (cfg.enabled !== true) return;
+  const anonId = ensureAnonId(cfg);
+
+  let json = null;
+  try {
+    const { engineJsonFirst } = require("./engine.js");
+    json = engineJsonFirst([
+      ["gain", "--format", "json"],
+      ["stats", "--format", "json"],
+    ]);
+  } catch {
+    json = null;
+  }
+  if (!json || !json.summary) return;
+
+  await postPayload(buildPayload(json, anonId));
+  cfg.lastSentAt = Date.now();
+  saveConfig(cfg);
+}
+
+// Chamado pela statusLine: se ligado e vencido, dispara o worker SEM travar.
+// `detached + unref` deixa o processo viver além do `novyr line` que já saiu.
+function maybeSendInBackground() {
+  try {
+    const cfg = loadConfig();
+    if (cfg.enabled !== true || !isDue(cfg)) return;
+    // marca otimisticamente pra não disparar N workers em rajada de statusLine
+    cfg.lastSentAt = Date.now();
+    saveConfig(cfg);
+    const child = spawn(process.execPath, [__dirname + "/../bin/cli.js", "telemetry", "send"], {
+      detached: true,
+      stdio: "ignore",
+    });
+    child.unref();
+  } catch {
+    /* nunca quebra a statusLine */
+  }
+}
+
+module.exports = {
+  isEnabled,
+  enable,
+  disable,
+  status,
+  login,
+  logout,
+  buildPayload,
+  runSend,
+  maybeSendInBackground,
+  configPath,
+  endpoint,
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "novyr",
+  "version": "0.1.0",
+  "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.",
+  "license": "MIT",
+  "homepage": "https://novyr.dev",
+  "bin": {
+    "novyr": "./bin/cli.js",
+    "nvr": "./bin/cli.js",
+    "rtk": "./bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/postinstall.js",
+    "README.md",
+    "NOTICE"
+  ],
+  "optionalDependencies": {
+    "@novyr/nvr-linux-x64": "0.1.0",
+    "@novyr/nvr-linux-arm64": "0.1.0",
+    "@novyr/nvr-darwin-x64": "0.1.0",
+    "@novyr/nvr-darwin-arm64": "0.1.0",
+    "@novyr/nvr-win32-x64": "0.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "tokens",
+    "token-savings",
+    "nvr",
+    "cli",
+    "statusline",
+    "claude"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+// Pós-instalação: ativa o engine no Claude Code automaticamente em instalações
+// GLOBAIS (`npm install -g novyr`), pra o usuário já sair com o CLI E o nvr
+// rodando no Claude Code, sem um passo manual.
+//
+// Princípios (importam pra não estragar a experiência):
+//  - Só auto-ativa em install GLOBAL — nunca mexe na config de quem usa novyr
+//    como dependência local de um projeto.
+//  - NUNCA falha o `npm install`: qualquer erro vira aviso e sai 0.
+//  - Idempotente: o setup preserva config existente e faz backup (.bak).
+//  - Respeita `--ignore-scripts`: se não rodar, `novyr setup` faz o mesmo na mão.
+
+function tip(msg) {
+  console.log(`\nnovyr: ${msg}`);
+}
+
+// Só auto-ativa em instalação global. (Instalação local como dependência não
+// deve tocar no ~/.claude do usuário.) Também cobre o `npm ci` do CI, que é local.
+if (process.env.npm_config_global !== "true") {
+  process.exit(0);
+}
+
+try {
+  // Chama o MESMO setup do wrapper (engine init + nossa statusLine), em
+  // processo — não o setup do engine direto, senão a statusLine não entra.
+  const { runSetup } = require("../lib/setup.js");
+  runSetup();
+} catch (_e) {
+  tip("ativação automática pulada — rode `novyr setup` para ativar.");
+}
+
+// Sempre sai 0: jamais queremos quebrar o `npm install`.
+process.exit(0);