jarvis-ai-framework 5.1.0 → 5.5.0

package/bin/lib/core/docs-migrate.js

@@ -0,0 +1,259 @@
+// Documentos de trabalho nos caminhos antigos → docs/jarvis/… (`jarvis init --upgrade`).
+// Mesmas regras do item 8 do Upgrade (C) do skill jarvis-init: conflito no destino pula,
+// pasta antiga removida só se ficar vazia, `git mv` quando versionado, `related_discovery`
+// reescrito pelo nome do arquivo e, na recusa, só chaves novas recebem o caminho antigo.
+import {
+  existsSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  renameSync,
+  rmdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+} from "node:fs";
+import { join, resolve, relative, dirname, basename, isAbsolute, sep } from "node:path";
+import { execFileSync } from "node:child_process";
+
+const ENG_SUBDIRS = ["ARD", "RFC", "qa", "swagger", "openapi", "robots", "c4"];
+const LEGACY_ENG_SUBDIRS = ["robots", "swagger", "openapi", "c4"];
+
+/**
+ * Resolve `$NOME` com as outras chaves do ENV, **em qualquer ordem**: upgrades antigos
+ * acrescentaram `JARVIS_DOCS` no fim do arquivo, depois do `PROD_DOCS` que a usa.
+ * Desconhecida (ex.: `$IDE`) ou ciclo fica literal.
+ * @param {Map<string, string>} entries
+ * @returns {Map<string, string>}
+ */
+export function expandEnv(entries) {
+  const out = new Map();
+  const resolving = new Set();
+  const resolveKey = (key) => {
+    if (out.has(key)) return out.get(key);
+    if (!entries.has(key) || resolving.has(key)) return null;
+    resolving.add(key);
+    const value = entries
+      .get(key)
+      .replace(/\$([A-Z][A-Z0-9_]*)/g, (m, name) => resolveKey(name) ?? m);
+    resolving.delete(key);
+    out.set(key, value);
+    return value;
+  };
+  for (const key of entries.keys()) resolveKey(key);
+  return out;
+}
+
+const clean = (p) => p.replace(/^\.\//, "").replace(/\/+$/, "");
+
+/** Pastas de documentos resolvidas, com os padrões do template quando faltam. */
+export function docsFolders(env) {
+  const docs = clean(env.get("DOCS_FOLDER") || "docs");
+  const jarvis = clean(env.get("JARVIS_DOCS") || `${docs}/jarvis`);
+  const prod = clean(env.get("PROD_DOCS") || `${jarvis}/product`);
+  const eng = clean(env.get("ENG_DOCS") || `${jarvis}/engineering`);
+  const discoveries = clean(env.get("DISCOVERIES_DOCS") || `${jarvis}/discoveries`);
+  return { docs, jarvis, prod, eng, discoveries };
+}
+
+function inside(workspaceDir, rel) {
+  if (isAbsolute(rel)) return false;
+  const r = relative(workspaceDir, resolve(workspaceDir, rel));
+  return r !== "" && !r.startsWith("..") && !isAbsolute(r);
+}
+
+function listFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...listFiles(p));
+    else if (entry.isFile()) files.push(p);
+  }
+  return files;
+}
+
+/** Pares pasta antiga → pasta nova, na ordem do item 8 + discoveries. */
+function sourcePairs(f) {
+  const pairs = [
+    { from: `${f.docs}/product`, to: f.prod, discoveriesSub: true },
+    ...ENG_SUBDIRS.map((s) => ({ from: `${f.docs}/engineering/${s}`, to: `${f.eng}/${s}` })),
+    ...LEGACY_ENG_SUBDIRS.map((s) => ({ from: `docs/engineering/${s}`, to: `${f.eng}/${s}` })),
+    { from: `${f.prod}/discoveries`, to: f.discoveries, discovery: true },
+  ];
+  const seen = new Set();
+  return pairs.filter((p) => {
+    if (p.from === p.to || seen.has(p.from)) return false;
+    seen.add(p.from);
+    return true;
+  });
+}
+
+/**
+ * Planeja a mudança de pasta (sem mexer em nada).
+ * @param {string} workspaceDir — pasta que contém `.{ide}/`
+ * @param {Map<string, string>} env — ENV já expandido (`expandEnv`)
+ * @returns {{ moves: {from: string, to: string, discovery: boolean}[],
+ *   skipped: {from: string, to: string, reason: string}[], sources: string[] }}
+ *   Caminhos relativos ao workspace.
+ */
+export function planDocsMigration(workspaceDir, env) {
+  const f = docsFolders(env);
+  const moves = [];
+  const skipped = [];
+  const sources = [];
+
+  for (const pair of sourcePairs(f)) {
+    if (!inside(workspaceDir, pair.from) || !inside(workspaceDir, pair.to)) {
+      skipped.push({ from: pair.from, to: pair.to, reason: "fora do workspace" });
+      continue;
+    }
+    const fromAbs = join(workspaceDir, pair.from);
+    if (!existsSync(fromAbs) || !statSync(fromAbs).isDirectory()) continue;
+
+    let added = false;
+    for (const fileAbs of listFiles(fromAbs)) {
+      const rel = relative(fromAbs, fileAbs).split(sep).join("/");
+      // docs/product/discoveries/* (layout antigo) vai direto para a pasta dos discoveries
+      const toDiscoveries =
+        pair.discovery || (pair.discoveriesSub && rel.startsWith("discoveries/"));
+      const to = toDiscoveries
+        ? `${f.discoveries}/${pair.discovery ? rel : rel.slice("discoveries/".length)}`
+        : `${pair.to}/${rel}`;
+      const from = `${pair.from}/${rel}`;
+      if (from === to) continue;
+      if (existsSync(join(workspaceDir, to)) || moves.some((m) => m.to === to)) {
+        skipped.push({ from, to, reason: "conflito" });
+        continue;
+      }
+      moves.push({ from, to, discovery: toDiscoveries });
+      added = true;
+    }
+    if (added) sources.push(pair.from);
+  }
+  return { moves, skipped, sources };
+}
+
+function isTracked(fileAbs) {
+  try {
+    execFileSync("git", ["ls-files", "--error-unmatch", basename(fileAbs)], {
+      cwd: dirname(fileAbs),
+      stdio: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeEmptyDirs(dirAbs, stopAbs) {
+  let dir = dirAbs;
+  while (dir.startsWith(stopAbs) && dir !== stopAbs && existsSync(dir)) {
+    if (readdirSync(dir).length > 0) break;
+    rmdirSync(dir);
+    dir = dirname(dir);
+  }
+}
+
+function emptyDirsUnder(dirAbs) {
+  if (!existsSync(dirAbs)) return;
+  for (const entry of readdirSync(dirAbs, { withFileTypes: true })) {
+    if (entry.isDirectory()) emptyDirsUnder(join(dirAbs, entry.name));
+  }
+  if (readdirSync(dirAbs).length === 0) rmdirSync(dirAbs);
+}
+
+/**
+ * Aplica o plano: `git mv` se o arquivo é versionado, senão `rename`. Remove as pastas
+ * antigas só se ficarem vazias e garante `{JARVIS_DOCS}/` no `.gitignore` do workspace.
+ * @returns {{ moved: {from: string, to: string, discovery: boolean}[], errors: string[] }}
+ */
+export function applyDocsMigration(workspaceDir, plan, env) {
+  const moved = [];
+  const errors = [];
+  for (const m of plan.moves) {
+    const fromAbs = join(workspaceDir, m.from);
+    const toAbs = join(workspaceDir, m.to);
+    try {
+      mkdirSync(dirname(toAbs), { recursive: true });
+      if (isTracked(fromAbs)) {
+        execFileSync("git", ["mv", fromAbs, toAbs], { cwd: dirname(fromAbs), stdio: "ignore" });
+      } else {
+        renameSync(fromAbs, toAbs);
+      }
+      moved.push(m);
+    } catch (err) {
+      errors.push(`${m.from}: ${err.message.split("\n")[0]}`);
+    }
+  }
+
+  // Pastas antigas vazias saem; a pasta raiz dos documentos ($DOCS_FOLDER) sempre fica.
+  const docsAbs = join(workspaceDir, docsFolders(env).docs);
+  for (const src of plan.sources) {
+    const srcAbs = join(workspaceDir, src);
+    emptyDirsUnder(srcAbs);
+    removeEmptyDirs(dirname(srcAbs), docsAbs);
+  }
+
+  if (moved.length > 0) ensureGitignore(workspaceDir, `${docsFolders(env).jarvis}/`);
+  return { moved, errors };
+}
+
+function ensureGitignore(workspaceDir, line) {
+  const p = join(workspaceDir, ".gitignore");
+  const text = existsSync(p) ? readFileSync(p, "utf-8") : "";
+  const bare = line.replace(/\/$/, "");
+  if (text.split("\n").some((l) => [line, bare, `/${line}`, `/${bare}`].includes(l.trim()))) return;
+  appendFileSync(p, `${text && !text.endsWith("\n") ? "\n" : ""}${line}\n`);
+}
+
+/**
+ * Nos `.md` de `PROD_DOCS`, todo `related_discovery:` cujo nome de arquivo seja o de um
+ * discovery movido passa ao caminho novo — inclusive valores que já estavam quebrados.
+ * @returns {string[]} arquivos alterados (relativos ao workspace)
+ */
+export function rewriteRelatedDiscovery(workspaceDir, env, moved) {
+  const byName = new Map(moved.filter((m) => m.discovery).map((m) => [basename(m.to), m.to]));
+  if (byName.size === 0) return [];
+  const prodAbs = join(workspaceDir, docsFolders(env).prod);
+  if (!existsSync(prodAbs)) return [];
+
+  const changed = [];
+  for (const fileAbs of listFiles(prodAbs).filter((p) => p.endsWith(".md"))) {
+    const text = readFileSync(fileAbs, "utf-8");
+    const next = text.replace(
+      /^(related_discovery:[ \t]*)(\S+)[ \t]*$/gm,
+      (line, prefix, value) => {
+        const to = byName.get(basename(value));
+        return to && value !== to ? `${prefix}${to}` : line;
+      }
+    );
+    if (next !== text) {
+      writeFileSync(fileAbs, next);
+      changed.push(relative(workspaceDir, fileAbs).split(sep).join("/"));
+    }
+  }
+  return changed;
+}
+
+/**
+ * Recusa em mover: o valor que as chaves **novas** recebem para continuar no caminho antigo.
+ * Chave que já existe no ENV não muda (o upgrade só acrescenta).
+ * @param {{moves: {from: string, discovery: boolean}[]}} plan
+ * @param {string[]} addedKeys — chaves que o upgrade vai acrescentar
+ * @returns {Record<string, string>}
+ */
+export function declineEnvValues(plan, addedKeys, env) {
+  const added = new Set(addedKeys);
+  const f = docsFolders(env);
+  const out = {};
+  if (added.has("DISCOVERIES_DOCS") && plan.moves.some((m) => m.discovery)) {
+    out.DISCOVERIES_DOCS = "$PROD_DOCS/discoveries";
+  }
+  if (added.has("PROD_DOCS") && plan.moves.some((m) => m.from.startsWith(`${f.docs}/product/`))) {
+    out.PROD_DOCS = "$DOCS_FOLDER/product";
+  }
+  if (added.has("ENG_DOCS") && plan.moves.some((m) => m.from.includes("/engineering/"))) {
+    out.ENG_DOCS = "$DOCS_FOLDER/engineering";
+  }
+  return out;
+}

package/bin/lib/core/env-upgrade.js

@@ -0,0 +1,84 @@
+// Upgrade do ENV.md (`jarvis init --upgrade`): acrescenta as chaves do template que faltam.
+// Regra: só acrescenta. Nenhuma chave existente muda, preenchida, vazia ou com lista de opções.
+// Mesmas regras do Upgrade (C) do skill jarvis-init (itens 4, 5, 9, 10 e 11).
+import { readFileSync, writeFileSync } from "node:fs";
+
+const KEY_LINE = /^([A-Z][A-Z0-9_]*)=(.*)$/;
+
+// PROD_MODE nova: o valor vem da AREA (só no upgrade; a criação do ENV continua perguntando).
+const PROD_MODE_BY_AREA = { ENGINEERING: "developer-guided", PRODUCT: "product-led" };
+
+/**
+ * Lê as chaves do ENV na ordem do arquivo, **incluindo as vazias** (o `loadEnv`
+ * descarta as vazias, o que esconderia uma chave existente do diff).
+ * Linhas comentadas não contam.
+ * @returns {Map<string, string>}
+ */
+export function parseEnvEntries(text) {
+  const entries = new Map();
+  for (const line of text.split("\n")) {
+    const m = line.trim().match(KEY_LINE);
+    if (m && !entries.has(m[1])) entries.set(m[1], m[2].trim());
+  }
+  return entries;
+}
+
+function isOptionList(value) {
+  return /^\[.*\]$/.test(value);
+}
+
+// Bloco "Data Engineering": DATA_* só entram com HUB=DATA. DATA_SPECIALIZATIONS é
+// obrigatória em qualquer HUB (eng.specializations-rules.md) e nunca é excluída.
+function isDataOnlyKey(key) {
+  return key.startsWith("DATA_") && key !== "DATA_SPECIALIZATIONS";
+}
+
+/**
+ * Calcula o que o upgrade acrescenta, sem gravar nada.
+ * @returns {{ added: {key: string, value: string}[], pending: string[], warnings: string[] }}
+ *   `pending` e `warnings` trazem só nomes de chave, nunca valores do ENV.
+ */
+export function planEnvUpgrade(envText, templateText) {
+  const env = parseEnvEntries(envText);
+  const template = parseEnvEntries(templateText);
+  const hub = (env.get("HUB") || "").toUpperCase();
+  const area = (env.get("AREA") || "").toUpperCase();
+
+  const added = [];
+  const pending = [];
+  const warnings = [];
+
+  for (const [key, templateValue] of template) {
+    if (env.has(key)) continue;
+    if (hub !== "DATA" && isDataOnlyKey(key)) continue;
+
+    let value = isOptionList(templateValue) ? "" : templateValue;
+    if (key === "PROD_MODE") {
+      value = PROD_MODE_BY_AREA[area] || "";
+      if (!value) pending.push("PROD_MODE");
+    }
+    added.push({ key, value });
+  }
+
+  if (env.has("PROD_MODE") && !env.get("PROD_MODE")) pending.push("PROD_MODE");
+
+  if (env.get("CENTRAL_DOCS_REPO") && !env.has("CENTRAL_DOCS_STORAGE")) {
+    warnings.push("CENTRAL_DOCS_REPO");
+  }
+
+  return { added, pending, warnings };
+}
+
+/**
+ * Grava as chaves novas no fim do ENV, num bloco datado. Nenhuma linha existente muda.
+ * `overrides` troca o valor de chaves novas (ex.: recusa em mover os discoveries).
+ * @returns {boolean} true se gravou
+ */
+export function applyEnvUpgrade(envPath, plan, today, overrides = {}) {
+  if (plan.added.length === 0) return false;
+  const text = readFileSync(envPath, "utf-8");
+  const lines = plan.added.map(({ key, value }) => `${key}=${overrides[key] ?? value}`);
+  const sep = text.endsWith("\n") ? "" : "\n";
+  writeFileSync(envPath, `${text}${sep}\n# --- Upgrade ${today} ---\n${lines.join("\n")}\n`);
+  return true;
+}

package/bin/lib/core/profile-filter.js

@@ -7,7 +7,9 @@
  * `rules/AGENTS.md`: ao mudar uma, mude as três.
  *
  * Regras:
- * - Os quatro eixos (HUB, POSITION, AREA, SQUAD) são combinados com AND.
+ * - Os eixos (HUB, POSITION, AREA, SQUAD e o opcional ARTIFACT_STYLE) são combinados com AND.
+ * - ARTIFACT_STYLE (5º campo, opcional): ausente no bloco = `all`; perfil sem valor =
+ *   `ai-generated`. Sem coringa: FULLCYCLE e GENERALIST não o satisfazem (é escolha da pessoa).
  * - `all` casa qualquer valor; listas são separadas por vírgula.
  * - FULLCYCLE (HUB) satisfaz qualquer HUB.
  * - GENERALIST (POSITION) satisfaz qualquer POSITION e qualquer AREA.
@@ -20,8 +22,11 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 
+// SQUAD para no próximo `|`: o 5º campo (ARTIFACT_STYLE) é opcional.
 const APPLIES_TO_RE =
-  /> \*\*Applies to:\*\* HUB: ([^|]+)\| POSITION: ([^|]+)\| AREA: ([^|]+)\| SQUAD: (.+)/;
+  /> \*\*Applies to:\*\* HUB: ([^|]+)\| POSITION: ([^|]+)\| AREA: ([^|]+)\| SQUAD: ([^|\n]+)(?:\| ARTIFACT_STYLE: ([^|\n]+))?/;
+
+const DEFAULT_ARTIFACT_STYLE = "ai-generated";
 
 /**
  * @typedef {Object} AppliesTo
@@ -29,6 +34,7 @@ const APPLIES_TO_RE =
  * @property {string} POSITION
  * @property {string} AREA
  * @property {string} SQUAD
+ * @property {string} ARTIFACT_STYLE - `all` quando o bloco não traz o campo
  */
 
 /**
@@ -37,6 +43,7 @@ const APPLIES_TO_RE =
  * @property {string} POSITION
  * @property {string} AREA
  * @property {string} SQUAD
+ * @property {string} [ARTIFACT_STYLE] - vazio = `ai-generated`
  */
 
 /**
@@ -52,6 +59,7 @@ export function parseAppliesTo(content) {
     POSITION: match[2].trim(),
     AREA: match[3].trim(),
     SQUAD: match[4].trim(),
+    ARTIFACT_STYLE: (match[5] || "all").trim(),
   };
 }
 
@@ -76,7 +84,11 @@ export function matchesProfile(appliesTo, profile) {
   const position = generalist || axisMatches(appliesTo.POSITION, profile.POSITION);
   const area = generalist || axisMatches(appliesTo.AREA, profile.AREA);
   const squad = axisMatches(appliesTo.SQUAD, profile.SQUAD);
-  return hub && position && area && squad;
+  const style = axisMatches(
+    appliesTo.ARTIFACT_STYLE || "all",
+    profile.ARTIFACT_STYLE || DEFAULT_ARTIFACT_STYLE
+  );
+  return hub && position && area && squad && style;
 }
 
 function walkMarkdown(dir) {

package/bin/lib/core/sync-engine.js

@@ -149,7 +149,7 @@ export function syncAssets(targetDir, ide, opts = {}) {
 
   // RTK: detectar e reconciliar RTK_ENABLED + rtk-rules.md
   if (!opts.dryRun) {
-    const rtkResult = reconcileRtk(ideDir, targetDir, ide);
+    const rtkResult = reconcileRtk(ideDir, targetDir, ide, { keepEnvValues: opts.keepEnvValues });
     if (rtkResult) result.copied.push(rtkResult);
   }
 
@@ -191,9 +191,11 @@ export function syncAssets(targetDir, ide, opts = {}) {
  * Detecta RTK no PATH e reconcilia RTK_ENABLED no ENV.md + rtk-rules.md na IDE.
  * - RTK encontrado → RTK_ENABLED=true no ENV.md, mantém rule
  * - RTK não encontrado → remove rtk-rules.md da IDE, mantém RTK_ENABLED=false
+ * - `keepEnvValues` (jarvis init --upgrade): não troca RTK_ENABLED=false por true, porque o
+ *   upgrade só acrescenta chaves novas; acrescentar RTK_ENABLED quando ela não existe continua valendo
  * @returns {string|null} mensagem de log ou null se nenhuma ação
  */
-function reconcileRtk(ideDir, targetDir, ide) {
+function reconcileRtk(ideDir, targetDir, ide, { keepEnvValues = false } = {}) {
   const rtkRulePath = join(ideDir, "rules", "rtk-rules.md");
   const envPath = join(ideDir, "ENV.md");
   const hasRtk = (() => {
@@ -209,7 +211,7 @@ function reconcileRtk(ideDir, targetDir, ide) {
     // Ativar RTK_ENABLED no ENV.md se existir e estiver false
     if (existsSync(envPath)) {
       let env = readFileSync(envPath, "utf-8");
-      if (env.includes("RTK_ENABLED=false")) {
+      if (env.includes("RTK_ENABLED=false") && !keepEnvValues) {
         env = env.replace("RTK_ENABLED=false", "RTK_ENABLED=true");
         writeFileSync(envPath, env, "utf-8");
         return "(rtk) detectado — RTK_ENABLED=true no ENV.md";

package/bin/lib/core/token-report.js

@@ -91,6 +91,7 @@ export function buildReport(root, profile, opts = {}) {
       POSITION: profile.POSITION,
       AREA: profile.AREA,
       SQUAD: profile.SQUAD,
+      ARTIFACT_STYLE: profile.ARTIFACT_STYLE || "ai-generated",
     },
     rtkEnabled,
     estimate: `tokens = bytes ÷ ${BYTES_PER_TOKEN} (estimativa)`,

package/bin/lib/docs/storage/build-index.js

@@ -53,7 +53,8 @@ export function renderIndex(root, squad) {
     const areaDir = join(root, squad, area);
     const files = walkFiles(areaDir).filter((f) => {
       const name = f.split(sep).pop();
-      return name.startsWith(prefix) && name.endsWith(".md");
+      // {nome}.public.md (versão humanizada, ARTIFACT_STYLE=human-generated) não entra no índice
+      return name.startsWith(prefix) && name.endsWith(".md") && !name.endsWith(".public.md");
     });
     out.push(`## ${area}`, "", `> ${title}`, "");
     if (files.length === 0) {

package/bin/lib/vcs/api.js

@@ -108,6 +108,14 @@ export async function createMergeRequest(repoUrl, opts) {
   };
 }
 
+// Tipos de issue do Bitbucket (campo `kind`; ele não tem labels livres).
+const BITBUCKET_KINDS = ["bug", "enhancement", "proposal", "task"];
+
+/**
+ * @param {string} repoUrl
+ * @param {{ title: string, body: string, labels?: string[] }} opts - `labels` padrão: ["bug"].
+ *   No Bitbucket, a primeira label vira o `kind` quando é um tipo válido; senão, `bug`.
+ */
 export async function createIssue(repoUrl, opts) {
   const { title, body, labels = ["bug"] } = opts;
   const repo = parseRepoUrl(repoUrl);
@@ -149,7 +157,11 @@ export async function createIssue(repoUrl, opts) {
     {
       method: "POST",
       headers,
-      body: { title, content: { raw: body } },
+      body: {
+        title,
+        content: { raw: body },
+        kind: BITBUCKET_KINDS.includes(labels[0]) ? labels[0] : "bug",
+      },
     }
   );
   if (!ok || !json?.links?.html?.href) {

package/bin/lib/vcs/create-issue.js

@@ -9,11 +9,25 @@ import { createIssue, parseRepoUrl } from "./api.js";
  * @param {string} options.repo - URL ou `org/repo` do repositório
  * @param {string} options.title - Título da issue
  * @param {string} options.bodyFile - Path de um arquivo com o corpo em markdown
+ * @param {string} [options.labels] - Labels separadas por vírgula (padrão: bug)
  */
-export async function runCreateIssue({ repo, title, bodyFile }) {
+/**
+ * "enhancement, documentation" → ["enhancement", "documentation"]; vazio → undefined (padrão: bug).
+ * @param {string} [raw]
+ * @returns {string[] | undefined}
+ */
+export function parseLabels(raw) {
+  const list = String(raw || "")
+    .split(",")
+    .map((l) => l.trim())
+    .filter(Boolean);
+  return list.length ? list : undefined;
+}
+
+export async function runCreateIssue({ repo, title, bodyFile, labels }) {
   if (!title || !bodyFile || !repo) {
     console.error(
-      "Uso: jarvis vcs create-issue --repo <url-ou-path> --title <titulo> --body-file <path>"
+      "Uso: jarvis vcs create-issue --repo <url-ou-path> --title <titulo> --body-file <path> [--label <labels>]"
     );
     process.exit(1);
   }
@@ -33,7 +47,7 @@ export async function runCreateIssue({ repo, title, bodyFile }) {
   const body = existsSync(bodyFile) ? readFileSync(bodyFile, "utf-8") : "";
 
   try {
-    const result = await createIssue(repoUrl, { title, body });
+    const result = await createIssue(repoUrl, { title, body, labels: parseLabels(labels) });
     parseRepoUrl(repoUrl);
     console.log(`✅ Issue aberto: ${result.url}`);
     console.log(JSON.stringify(result));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jarvis-ai-framework",
-  "version": "5.1.0",
+  "version": "5.5.0",
   "description": "Jarvis framework",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "prepublishOnly": "echo 'Publishing jarvis-framework...'",
     "publish:gitlab": "npm publish",
     "test:comandos": "node test/comandos-docs.test.js",
-    "test:filtro": "node --test test/profile-filter.test.js test/token-report.test.js test/flow-map.test.js test/env-loader.test.js test/sync-engine.test.js test/vcs-api.test.js test/fetch-file.test.js test/publish-file.test.js test/docs-storage.test.js",
+    "test:filtro": "node --test test/profile-filter.test.js test/token-report.test.js test/flow-map.test.js test/env-loader.test.js test/sync-engine.test.js test/vcs-api.test.js test/fetch-file.test.js test/publish-file.test.js test/docs-storage.test.js test/env-upgrade.test.js test/docs-migrate.test.js test/init-upgrade.test.js",
     "lint": "eslint bin/ test/",
     "lint:fix": "eslint bin/ test/ --fix",
     "format": "prettier --write bin/ test/",

package/rules/AGENTS.md

@@ -32,8 +32,9 @@ rules-on-demand/              # Lidas pelo workflow que as usa (não carregadas
 │   ├── eng.pr-rules.md       # Regras para /eng.pr
 │   ├── eng.tech-spec-rules.md # Regras para tech specs
 │   └── eng.breakdown-subtasks-rules.md # Regras para o breakdown de subtarefas
-└── product/
-    └── prod.guided-rules.md  # Modo Developer-Guided (lida só com PROD_MODE=developer-guided)
+├── product/
+│   └── prod.guided-rules.md  # Modo Developer-Guided (lida só com PROD_MODE=developer-guided)
+└── warm-up-consume-rules.md  # Consumo do /warm-up (lida pelo eng.start e pelos prod.spec* só quando há aquecimento)
 ```
 
 ### `rules/` x `rules-on-demand/`
@@ -74,6 +75,8 @@ Cada arquivo de rule declara para quais perfis se aplica via bloco `applies_to`,
 > **Applies to:** HUB: {valor ou all} | POSITION: {valor ou all} | AREA: {valor ou all} | SQUAD: {valor ou all}
 ```
 
+Campo opcional no fim: `| ARTIFACT_STYLE: {ai-generated, human-generated ou all}` (ausente = `all`).
+
 **Eixos de filtragem:**
 
 | Eixo | Exemplos de valor | `all` significa |
@@ -82,13 +85,14 @@ Cada arquivo de rule declara para quais perfis se aplica via bloco `applies_to`,
 | POSITION | TECH LEAD, PM, QA-ENGINEER, SENIOR, GENERALIST | qualquer cargo |
 | AREA | ENGINEERING, PRODUCT | qualquer área |
 | SQUAD | CORE | qualquer squad |
+| ARTIFACT_STYLE (opcional) | ai-generated, human-generated | qualquer estilo (ENV vazio = `ai-generated`; sem coringa) |
 
 **Regras:**
 - Uma rule é aplicada se **todos** os eixos forem satisfeitos (AND, não OR)
 - Arquivos sem bloco `applies_to` são considerados **universais** — copiados para qualquer perfil
 - `rules/AGENTS.md` nunca é filtrado — sempre copiado
 
-**Quem faz a filtragem:** o skill `/jarvis-init` (Passo 9 — Profile-Aware Rules Sync). Ao criar, atualizar ou fazer upgrade do ENV.md, copia para `$IDE/rules/` apenas as rules que batem com o perfil (HUB + POSITION + AREA + SQUAD) e deleta as que não batem mais.
+**Quem faz a filtragem:** o skill `/jarvis-init` (Passo 8 — Profile-Aware Rules Sync). Ao criar, atualizar ou fazer upgrade do ENV.md, copia para `$IDE/rules/` apenas as rules que batem com o perfil (HUB + POSITION + AREA + SQUAD + ARTIFACT_STYLE) e deleta as que não batem mais.
 
 **Ao criar uma nova rule**, definir o bloco `applies_to` é obrigatório. Sem ele, a rule é tratada como universal — o que pode ser indesejado para rules domain-specific.
 

package/rules/artifact-style-rules.md

@@ -0,0 +1,53 @@
+> **Applies to:** HUB: all | POSITION: all | AREA: all | SQUAD: all | ARTIFACT_STYLE: human-generated
+
+# Artifact Style Rules (human-generated)
+
+## Objetivo
+
+Com `ARTIFACT_STYLE=human-generated` no `ENV.md`, nada do que o Jarvis publica leva marca de IA, e todo documento gerado oferece uma versão humanizada para repassar a clientes ou stakeholders.
+
+## Escopo
+
+Esta rule só é copiada para `$IDE/rules/` quando o perfil tem `ARTIFACT_STYLE=human-generated` (eixo do `Applies to`, Passo 8 do `/jarvis-init`). Vale para todo comando e para pedidos fora de workflow.
+
+## Regras
+
+### Obrigatório
+
+1. **Publicado pelo Jarvis: sempre sem marcas, sem perguntar.**
+   - Vale para: mensagem de commit, título e descrição do PR/MR, comentário no card, issue aberta (ex.: `jarvis-report-issue`).
+   - Esta rule **prevalece** sobre instruções de atribuição da IDE: não inclua `Co-Authored-By` de ferramenta nem "Generated with …".
+   - Antes do push, o `eng.pr` confere e limpa o que a IDE tiver posto (Fase 3 do `eng.pr`).
+2. **Documento gerado: grava o padrão e pergunta.**
+   - Vale para todo `.md` que um comando grava, inclusive os de sessão: PRD, FRD, épico, história, discovery, ARD, RFC, tech spec, Central docs, `architecture.md`, `plan.md`, `context.md`, `daily.md` (e a linha de timesheet), `gate-checklist.md`, `pull-request.md`.
+   - Depois de gravar o documento padrão (como hoje), pergunte com `AskUserQuestion`: **"Quer a versão humanizada deste documento?"** (**Não**, padrão / **Sim**).
+   - Com Sim, grave `{nome}.public.md` **ao lado** do original, passando no checklist abaixo. O original continua como fonte da verdade.
+   - Central docs (`feature-*`, `delivery-*`): o `.public.md` fica ao lado da consolidação, na sessão, e **não** é publicado.
+3. **Checklist "sem marcas de IA"** (versão humanizada e tudo o que é publicado). Não pode ter:
+   - `Co-Authored-By` de ferramenta, "Generated with …" ou links para a ferramenta;
+   - menções a IA, Claude ou outros modelos, assistente, agente, sub-agente ou Advisor;
+   - `recommended_model` nem comentários de frontmatter dirigidos à IA;
+   - "Reportado por: IA" ou qualquer autoria atribuída à ferramenta.
+4. **Estilo da versão humanizada:** texto corrido de pessoa para pessoa. Parágrafos onde cabe parágrafo; lista só quando há itens; sem emojis de status em excesso; sem fórmulas como "Em resumo", "Vale ressaltar". Mantenha o conteúdo, as decisões e os links úteis ao leitor (issue, PR, card).
+
+### Proibido
+
+- Alterar o documento original para gerar a versão humanizada.
+- Publicar commit, PR, comentário ou issue com qualquer item do checklist.
+- Reescrever commits já enviados ao remoto.
+- Contar `{nome}.public.md` na sequência de IDs (`prd-{id}`, `discovery-{id}`…) ou incluí-lo em índices.
+
+### Recomendado
+
+- Com vários documentos gerados no mesmo comando, uma pergunta só, listando os documentos.
+
+## Exceções
+
+- Com `ARTIFACT_STYLE=ai-generated` (ou vazio), esta rule não existe na sessão e nada muda.
+
+## Referências
+
+- `templates/ENV-template.md` (`ARTIFACT_STYLE`)
+- `skills/jarvis-init/SKILL.md` (Pergunta 9 e Passo 8)
+- `workflows/engineering/eng.pr.md` (conferência antes do push)
+- `rules/AGENTS.md` (eixo `ARTIFACT_STYLE` do `Applies to`)

package/rules/product/prod-rules.md

@@ -40,12 +40,14 @@ PROD_RULES=$RULES_FOLDER/$PROD_FOLDER_NAME
 PROD_FLOWS=.$IDE/$FLOWS_FOLDER
 PROD_TEMPLATES=.$IDE/$TEMPLATES_FOLDER/$PROD_FOLDER_NAME
 PROD_DOCS=$DOCS_FOLDER/jarvis/$PROD_FOLDER_NAME
+DISCOVERIES_DOCS=$DOCS_FOLDER/jarvis/discoveries
 ```
 
 Abaixo, segue uma descrição de algumas das variáveis mais importantes para as rotinas de produto:
 
 - $DOCS_FOLDER é o nome da pasta principal de documentações do projeto. Ela fica localizada na raiz do projeto.
-- $PROD_DOCS é a pasta dos documentos de produto gerados pelos comandos (PRD, FRD, épicos, histórias, discovery): `$JARVIS_DOCS/product` (`docs/jarvis/product`), nos dois modos de trabalho e fora do versionamento do código. Os de engenharia ficam em `$ENG_DOCS` (`docs/jarvis/engineering`).
+- $PROD_DOCS é a pasta dos documentos de produto gerados pelos comandos (PRD, FRD, épicos, histórias): `$JARVIS_DOCS/product` (`docs/jarvis/product`), nos dois modos de trabalho e fora do versionamento do código. Os de engenharia ficam em `$ENG_DOCS` (`docs/jarvis/engineering`).
+- $DISCOVERIES_DOCS é a pasta dos discoveries: `$JARVIS_DOCS/discoveries` (`docs/jarvis/discoveries`), fora de `product/`. ENV sem a variável: use `$PROD_DOCS/discoveries` se essa pasta existir, senão `$JARVIS_DOCS/discoveries`, e avise para rodar `jarvis init --upgrade`.
 - $PROD_FOLDER_NAME é o nome padrão da pasta de produto que será usada em diversos contextos do projeto.
 - $TEMPLATES_FOLDER é o nome da pasta principal de templates do projeto.
 - $PROD_TEMPLATES é o caminho completo para os templates de produto.
@@ -126,7 +128,7 @@ Dentro das pastas do projeto, os caminhos de pastas e o nome dos arquivos finais
 - Documento de Requisitos Funcionais: `$PROD_DOCS/prd-{id}-{nome-do-pai}/frd-{id}-{nome}.md`
 - Épico: `$PROD_DOCS/prd-{id}-{nome-do-pai}/issues/epic-{id}-{nome}.md`
 - História / tarefa: `$PROD_DOCS/prd-{id}-{nome-do-pai}/issues/{story|task}-{id}-{nome}.md`
-- Discovery (rascunho de uma ideia, anterior ao PRD): `$PROD_DOCS/discoveries/discovery-{id}-{nome}.md`. Usa `status` (`in_review` enquanto o rascunho existe; `cancelled` se o veredito for não seguir) e `verdict` (vazio durante a entrevista, `proceed`, `investigate_more` ou `do_not_proceed`). O veredito é uma recomendação; um PRD, FRD, épico ou issue criado depois prevalece como fonte da verdade.
+- Discovery (rascunho de uma ideia, anterior ao PRD): `$DISCOVERIES_DOCS/discovery-{id}-{nome}.md`. Usa `status` (`in_review` enquanto o rascunho existe; `cancelled` se o veredito for não seguir) e `verdict` (vazio durante a entrevista, `proceed`, `investigate_more` ou `do_not_proceed`). O veredito é uma recomendação; um PRD, FRD, épico ou issue criado depois prevalece como fonte da verdade.
 
 O ID deve ser iterado nos novos arquivos seguindo a sequência existente.