jarvis-ai-framework 5.1.0 → 5.5.0

package/AGENTS.md

@@ -194,6 +194,7 @@ Comandos disponíveis:
 jarvis whoami   [--logout]                          # Exibir identidade (ENV.md / git / SO)
 jarvis logout                                       # Remover auth.json legado (opcional)
 jarvis init                                         # Bootstrap do framework no projeto
+jarvis init --upgrade [--ide X] [--yes]             # Atualizar projeto existente: assets + variáveis novas do ENV + documentos nas pastas novas
 jarvis list                                         # Listar agents, skills e workflows
 jarvis install-rtk                                  # Instalar RTK (token killer — economia 60-90% em tokens de shell)
 jarvis tokens    [--hub X --position Y --area Z --squad W] [--rtk] [--json]   # Estimar o que carrega no início da sessão (perfil do ENV.md se sem flags)

package/README.md

@@ -116,9 +116,11 @@ Mesmos passos 2 e 3 do [Get Started](#get-started) acima — `jarvis init --ide
 
 ```bash
 npm install -g jarvis-ai-framework@latest
-jarvis init --ide {ide}   # re-sincroniza os assets (agents/skills/workflows/rules)
+jarvis init --upgrade --ide {ide}   # assets + variáveis novas do ENV.md + documentos para as pastas novas
 ```
 
+Depois, na IDE, rode `/jarvis-init upgrade`: ele vai direto ao Upgrade (C) e cuida do que precisa de conversa (Central docs antigo e o passo das stacks). O `--upgrade` só **acrescenta** chaves ao `ENV.md`: nenhuma chave existente muda. Ele mostra os documentos que estão em caminhos antigos e pergunta antes de movê-los (`--yes` move sem perguntar; sem terminal interativo, não move).
+
 **Instalou via clone local** (fluxo de [Desenvolvendo o Jarvis localmente](#desenvolvendo-o-jarvis-localmente)) — quando o repo no GitHub ganhar commits novos, sincronize assim:
 
 ### 1. Atualizar o clone
@@ -203,6 +205,17 @@ Escolha **Upgrade (C)** — adiciona chaves novas do template sem apagar os valo
 
 ---
 
+## Estilo dos artefatos
+
+O `/jarvis-init` pergunta o `ARTIFACT_STYLE` (variável do `ENV.md`):
+
+| Valor | O que acontece |
+|---|---|
+| `ai-generated` (padrão) | Como sempre: metadados, links de rastreabilidade e padrões da ferramenta |
+| `human-generated` | Nada do que o Jarvis publica (commit, PR/MR, comentário no card, issue) leva marca de IA ou da IDE: o `/eng.pr` confere e limpa antes do push. Todo documento gerado pergunta, no fim, se você quer a versão humanizada, gravada ao lado como `{nome}.public.md` para repassar a clientes ou stakeholders |
+
+Com `human-generated`, o `/jarvis-init` copia a rule `rules/artifact-style-rules.md` (eixo `ARTIFACT_STYLE` do `Applies to`); com `ai-generated`, ela nem existe na sessão. Trocou o valor à mão? Rode `/jarvis-init upgrade`.
+
 ## Funciona com qualquer stack
 
 O Jarvis não presume Go, PHP, NestJS ou React. Cada área (backend e frontend) tem uma **skill base neutra**, e cada projeto registra no `ENV.md` as **especializações** da sua stack (`BACKEND_SPECIALIZATIONS` e `FRONTEND_SPECIALIZATIONS`). Os comandos `eng.*` carregam a base mais o que o projeto registrou.

package/agents/product/prod.discovery-interviewer.md

@@ -1,105 +1,40 @@
 ---
 name: prod.discovery-interviewer
-description: Entrevistador de produto que conduz o discovery de uma ideia: entende o problema, os requisitos iniciais e a viabilidade sem chutar, e registra tudo em um rascunho estruturado.
+description: Entrevistador de produto que conduz o discovery de uma ideia: mostra primeiro o que entendeu, faz poucas perguntas de alto impacto com recomendação e registra um rascunho com scorecard e veredito, sem chutar.
 tools: Read, Write, Edit, Glob, Grep, LS, Bash
 model: sonnet
 ---
 
 # @prod.discovery-interviewer
 
-Entrevistador de produto do Jarvis. Conduz o `/prod.spec.discovery`: transforma uma ideia ainda crua em um rascunho estruturado, com o que se sabe, o que é hipótese e o que ainda é lacuna, e indica o próximo passo.
+Entrevistador de produto do Jarvis no `/prod.spec.discovery`. **O fluxo, o orçamento de perguntas e a regra "não chute" estão no workflow `workflows/product/prod.spec.discovery.md`: siga-o.** Este arquivo define só a postura.
 
-As regras de escrita de especificação ficam em `rules/product/` (`prod.spec-rules.md`). O fluxo do comando (criação e retomada do arquivo, veredito, limites) está no workflow `workflows/product/prod.spec.discovery.md`; este arquivo define a **postura**.
+## Postura
 
-## Persona
+Você é um product manager experiente: **testa a ideia, não a julga**, e economiza o tempo de quem responde.
 
-Você é um product manager experiente e curioso, e faz o papel de entrevistador: a qualidade do discovery depende das perguntas certas, não de preencher um formulário.
-
-- **Faz perguntas abertas** e escuta a resposta antes de formular a próxima
-- **Aprofunda respostas rasas**: "por quê?", "para quem?", "com que frequência?", "me dá um exemplo real", "o que acontece hoje?"
-- **Pede evidência** quando ouve uma afirmação sem base ("todo mundo quer") e registra se ela é dado, observação ou suposição
-- **Aponta contradições**, entre respostas ou entre o que o usuário disse e o que está no projeto, e pede que o usuário resolva
-- **Levanta o que o usuário provavelmente não considerou**: quem mais é impactado, custo de manutenção, o que acontece se der errado, a alternativa mais simples
-- **Adapta o roteiro às respostas**: não segue uma lista fixa e não repete temas já esgotados
-- Tom direto e respeitoso; não julga a ideia, testa a ideia
-
-## Objetivo
-
-Ajudar o usuário a fazer o melhor discovery possível de uma ideia, cobrindo quatro eixos:
-
-1. **Ideia**: o que é e para quem
-2. **Problema**: qual dor, que evidência existe, quem sofre, como se resolve hoje
-3. **Requisitos iniciais**: o que precisaria ser verdade, em alto nível, como hipóteses
-4. **Viabilidade**: sinal indicativo de valor, usabilidade, técnica e negócio, com riscos e dependências
-
-O resultado é um arquivo no formato do template `$PROD_TEMPLATES/prod-discovery-template.md` (`templates/product/prod-discovery-template.md`), terminando com um veredito (`proceed`, `investigate_more` ou `do_not_proceed`) e um próximo passo sugerido.
-
-## Quando Usar
-
-- O usuário tem uma ideia e ainda não sabe se o problema é real, quais são os requisitos ou se é viável
-- O usuário roda `/prod.spec.discovery`, com uma ideia ou apontando um discovery existente para retomar
-- O `/prod.spec` identifica que só existe uma ideia inicial
-
-Não use quando já existe uma spec (use `/prod.spec.clarify`) ou quando o escopo já está claro e o usuário quer documentá-lo (use `/prod.spec.prd`, `/prod.spec.frd` ou `/prod.spec.issue`).
-
-## Entrada
-
-- A ideia em texto livre (`$ARGUMENTS`), ou o caminho ou nome de um discovery existente para retomar
-- O contexto do projeto: `ENV.md`, documentos em `$PROD_DOCS` e o código, lidos antes de perguntar
-
-## Saída
-
-- O arquivo `$PROD_DOCS/discoveries/discovery-{id}-{nome}.md`, preenchido pelo template e atualizado a cada tema
-- Uma seção de **Próximo passo sugerido**, sempre presente e sempre só uma sugestão
-
-## Como conduzir a entrevista
-
-1. **Comece explicando** em poucas linhas que vai entrevistar, quais temas cobrirá (ideia, problema, requisitos, viabilidade) e que o usuário pode responder "não sei" a qualquer momento
-2. **Consulte o projeto antes de perguntar**: documentos existentes (para não duplicar um PRD) e o código (para embasar a viabilidade)
-3. **Uma pergunta por vez.** Use o `AskUserQuestion` quando estiver disponível; caso contrário, o formato de tabela do `prod-rules.md`. Espere a resposta antes de seguir
-4. **Se o usuário não responde ou diz "não sei"**, não repita a pergunta: registre "não informado" e siga
-5. **Ao cobrir um tema**, resuma em poucas linhas o que entendeu e peça confirmação antes de passar ao próximo
-6. **Priorize as perguntas de maior impacto** na decisão de seguir ou não, em vez de esgotar todas as possíveis
-7. **Quando achar que já tem informação suficiente**, proponha encerrar e pergunte se o usuário quer acrescentar algo antes de fechar o documento
-
-## Não chute (regra inviolável)
-
-- Quando você não tem uma informação (público, volume, custo, prazo, restrição técnica, comportamento de usuários, estado atual do código), **não presuma nem complete com "o que costuma ser"**: pergunte, busque no projeto ou registre como lacuna
-- Todo fato citado indica a origem: resposta do usuário, arquivo do projeto ou documentação consultada. O que não tem origem entra no documento como **suposição a validar**
-- Se o usuário pedir "preencha o que faltar" ou "assuma o padrão", registre o item como **suposição explícita**, nunca como fato, e não a use para sustentar o veredito
-- Uma **lacuna crítica nunca** resulta em `proceed`: o veredito é `investigate_more`
-- Quando a viabilidade técnica depende de bibliotecas, APIs ou serviços, consulte a documentação atual (por exemplo via Context7) em vez de responder de memória
+- **Entende antes de perguntar:** lê o que já existe e devolve o que entendeu, separando o que foi dito, o que é suposição e o que falta
+- **Pergunta pouco e certo:** só o que muda o veredito, da pergunta mais impactante para a menos, sempre com o porquê e uma recomendação
+- **Não pergunta o óbvio:** um padrão razoável vira suposição registrada, não pergunta
+- **Pede evidência e aponta contradição** só quando isso muda a decisão
+- **Lembra do que o usuário não considerou:** quem mais é impactado, custo de manutenção, o que acontece se der errado, a alternativa mais simples
+- **Fecha com clareza:** abordagens com recomendação, scorecard honesto (`desconhecido` é uma resposta válida) e um próximo passo pronto para usar
+- Tom direto e respeitoso
 
 ## Skills Disponíveis
 
-As skills são apoio, nunca a fonte da decisão. A busca em `$PROD_DOCS` não é uma skill: é feita sempre, antes de perguntar.
-
 ### jarvis-docs-central
-Para conhecer o que já foi implementado no produto (funcionalidades do Central docs), quando `CENTRAL_DOCS_STORAGE` estiver configurado:
-- Arquivo: `$IDE/skills/jarvis-docs-central/SKILL.md`
-- Confiança: sempre
-
-### jarvis-context-detect
-Para calibrar a profundidade da entrevista:
-- Arquivo: `$IDE/skills/jarvis-context-detect/SKILL.md`
-- Confiança: sempre
+O que já foi implementado, quando `CENTRAL_DOCS_STORAGE` estiver configurado. Confiança: sempre.
 
 ### eng-backend-arch-c4
-Para consultar a arquitetura atual:
-- Arquivo: `$IDE/skills/eng-backend-arch-c4/SKILL.md`
-- Confiança: só com a confirmação do usuário (skill de engenharia: pergunte antes de consultá-la; o que ela retornar entra no discovery como **suposição a validar**, não como fato)
+Arquitetura atual. Confiança: só com a confirmação do usuário; o retorno é **suposição a validar**.
 
 ### eng-platform
-Para quando a ideia envolve infraestrutura, dados pessoais ou fluxo financeiro com risco de segurança/privacidade:
-- Arquivo: `$IDE/skills/eng-platform/SKILL.md` (temas 9 e 13)
-- Confiança: só com a confirmação do usuário (skill de engenharia: pergunte antes de consultá-la; o que ela retornar entra no discovery como **suposição a validar**, não como fato)
+Infraestrutura, dados pessoais ou risco de segurança (temas 9 e 13). Confiança: só com a confirmação do usuário; o retorno é **suposição a validar**.
 
 ## Restrições
 
-- **O discovery é um rascunho.** Você **não** gera PRD, FRD, épico, issue, tarefas, histórias, critérios de aceitação nem estimativas (horas ou pontos). Se o usuário pedir, explique que é outra etapa e indique o comando certo
-- **Não escreve código** e não implementa nada
-- **Não grava credenciais, tokens nem dados pessoais de clientes** no arquivo: o discovery é versionado
-- **Não entrevista terceiros**: a entrevista é sempre com o usuário que executou o comando
-- **Não executa o próximo passo**: só sugere. O usuário pode escolher outro caminho ou parar ali
-- Um rascunho de abordagem técnica pode aparecer na viabilidade, sempre como hipótese a validar; a decisão de arquitetura pertence ao fluxo de engenharia
-- Siga as regras de `$PROD_RULES` (`prod-rules.md`): validação do `ENV.md`, idioma (pt-BR por padrão, ou o idioma da interação do usuário) e confirmação antes de salvar arquivos
+- Não gera PRD, FRD, épico, issue, histórias, critérios de aceitação nem estimativas; indique o comando certo
+- Não escreve código nem decide arquitetura (um rascunho técnico é sempre suposição)
+- Não entrevista terceiros e não executa o próximo passo: só sugere
+- Não grava credenciais, tokens nem dados pessoais de clientes

package/bin/commands/init.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, dirname, basename } from "node:path";
 import { createInterface } from "node:readline";
 import { syncAssets } from "../lib/core/sync-engine.js";
 import { discoverAll } from "../lib/core/scanner.js";
@@ -7,12 +7,23 @@ import {
   IDES,
   getIDEConfig,
   getIDEFolder,
+  getIDEValues,
   getWorkflowsFolder,
   isIDESupported,
 } from "../lib/config/ide-config.js";
 import { showBanner, RED, GREEN, BLUE, YELLOW, CYAN, DIM, BOLD, NC } from "../lib/utils/ui.js";
-import { getPackageInfo } from "../lib/utils/paths.js";
+import { getPackageInfo, getFrameworkRoot } from "../lib/utils/paths.js";
 import { logger, configureFromFlags } from "../lib/utils/logger.js";
+import { resolveEnvPath } from "../lib/env-loader.js";
+import { LOCK_FILE } from "../lib/config/constants.js";
+import { parseEnvEntries, planEnvUpgrade, applyEnvUpgrade } from "../lib/core/env-upgrade.js";
+import {
+  expandEnv,
+  planDocsMigration,
+  applyDocsMigration,
+  rewriteRelatedDiscovery,
+  declineEnvValues,
+} from "../lib/core/docs-migrate.js";
 
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
@@ -25,6 +36,11 @@ export async function init(flags) {
 
   showBanner();
 
+  if (flags.upgrade) {
+    process.exitCode = await runUpgrade(cwd, flags);
+    return;
+  }
+
   let ide;
   if (flags.ide) {
     if (!isIDESupported(flags.ide)) {
@@ -207,3 +223,134 @@ export async function init(flags) {
   logger.info(`     ${YELLOW}jarvis list${NC}`);
   logger.info("");
 }
+
+/** IDE de um ENV.md encontrado (`.claude/ENV.md` → `claude`). */
+function ideFromEnvPath(envPath) {
+  const folder = basename(dirname(envPath));
+  return getIDEValues().find((v) => `.${getIDEFolder(v)}` === folder);
+}
+
+function readLockVersion(workspaceDir) {
+  try {
+    return (
+      JSON.parse(readFileSync(join(workspaceDir, LOCK_FILE), "utf-8")).version || "desconhecida"
+    );
+  } catch {
+    return "desconhecida";
+  }
+}
+
+/**
+ * `jarvis init --upgrade`: atualiza um projeto já configurado em uma passada.
+ * 1. arquivos do framework (como o --force, sem perguntar); 2. só as chaves novas do ENV;
+ * 3. documentos dos caminhos antigos → docs/jarvis/… (com confirmação ou --yes).
+ * Nunca imprime valores do ENV, só nomes de chave e caminhos.
+ * @returns {Promise<number>} código de saída
+ */
+async function runUpgrade(cwd, flags) {
+  let resolved;
+  try {
+    resolved = resolveEnvPath(cwd, flags.ide ? { ide: flags.ide } : {});
+  } catch (err) {
+    resolved = { error: err.message.split("\n")[0] };
+  }
+  const ide = flags.ide || (resolved.path && ideFromEnvPath(resolved.path));
+  if (resolved.error || !ide || !existsSync(resolved.path)) {
+    logger.error(
+      `${RED}🚫 Nenhuma instalação do Jarvis encontrada (ENV.md ausente)${resolved.error ? `: ${resolved.error}` : ""}.${NC}`
+    );
+    logger.error(
+      `${YELLOW}Rode ${BOLD}jarvis init --ide ${flags.ide || "{ide}"}${NC}${YELLOW} e depois ${BOLD}/jarvis-init${NC}${YELLOW} na IDE.${NC}\n`
+    );
+    return 1;
+  }
+  const workspaceDir = resolved.root;
+  const envPath = resolved.path;
+  const previousVersion = readLockVersion(workspaceDir);
+
+  // 1. Arquivos do framework (o ENV.md não está entre os sincronizados)
+  logger.info(`${BLUE}⬆️  Upgrade do Jarvis em .${getIDEFolder(ide)}/${NC}\n`);
+  const sync = syncAssets(workspaceDir, ide, {
+    force: true,
+    workflowsFolder: getWorkflowsFolder(ide),
+    keepEnvValues: true,
+  });
+  for (const item of sync.errors) logger.error(`${RED}  ✗ ${item}${NC}`);
+
+  // 2. Variáveis novas (só acrescenta)
+  const envText = readFileSync(envPath, "utf-8");
+  const templateText = readFileSync(
+    join(getFrameworkRoot(), "templates", "ENV-template.md"),
+    "utf-8"
+  );
+  const envPlan = planEnvUpgrade(envText, templateText);
+  const addedKeys = envPlan.added.map((a) => a.key);
+
+  // 3. Documentos: o plano usa o ENV como ficará depois do upgrade (com as chaves novas)
+  const futureEntries = parseEnvEntries(
+    `${envText}\n${envPlan.added.map(({ key, value }) => `${key}=${value}`).join("\n")}\n`
+  );
+  const env = expandEnv(futureEntries);
+  const docsPlan = planDocsMigration(workspaceDir, env);
+
+  let accepted = false;
+  if (docsPlan.moves.length > 0) {
+    logger.info(`${YELLOW}📁 Documentos em caminhos antigos:${NC}`);
+    for (const m of docsPlan.moves) logger.info(`  ${m.from} → ${m.to}`);
+    if (flags.yes) accepted = true;
+    else if (process.stdin.isTTY) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await ask(rl, `Mover para docs/jarvis/…? (s/N): `);
+      rl.close();
+      accepted = answer.trim().toLowerCase() === "s";
+    } else {
+      logger.info(`${DIM}  Sem terminal interativo e sem --yes: nada será movido.${NC}`);
+    }
+  }
+
+  const overrides =
+    docsPlan.moves.length > 0 && !accepted ? declineEnvValues(docsPlan, addedKeys, env) : {};
+  const today = new Date().toISOString().slice(0, 10);
+  applyEnvUpgrade(envPath, envPlan, today, overrides);
+
+  let moved = [];
+  let rewritten = [];
+  let moveErrors = [];
+  if (accepted) {
+    const result = applyDocsMigration(workspaceDir, docsPlan, env);
+    moved = result.moved;
+    moveErrors = result.errors;
+    rewritten = rewriteRelatedDiscovery(workspaceDir, env, moved);
+  }
+
+  // 4. Resumo (só nomes de chave e caminhos)
+  const pkg = getPackageInfo();
+  logger.info("");
+  logger.info(`${GREEN}✅ Upgrade concluído: ${previousVersion} → ${pkg.version}${NC}`);
+  logger.info(`  • Arquivos do framework: ${sync.copied.length} item(ns) sincronizado(s)`);
+  logger.info(
+    `  • ENV.md: ${addedKeys.length ? `+ ${addedKeys.join(", ")}` : "nenhuma variável nova"}`
+  );
+  if (Object.keys(overrides).length) {
+    logger.info(`  • Mantidos no caminho antigo: ${Object.keys(overrides).join(", ")}`);
+  }
+  if (docsPlan.moves.length && !accepted) {
+    logger.info(`  • Documentos: nada movido (${docsPlan.moves.length} no caminho antigo)`);
+  }
+  if (moved.length) logger.info(`  • Documentos movidos: ${moved.length}`);
+  if (rewritten.length) logger.info(`  • related_discovery atualizado: ${rewritten.join(", ")}`);
+  for (const s of docsPlan.skipped)
+    logger.info(`${YELLOW}  ⚠️  Pulado (${s.reason}): ${s.from}${NC}`);
+  for (const e of moveErrors) logger.error(`${RED}  ✗ ${e}${NC}`);
+  for (const k of envPlan.pending) {
+    logger.info(`${YELLOW}  ⚠️  ${k} está vazio: responda no /jarvis-init upgrade${NC}`);
+  }
+  if (envPlan.warnings.includes("CENTRAL_DOCS_REPO")) {
+    logger.info(
+      `${YELLOW}  ⚠️  Central docs no formato antigo (CENTRAL_DOCS_REPO): a migração é feita pelo /jarvis-init upgrade${NC}`
+    );
+  }
+  logger.info("");
+  logger.info(`${CYAN}➡️  Agora rode ${BOLD}/jarvis-init upgrade${NC}${CYAN} na IDE.${NC}\n`);
+  return sync.errors.length || moveErrors.length ? 1 : 0;
+}

package/bin/commands/tokens.js

@@ -6,16 +6,20 @@ import { logger } from "../lib/utils/logger.js";
 
 const AXES = ["HUB", "POSITION", "AREA", "SQUAD"];
 
-/** Perfil: as flags (`--hub` etc.) mandam; o que faltar vem do ENV.md. */
+/**
+ * Perfil: as flags (`--hub` etc.) mandam; o que faltar vem do ENV.md.
+ * ARTIFACT_STYLE é opcional (vazio = ai-generated) e não entra em `missing`.
+ */
 function resolveProfile(flags) {
   const profile = {};
   for (const axis of AXES) {
     const value = flags[axis.toLowerCase()];
     if (typeof value === "string") profile[axis] = value;
   }
+  if (typeof flags.artifactStyle === "string") profile.ARTIFACT_STYLE = flags.artifactStyle;
 
   let rtkEnabled = flags.rtk === true || flags.rtk === "true";
-  // O ENV.md só entra quando falta algum eixo; com os 4 eixos nas flags, o RTK vem só da flag.
+  // O ENV.md só entra quando falta algum eixo; com os 4 eixos nas flags, o RTK e o estilo vêm só das flags.
   if (AXES.some((axis) => !profile[axis])) {
     try {
       const { path } = resolveEnvPath(process.cwd(), flags);
@@ -23,6 +27,8 @@ function resolveProfile(flags) {
       for (const axis of AXES) {
         if (!profile[axis] && env[axis]) profile[axis] = env[axis];
       }
+      if (!profile.ARTIFACT_STYLE && env.ARTIFACT_STYLE)
+        profile.ARTIFACT_STYLE = env.ARTIFACT_STYLE;
       if (flags.rtk === undefined) rtkEnabled = env.RTK_ENABLED === "true";
     } catch {
       // sem ENV.md: valem só as flags
@@ -59,7 +65,7 @@ export async function tokens(flags) {
   showBanner();
   logger.info(`${CYAN}📏 Custo estimado no início da sessão${NC}`);
   logger.info(
-    `${DIM}Perfil: HUB=${profile.HUB} | POSITION=${profile.POSITION} | AREA=${profile.AREA} | SQUAD=${profile.SQUAD}` +
+    `${DIM}Perfil: HUB=${profile.HUB} | POSITION=${profile.POSITION} | AREA=${profile.AREA} | SQUAD=${profile.SQUAD} | ARTIFACT_STYLE=${profile.ARTIFACT_STYLE || "ai-generated"}` +
       ` | RTK=${rtkEnabled ? "ligado" : "desligado"}${NC}`
   );
   logger.info(`${DIM}${report.estimate}${NC}`);

package/bin/lib/cli/program.js

@@ -87,7 +87,12 @@ export function buildProgram() {
   const initCmd = cmd(program, "init")
     .description("Bootstrap do framework no workspace")
     .option("--ide <ide>", "IDE a configurar (pula o menu interativo)")
-    .option("--force", "Sobrescreve a instalação existente sem perguntar");
+    .option("--force", "Sobrescreve a instalação existente sem perguntar")
+    .option(
+      "--upgrade",
+      "Atualiza um projeto já configurado: arquivos do framework, variáveis novas do ENV e pastas de documentos"
+    )
+    .option("--yes", "Com --upgrade, move os documentos para as pastas novas sem perguntar");
   withLogOptions(initCmd).action((options) => init(toLegacyFlags(options)));
 
   cmd(program, "list")
@@ -164,6 +169,7 @@ export function buildProgram() {
     .option("--position <position>")
     .option("--area <area>")
     .option("--squad <squad>")
+    .option("--artifact-style <estilo>", "ai-generated ou human-generated (padrão: lido do ENV.md)")
     .option("--rtk", "Força RTK ligado (padrão: lido do ENV.md)")
     .option("--json", "Saída em JSON")
     .option("--ide <ide>")
@@ -201,8 +207,14 @@ export function buildProgram() {
     .option("--repo <url-ou-path>")
     .option("--title <titulo>")
     .option("--body-file <path>")
+    .option("--label <labels>", "Labels separadas por vírgula (padrão: bug)")
     .action((options) =>
-      runCreateIssue({ repo: options.repo, title: options.title, bodyFile: options.bodyFile })
+      runCreateIssue({
+        repo: options.repo,
+        title: options.title,
+        bodyFile: options.bodyFile,
+        labels: options.label,
+      })
     );
 
   const tasks = cmd(program, "tasks").description("Adapters de task manager");