jarvis-ai-framework 5.5.0 → 5.7.0

package/AGENTS.md

@@ -194,11 +194,12 @@ 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 init --upgrade [--ide X] [--yes] [--remove-stale]   # Atualizar projeto existente: assets + variáveis novas do ENV (inclui WORKSPACE_MODE) + documentos nas pastas novas + lista/remove skills antigos
 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)
 jarvis map       <nome> [--depth N] [--reverse]      # Mapa de chamadas de um workflow, skill ou agente (lê só as tabelas padronizadas)
+jarvis daily-report [--days N] [--json]             # Junta os daily.md das sessões por dia (usado pelo /eng.daily-report)
 ```
 
 Quando atuar em um projeto alvo, detectar comandos em:

package/README.md

@@ -119,7 +119,7 @@ npm install -g jarvis-ai-framework@latest
 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).
+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). Também lista os skills instalados que saíram do framework e pergunta antes de removê-los (`--remove-stale` remove sem perguntar só os listados; skills registrados em `*_SPECIALIZATIONS` nunca são listados).
 
 **Instalou via clone local** (fluxo de [Desenvolvendo o Jarvis localmente](#desenvolvendo-o-jarvis-localmente)) — quando o repo no GitHub ganhar commits novos, sincronize assim:
 

package/bin/commands/daily-report.js

@@ -0,0 +1,90 @@
+import { isAbsolute, join, relative } from "node:path";
+import { scanSessions, parseDays } from "../lib/core/session-scan.js";
+import { resolveEnvPath, loadEnv } from "../lib/env-loader.js";
+import { logger } from "../lib/utils/logger.js";
+import { GREEN, YELLOW, CYAN, DIM, NC } from "../lib/utils/ui.js";
+
+const USAGE = "Uso: jarvis daily-report [--days 1|3|7|15|30|60] [--json]";
+const DEFAULTS = {
+  DOCS_FOLDER: "docs",
+  JARVIS_DOCS: "$DOCS_FOLDER/jarvis",
+  ENG_DOCS: "$JARVIS_DOCS/engineering",
+  SESSIONS_DIR: ".jarvis/sessions",
+};
+
+/** Expande `$VAR` com os valores do ENV (e os padrões acima), em até 5 passadas. */
+export function expandVars(value, env) {
+  let out = value;
+  for (let i = 0; i < 5 && /\$[A-Z_]+/.test(out); i++) {
+    out = out.replace(/\$([A-Z_][A-Z0-9_]*)/g, (m, name) => env[name] ?? DEFAULTS[name] ?? m);
+  }
+  return out;
+}
+
+function resolveDir(root, value) {
+  return isAbsolute(value) ? value : join(root, value);
+}
+
+/**
+ * Lê as sessões do workspace e devolve o JSON do relatório. Separado de `dailyReport` para ser testável.
+ * @param {Record<string, unknown>} flags - `days`, `ide`, `env-file`
+ * @param {string} [cwd]
+ * @param {Date} [now]
+ * @returns {{ code: number, json?: object, lines?: string[] }}
+ */
+export function runDailyReport(flags = {}, cwd = process.cwd(), now = new Date()) {
+  const parsed = parseDays(flags.days);
+  if (parsed.error) return { code: 1, lines: [`❌ ${parsed.error}`, USAGE] };
+
+  let envPath;
+  let root;
+  try {
+    ({ path: envPath, root } = resolveEnvPath(cwd, flags));
+  } catch (err) {
+    return { code: 1, lines: [`❌ ${err.message}`, USAGE] };
+  }
+  root = root || cwd;
+  const env = { ...DEFAULTS, ...loadEnv(cwd, envPath) };
+
+  const sessionsDir = join(resolveDir(root, expandVars(env.SESSIONS_DIR, env)), "eng");
+  const reportsDir = join(resolveDir(root, expandVars(env.ENG_DOCS, env)), "daily-reports");
+
+  const result = scanSessions(sessionsDir, { days: parsed.days, now });
+  const reportPathAbs = join(reportsDir, result.fileName);
+  return {
+    code: 0,
+    json: {
+      ...result,
+      workspace: root,
+      sessionsDir: relative(root, sessionsDir) || ".",
+      reportPath: relative(root, reportPathAbs),
+      reportPathAbs,
+    },
+  };
+}
+
+export async function dailyReport(flags) {
+  const { code, json, lines } = runDailyReport(flags);
+  if (code !== 0) {
+    for (const line of lines) logger.error(line);
+    process.exit(code);
+  }
+
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
+    return;
+  }
+
+  logger.info(`${CYAN}🗓️  Registros dos últimos ${json.days} dia(s)${NC}`);
+  logger.info(`${DIM}Janela: ${json.window.from} a ${json.window.to} (fuso local)${NC}`);
+  logger.info(
+    `Sessões lidas: ${json.sessionsScanned} · na janela: ${json.sessionsInWindow} · dias com registro: ${json.byDate.length}`
+  );
+  logger.info(
+    json.alerts.length
+      ? `${YELLOW}⚠️  ${json.alerts.length} sessão(ões) sem daily.md: ${json.alerts.map((a) => a.key).join(", ")}${NC}`
+      : `${GREEN}✅ Todas as sessões da janela têm daily.md${NC}`
+  );
+  for (const w of json.warnings) logger.info(`${DIM}aviso: ${w}${NC}`);
+  logger.info(`${DIM}Relatório (escrito pelo /eng.daily-report): ${json.reportPath}${NC}`);
+}

package/bin/commands/init.js

@@ -16,6 +16,11 @@ 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 {
+  findStaleSkills,
+  registeredSpecializations,
+  removeStaleSkills,
+} from "../lib/core/stale-skills.js";
 import { parseEnvEntries, planEnvUpgrade, applyEnvUpgrade } from "../lib/core/env-upgrade.js";
 import {
   expandEnv,
@@ -283,7 +288,7 @@ async function runUpgrade(cwd, flags) {
     join(getFrameworkRoot(), "templates", "ENV-template.md"),
     "utf-8"
   );
-  const envPlan = planEnvUpgrade(envText, templateText);
+  const envPlan = planEnvUpgrade(envText, templateText, { workspaceDir });
   const addedKeys = envPlan.added.map((a) => a.key);
 
   // 3. Documentos: o plano usa o ENV como ficará depois do upgrade (com as chaves novas)
@@ -313,6 +318,34 @@ async function runUpgrade(cwd, flags) {
   const today = new Date().toISOString().slice(0, 10);
   applyEnvUpgrade(envPath, envPlan, today, overrides);
 
+  // 3.1 Skills instalados que saíram do framework: só lista; remove com confirmação ou --remove-stale
+  const ideSkillsDir = join(workspaceDir, `.${getIDEFolder(ide)}`, "skills");
+  const stale = findStaleSkills({
+    ideSkillsDir,
+    frameworkSkillsDir: join(getFrameworkRoot(), "skills"),
+    registered: registeredSpecializations(parseEnvEntries(envText)),
+  });
+  let staleRemoved = [];
+  let staleErrors = [];
+  if (stale.length > 0) {
+    logger.info(`${YELLOW}🧹 Skills instalados que saíram do framework:${NC}`);
+    for (const name of stale) logger.info(`  .${getIDEFolder(ide)}/skills/${name}/`);
+    let confirmed = Boolean(flags.removeStale);
+    if (!confirmed && !flags.yes && process.stdin.isTTY) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await ask(rl, `Remover estes skills antigos? (s/N): `);
+      rl.close();
+      confirmed = answer.trim().toLowerCase() === "s";
+    }
+    if (confirmed) {
+      ({ removed: staleRemoved, errors: staleErrors } = removeStaleSkills(ideSkillsDir, stale));
+    } else {
+      logger.info(
+        `${DIM}  Nada removido. Apague as pastas à mão ou rode de novo com ${BOLD}--remove-stale${NC}${DIM}.${NC}`
+      );
+    }
+  }
+
   let moved = [];
   let rewritten = [];
   let moveErrors = [];
@@ -342,6 +375,8 @@ async function runUpgrade(cwd, flags) {
   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}`);
+  if (staleRemoved.length) logger.info(`  • Skills antigos removidos: ${staleRemoved.join(", ")}`);
+  for (const e of staleErrors) logger.error(`${RED}  ✗ ${e}${NC}`);
   for (const k of envPlan.pending) {
     logger.info(`${YELLOW}  ⚠️  ${k} está vazio: responda no /jarvis-init upgrade${NC}`);
   }
@@ -350,7 +385,12 @@ async function runUpgrade(cwd, flags) {
       `${YELLOW}  ⚠️  Central docs no formato antigo (CENTRAL_DOCS_REPO): a migração é feita pelo /jarvis-init upgrade${NC}`
     );
   }
+  if (envPlan.warnings.includes("WORKSPACE_MODE")) {
+    logger.info(
+      `${YELLOW}  ⚠️  WORKSPACE_MODE: a raiz é um repositório e há subpastas com .git (submódulos?): gravado como project; confira no ENV.md${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;
+  return sync.errors.length || moveErrors.length || staleErrors.length ? 1 : 0;
 }

package/bin/lib/cli/program.js

@@ -26,6 +26,7 @@ import { qaSignoff } from "../../commands/qa-signoff.js";
 import { installRtk } from "../../commands/install-rtk.js";
 import { tokens } from "../../commands/tokens.js";
 import { map } from "../../commands/map.js";
+import { dailyReport } from "../../commands/daily-report.js";
 import { runCreateMerge } from "../vcs/create-merge.js";
 import { runCreateIssue } from "../vcs/create-issue.js";
 import { runComment } from "../tasks/comment.js";
@@ -92,7 +93,11 @@ export function buildProgram() {
       "--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");
+    .option("--yes", "Com --upgrade, move os documentos para as pastas novas sem perguntar")
+    .option(
+      "--remove-stale",
+      "Com --upgrade, remove sem perguntar os skills instalados que saíram do framework (só os listados)"
+    );
   withLogOptions(initCmd).action((options) => init(toLegacyFlags(options)));
 
   cmd(program, "list")
@@ -183,6 +188,14 @@ export function buildProgram() {
     .option("--reverse", "Mostra quem chama, em vez do que é chamado")
     .action((name, options) => map(toLegacyFlags(options, { _: [name].filter(Boolean) })));
 
+  cmd(program, "daily-report")
+    .description("Junta os daily.md das sessões por dia (base do /eng.daily-report)")
+    .option("--days <n>", "Janela em dias: 1, 3, 7, 15, 30 ou 60 (padrão: 7)")
+    .option("--json", "Saída em JSON")
+    .option("--ide <ide>")
+    .option("--env-file <path>")
+    .action((options) => dailyReport(toLegacyFlags(options)));
+
   const vcs = cmd(program, "vcs").description("Adapters de Git host (GitLab/GitHub/Bitbucket)");
 
   cmd(vcs, "create-merge")

package/bin/lib/config/constants.js

@@ -46,6 +46,11 @@ export const OBSOLETE_PATHS = Object.freeze([
   "skills/lovable-prompt-generator",
   "steering/skills/skill-churn-audit.md",
   "steering/skills/skill-lovable-prompt-generator.md",
+  // eng-scraper e eng-scraper-robot-builder (renomeados na #81 para eng-automation): ficavam sobrando na pasta da IDE
+  "skills/eng-scraper",
+  "skills/eng-scraper-robot-builder",
+  "steering/skills/skill-eng-scraper.md",
+  "steering/skills/skill-eng-scraper-robot-builder.md",
   "skills/eng-nestjs",
   "skills/eng-rabbitmq",
   "skills/eng-arch-c4",

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

@@ -2,6 +2,7 @@
 // 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";
+import { detectWorkspaceMode } from "./workspace-mode.js";
 
 const KEY_LINE = /^([A-Z][A-Z0-9_]*)=(.*)$/;
 
@@ -35,10 +36,13 @@ function isDataOnlyKey(key) {
 
 /**
  * Calcula o que o upgrade acrescenta, sem gravar nada.
+ * @param {string} envText
+ * @param {string} templateText
+ * @param {{ workspaceDir?: string }} [options] - `workspaceDir`: pasta que contém o `$IDE/`, para detectar o `WORKSPACE_MODE`
  * @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) {
+export function planEnvUpgrade(envText, templateText, { workspaceDir } = {}) {
   const env = parseEnvEntries(envText);
   const template = parseEnvEntries(templateText);
   const hub = (env.get("HUB") || "").toUpperCase();
@@ -57,6 +61,15 @@ export function planEnvUpgrade(envText, templateText) {
       value = PROD_MODE_BY_AREA[area] || "";
       if (!value) pending.push("PROD_MODE");
     }
+    if (key === "WORKSPACE_MODE" && workspaceDir) {
+      const repos = (env.get("WORKSPACE_REPOS") || "")
+        .split(",")
+        .map((r) => r.trim())
+        .filter(Boolean);
+      const detected = detectWorkspaceMode(workspaceDir, { repos });
+      value = detected.mode;
+      if (detected.warning) warnings.push("WORKSPACE_MODE");
+    }
     added.push({ key, value });
   }
 

package/bin/lib/core/session-scan.js

@@ -0,0 +1,266 @@
+// Varredura das sessões de engenharia para o /eng.daily-report: junta as seções `## AAAA-MM-DD`
+// dos `daily.md` por dia e aponta as sessões que deveriam ter `daily.md` e não têm.
+// Só lê: não escreve nas sessões nem cria o relatório (quem escreve é o workflow).
+// As datas são sempre do calendário LOCAL (o `.timestamp_start` é gravado em UTC).
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+export const ALLOWED_DAYS = [1, 3, 7, 15, 30, 60];
+export const DEFAULT_DAYS = 7;
+
+// Dia em que o `daily.md` passou a existir (gerado pelo eng.pr). Sessões sem `daily.md` que
+// começaram antes disso só geram alerta se chegaram ao eng.pr (têm `pull-request.md`).
+export const DAILY_SINCE = "2026-10-15";
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+
+/** Valida a janela. Sem valor: o padrão (7). */
+export function parseDays(value) {
+  if (value === undefined || value === null || value === "" || value === true)
+    return { days: DEFAULT_DAYS };
+  const n = Number(String(value).trim());
+  if (!ALLOWED_DAYS.includes(n)) {
+    return {
+      error: `Janela inválida: ${value}. Valores aceitos: ${ALLOWED_DAYS.join(", ")}`,
+    };
+  }
+  return { days: n };
+}
+
+/** `AAAA-MM-DD` no fuso local (sem `toISOString`, que é UTC). */
+export function localDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+/** Hoje e os `days - 1` dias anteriores, do mais recente para o mais antigo. */
+export function buildWindow(days, now = new Date()) {
+  const dates = [];
+  for (let i = 0; i < days; i++) {
+    dates.push(localDate(new Date(now.getFullYear(), now.getMonth(), now.getDate() - i)));
+  }
+  return { from: dates[dates.length - 1], to: dates[0], dates };
+}
+
+export function reportFileName(today, days) {
+  return `daily-report-${today}-${days}d.md`;
+}
+
+export function redactEmails(text) {
+  return typeof text === "string" ? text.replace(EMAIL_RE, "[e-mail removido]") : text;
+}
+
+function readText(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function unquote(value) {
+  const v = value.trim();
+  return /^(["']).*\1$/.test(v) ? v.slice(1, -1) : v;
+}
+
+/** Frontmatter `chave: valor` simples (ignora comentários). */
+function parseFrontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const data = {};
+  if (!m) return { data, body: text };
+  for (const line of m[1].split(/\r?\n/)) {
+    if (/^\s*#/.test(line)) continue;
+    const kv = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+    if (kv) data[kv[1]] = unquote(kv[2]);
+  }
+  return { data, body: text.slice(m[0].length) };
+}
+
+/** Primeira linha não vazia depois de `### Timesheet`, sem crases nem cercas de código. */
+function extractTimesheet(section) {
+  const m = section.match(/^###\s+Timesheet\s*$([\s\S]*?)(?=^###?\s|(?![\s\S]))/m);
+  if (!m) return null;
+  const line = m[1]
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .find((l) => l && !/^```/.test(l));
+  return line ? line.replace(/^`+|`+$/g, "").trim() : null;
+}
+
+function extractDescription(section) {
+  const m = section.match(/^###\s+Descrição detalhada\s*$([\s\S]*?)(?=^###\s|(?![\s\S]))/m);
+  return m ? m[1].trim() : "";
+}
+
+/**
+ * Lê um `daily.md`: frontmatter (`task_key`, `card_url`, `pr`, `branch`) e uma entrada por
+ * seção `## AAAA-MM-DD`, com a descrição detalhada e a linha de timesheet.
+ */
+export function parseDaily(text) {
+  const { data, body } = parseFrontmatter(text);
+  const sections = [];
+  const parts = body.split(/^##\s+(\d{4}-\d{2}-\d{2})\s*$/m);
+  for (let i = 1; i < parts.length; i += 2) {
+    sections.push({
+      date: parts[i],
+      description: redactEmails(extractDescription(parts[i + 1])),
+      timesheet: redactEmails(extractTimesheet(parts[i + 1])),
+    });
+  }
+  return {
+    taskKey: data.task_key || null,
+    cardUrl: data.card_url || null,
+    pr: data.pr || null,
+    branch: data.branch || null,
+    sections,
+  };
+}
+
+function firstHeading(text) {
+  const m = text && text.match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+/** Linha `Issue:` do cabeçalho do architecture.md (com ou sem negrito e `>`). */
+function issueLine(text) {
+  const m = text && text.match(/^[>\s]*\**Issue:\**\s*(.+?)\s*$/m);
+  return m ? m[1].trim() : null;
+}
+
+function prNumberFrom(text) {
+  if (!text) return null;
+  const m = text.match(/\/(?:pull|merge_requests)\/(\d+)/) || text.match(/\b(?:PR|MR)\s*#(\d+)/);
+  return m ? `#${m[1]}` : null;
+}
+
+/**
+ * Data e atividade de uma sessão sem `daily.md`, só com fontes locais (o vendor fica com o
+ * workflow). Ordem da data: `Criado em:` > `.timestamp_start` (UTC → local) > modificação da pasta.
+ */
+export function sessionInfo(dir) {
+  const arch = readText(join(dir, "architecture.md"));
+  const plan = readText(join(dir, "plan.md"));
+  const pr = readText(join(dir, "pull-request.md"));
+
+  let date = null;
+  let dateSource = null;
+  const created = arch && arch.match(/Criado em:\**\s*(\d{4}-\d{2}-\d{2})/);
+  if (created) {
+    date = created[1];
+    dateSource = "architecture";
+  }
+  if (!date) {
+    const ts = (readText(join(dir, ".timestamp_start")) || "").trim();
+    const parsed = ts ? new Date(ts) : null;
+    if (parsed && !Number.isNaN(parsed.getTime())) {
+      date = localDate(parsed);
+      dateSource = "timestamp_start";
+    }
+  }
+  if (!date) {
+    date = localDate(statSync(dir).mtime);
+    dateSource = "mtime";
+  }
+
+  const issue = issueLine(arch);
+  const issueKey = issue ? (issue.match(/#\d+|\b[A-Z][A-Z0-9]+-\d+\b/) || [null])[0] : null;
+  const issueTitle = issue ? (issue.match(/\s[—–-]\s+(.+)$/) || [null, null])[1] : null;
+  const archTitle = firstHeading(arch);
+  const usefulArchTitle =
+    archTitle && !/^architecture(\.md)?\s*[:—-]?\s*[#\w-]*$/i.test(archTitle) ? archTitle : null;
+
+  const activity = issueTitle || firstHeading(plan) || firstHeading(pr) || usefulArchTitle || null;
+
+  return {
+    date,
+    dateSource,
+    activity: redactEmails(activity),
+    issueKey,
+    prNumber: prNumberFrom(pr),
+    hasPullRequest: pr !== null,
+  };
+}
+
+/** Sessão sem `daily.md` gera alerta se chegou ao eng.pr ou começou depois do `daily.md` existir. */
+export function needsAlert({ hasDaily, hasPullRequest, date }) {
+  if (hasDaily) return false;
+  return hasPullRequest || date >= DAILY_SINCE;
+}
+
+const byKey = (a, b) => a.key.localeCompare(b.key, "pt-BR", { numeric: true });
+
+/**
+ * Varre `sessionsDir` (o `$SESSIONS_DIR/eng`) e devolve o que entra na janela.
+ * @param {string} sessionsDir
+ * @param {{ days?: number, now?: Date }} [options]
+ */
+export function scanSessions(sessionsDir, { days = DEFAULT_DAYS, now = new Date() } = {}) {
+  const window = buildWindow(days, now);
+  const inWindow = new Set(window.dates);
+  const warnings = [];
+  const perDate = new Map();
+  const alerts = [];
+  const touched = new Set();
+
+  let keys = [];
+  if (existsSync(sessionsDir)) {
+    keys = readdirSync(sessionsDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+      .map((e) => e.name);
+  } else {
+    warnings.push(`pasta de sessões não encontrada: ${sessionsDir}`);
+  }
+
+  for (const key of keys) {
+    const dir = join(sessionsDir, key);
+    const dailyText = readText(join(dir, "daily.md"));
+
+    if (dailyText !== null) {
+      const daily = parseDaily(dailyText);
+      for (const s of daily.sections) {
+        if (!DATE_RE.test(s.date) || !inWindow.has(s.date)) continue;
+        if (!perDate.has(s.date)) perDate.set(s.date, []);
+        perDate.get(s.date).push({
+          key,
+          taskKey: daily.taskKey,
+          cardUrl: daily.cardUrl,
+          pr: daily.pr,
+          branch: daily.branch,
+          description: s.description,
+          timesheet: s.timesheet,
+        });
+        touched.add(key);
+      }
+      continue;
+    }
+
+    const info = sessionInfo(dir);
+    if (!inWindow.has(info.date)) continue;
+    if (!needsAlert({ hasDaily: false, hasPullRequest: info.hasPullRequest, date: info.date }))
+      continue;
+    if (info.dateSource === "mtime")
+      warnings.push(`sessão ${key}: data tirada da modificação da pasta (sem outra fonte)`);
+    alerts.push({ key, ...info });
+    touched.add(key);
+  }
+
+  const byDate = [...perDate.entries()]
+    .sort(([a], [b]) => (a < b ? 1 : -1))
+    .map(([date, tasks]) => ({ date, tasks: tasks.sort(byKey) }));
+  alerts.sort((a, b) => (a.date === b.date ? byKey(a, b) : a.date < b.date ? 1 : -1));
+
+  return {
+    days,
+    today: window.to,
+    window: { from: window.from, to: window.to },
+    fileName: reportFileName(window.to, days),
+    sessionsScanned: keys.length,
+    sessionsInWindow: touched.size,
+    byDate,
+    alerts,
+    warnings,
+  };
+}

package/bin/lib/core/stale-skills.js

@@ -0,0 +1,63 @@
+// Skills obsoletos (`jarvis init --upgrade`): skills instalados na pasta da IDE que não existem
+// mais no framework (renomeados ou removidos). O upgrade só LISTA e, com confirmação, remove.
+// Nunca marca como obsoleto um skill registrado em alguma lista `*_SPECIALIZATIONS` do ENV.md
+// (especializações criadas pelo usuário com o jarvis-create-specialization).
+// Só lê nomes de pasta: nunca lê nem imprime o conteúdo dos skills.
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
+
+/**
+ * Nomes registrados nas listas `*_SPECIALIZATIONS` do ENV (aceita vírgulas, colchetes, aspas e espaços).
+ * @param {Map<string, string>} entries - `parseEnvEntries(envText)`
+ * @returns {Set<string>}
+ */
+export function registeredSpecializations(entries) {
+  const names = new Set();
+  for (const [key, value] of entries) {
+    if (!key.endsWith("_SPECIALIZATIONS")) continue;
+    for (const item of value.replace(/[[\]"']/g, "").split(",")) {
+      const name = item.trim();
+      if (name) names.add(name);
+    }
+  }
+  return names;
+}
+
+/**
+ * @param {{ ideSkillsDir: string, frameworkSkillsDir: string, registered?: Set<string> }} p
+ * @returns {string[]} nomes (pastas) de skills instalados que o framework não tem mais
+ */
+export function findStaleSkills({ ideSkillsDir, frameworkSkillsDir, registered = new Set() }) {
+  if (!existsSync(ideSkillsDir)) return [];
+  return readdirSync(ideSkillsDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && SKILL_NAME.test(e.name))
+    .map((e) => e.name)
+    .filter((name) => existsSync(join(ideSkillsDir, name, "SKILL.md")))
+    .filter((name) => !existsSync(join(frameworkSkillsDir, name)))
+    .filter((name) => !registered.has(name))
+    .sort();
+}
+
+/**
+ * Remove as pastas listadas, uma a uma (só nomes já validados por `findStaleSkills`).
+ * @returns {{ removed: string[], errors: string[] }}
+ */
+export function removeStaleSkills(ideSkillsDir, names) {
+  const removed = [];
+  const errors = [];
+  for (const name of names) {
+    if (!SKILL_NAME.test(name)) {
+      errors.push(`${name}: nome inválido`);
+      continue;
+    }
+    try {
+      rmSync(join(ideSkillsDir, name), { recursive: true, force: true });
+      removed.push(name);
+    } catch (err) {
+      errors.push(`${name}: ${err.message}`);
+    }
+  }
+  return { removed, errors };
+}

package/bin/lib/core/workspace-mode.js

@@ -0,0 +1,57 @@
+// Modo de trabalho do workspace (WORKSPACE_MODE): decide se a pasta que contém o `$IDE/` é
+// um projeto único ou um workspace. O que define o modo é a RAIZ ser ou não um repositório,
+// e não quantos repositórios existem dentro dela:
+//   - raiz com `.git`                                  → "project" (o git já delimita o código)
+//   - raiz sem `.git` e 1+ subpastas com `.git`        → "workspace"
+//   - raiz sem `.git` e nenhuma subpasta com `.git`    → "project" (padrão)
+// Caso ambíguo (raiz com `.git` e subpastas também com `.git`, como submódulos): "project" + aviso.
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+export const WORKSPACE_MODES = ["workspace", "project"];
+
+/** Subpastas diretas com `.git` (arquivo ou pasta). Ignora ocultas e `node_modules`. */
+function listGitSubdirs(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules")
+    .filter((e) => existsSync(join(dir, e.name, ".git")))
+    .map((e) => e.name)
+    .sort();
+}
+
+/**
+ * @param {string} workspaceDir - pasta que contém o `$IDE/`
+ * @param {{ repos?: string[] }} [options] - `repos`: allowlist (WORKSPACE_REPOS); vazia = todas
+ * @returns {{ mode: "workspace"|"project", repos: string[], warning: string|null }}
+ */
+export function detectWorkspaceMode(workspaceDir, { repos = [] } = {}) {
+  const rootIsRepo = existsSync(join(workspaceDir, ".git"));
+  const allow = new Set(repos);
+  const found = listGitSubdirs(workspaceDir).filter((n) => allow.size === 0 || allow.has(n));
+
+  if (rootIsRepo) {
+    return {
+      mode: "project",
+      repos: [],
+      warning: found.length
+        ? "a raiz é um repositório e há subpastas com .git (submódulos ou repositórios aninhados): tratada como projeto único"
+        : null,
+    };
+  }
+  if (found.length >= 1) return { mode: "workspace", repos: found, warning: null };
+  return { mode: "project", repos: [], warning: null };
+}
+
+/** Lê o valor do ENV: só `workspace` ou `project` (sem diferenciar maiúsculas); outro valor = null. */
+export function normalizeWorkspaceMode(value) {
+  const v = String(value || "")
+    .trim()
+    .toLowerCase();
+  return WORKSPACE_MODES.includes(v) ? v : null;
+}