shakers-cli 0.0.0-stage → 0.14.1

package/src/render-terminal.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const { getCatalog, categoryLabel } = require('./i18n');
+const { sanitizeRenderText } = require('./sanitize-network-text');
+const { DEFAULT_REPORT_GATE } = require('./report-gating');
+const { c, bar, sep, wrap } = require('./terminal-format');
+const { detectedTools } = require('./detected-tools');
+const { printAgents, printActivity } = require('./terminal-agents');
+const {
+  printMcpServices,
+  printTierAnalysis,
+  printLadder,
+  printRoadmap,
+} = require('./terminal-sections');
+
+// talents-ai-score: terminal parity with the HTML report.
+
+// `lang` ('es'|'en', see src/i18n.js) decides the text catalog.
+function renderTerminal(report, maturity, lang, opts = {}) {
+  const t = getCatalog(lang);
+  const lines = [];
+  const p = (s = '') => lines.push(s);
+
+  // issue 123 / ADR-044: the ONE identity gate.
+  const gate = opts.gate || DEFAULT_REPORT_GATE;
+
+  // ADR-016: Setup Level (S1-S3 / Not certified) replaces the 0-4 band label.
+  const setupKey = (maturity.setupLevel && maturity.setupLevel.key) || 'none';
+  const setupLabel = (t.setupLevels && t.setupLevels[setupKey] && t.setupLevels[setupKey].label) || setupKey;
+
+  // A compact brand header in BOTH modes for orientation.
+  p();
+  p(`${c.bold}${c.primary}  SHAKERS${c.reset}${c.muted}  ·  ${t.terminal.brandSub}${c.reset}`);
+  p(`${c.muted}  ${new Date(report.generatedAt).toLocaleString()}  ·  ${t.terminal.toolsDetected(detectedTools(report.tools).length, report.tools.length)}${c.reset}`);
+
+  // `--roadmap` (opts.showRoadmap): render ONLY the next-steps/roadmap section (header + steps + the copyable implementation prompt) — NOT the rest of the report.
+  if (opts.showRoadmap) {
+    sep(p);
+    if (gate.showRoadmap) {
+      printRoadmap(report, maturity, t, lang, p);
+    }
+    return lines.join('\n');
+  }
+
+  // Default report: score -> why -> tools -> technologies -> agents, then a dim hint pointing at --roadmap (so the next-steps section is discoverable).
+
+  sep(p);
+  const tierName = (maturity.tierKey && t.tierNames[maturity.tierKey]) || maturity.tierName || '';
+  const tierBit = maturity.tierKey ? t.terminal.tierInline(maturity.tierKey, tierName) : '';
+  // This report's ONE headline (dueño, 2026-08-11): the Setup Level IS the evaluation's main result, so it gets `accent` (lime) — and nothing else on this screen does.
+  const setupColor = setupKey === 'none' ? c.white : c.accent;
+  p(`  ${c.bold}${setupColor}${t.terminal.setupLevel(setupLabel)}${c.reset}${c.muted}${tierBit}${c.reset}`);
+  p(`  ${c.primary}${bar(maturity.score)}${c.reset} ${c.dim}${maturity.score}/100${c.reset}`);
+
+  // 2. WHY that score/tier — the rationale, right after the number.
+  sep(p);
+  printTierAnalysis(report, t, p);
+
+  // 2b. Progression ladder — what each level 0-4 and tier T0-T7 means, and the
+  // ✓/●/○ progression with unlock criteria (report req 1, full in terminal).
+  sep(p);
+  printLadder(report, t, p);
+
+  // 3. Detected tools — omitted entirely if none detected.
+  const detected = detectedTools(report.tools);
+  if (detected.length) {
+    sep(p);
+    p(`  ${c.bold}${t.terminal.detectedHeading}${c.reset}`);
+    for (const tool of detected) {
+      const depthBits = Object.entries(tool.depth)
+        .filter(([, v]) => v > 0)
+        .map(([k, v]) => `${v} ${k}`)
+        .join(', ');
+      const extra = depthBits ? `${c.dim} — ${depthBits}${c.reset}` : '';
+      const version = tool.version ? `${c.dim} v${sanitizeRenderText(tool.version)}${c.reset}` : '';
+      p(`  ${c.success}●${c.reset} ${sanitizeRenderText(tool.name)}${version} ${c.muted}(${categoryLabel(lang, tool.category)})${c.reset}${extra}`);
+    }
+  }
+
+  // 4b. MCP services (issue 110) — ALWAYS printed, empty state included, because
+  // its absence is a tier criterion the talent needs to know about.
+  sep(p);
+  printMcpServices(report, t, p);
+
+  // 5. Agents — one line per agent (+ summarized description, ↓ nesting,
+  // compact score + usage). Omitted entirely when there are no agents at all.
+  const hasAgents = Array.isArray(report.agents) && report.agents.length > 0;
+  if (hasAgents) {
+    sep(p);
+    printAgents(report, t, p, gate);
+  }
+
+  const activityLines = [];
+  if (printActivity(report, t, (s = '') => activityLines.push(s))) {
+    sep(p);
+    for (const line of activityLines) p(line);
+  }
+
+  // Where the roadmap pointer went.
+  if (gate.showRoadmap) {
+    p(`  ${c.dim}${t.terminal.roadmapHint}${c.reset}`);
+  }
+  p();
+
+  return lines.join('\n');
+}
+
+// `wrap` is re-exported for its own unit test (issue 087): it is the one piece of the formatting with edge cases worth pinning directly.
+module.exports = { renderTerminal, wrap, printAgents };

package/src/render-usage-report-text.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const { detectedTools } = require('./detected-tools');
+
+const LABELS = {
+  es: {
+    title: 'Informe de uso de IA (almacenado)',
+    platform: 'Plataforma',
+    level: 'Nivel',
+    score: 'Puntuación',
+    tier: 'Tier',
+    detected: 'Detectados',
+    categories: 'Categorías',
+    tools: 'Herramientas',
+    technologies: 'Tecnologías',
+    agents: 'Agentes',
+    mcp: 'Servidores MCP',
+    activity: 'Actividad',
+    sessions: 'Sesiones',
+    subagentRuns: 'Ejecuciones de subagentes',
+    activeHours: 'Horas activas',
+    crossToolLinks: 'Enlaces entre herramientas',
+    filesTouched: 'Ficheros tocados',
+    bashCommands: 'Comandos de shell',
+    planningSignals: 'Señales de planificación',
+    commits: 'Commits propios',
+    steering: 'Correcciones/steering',
+    decisions: 'Decisiones deliberadas',
+    fluency: 'Nivel de fluidez con IA',
+    interaction: 'Nivel de interacción (prompting)',
+    veracity: 'veracidad',
+    generatedAt: 'Generado',
+    none: '(ninguno)',
+    notEvaluated: '(sin evaluar todavía)',
+  },
+  en: {
+    title: 'AI usage report (stored)',
+    platform: 'Platform',
+    level: 'Level',
+    score: 'Score',
+    tier: 'Tier',
+    detected: 'Detected',
+    categories: 'Categories',
+    tools: 'Tools',
+    technologies: 'Technologies',
+    agents: 'Agents',
+    mcp: 'MCP servers',
+    activity: 'Activity',
+    sessions: 'Sessions',
+    subagentRuns: 'Subagent runs',
+    activeHours: 'Active hours',
+    crossToolLinks: 'Cross-tool links',
+    filesTouched: 'Files touched',
+    bashCommands: 'Shell commands',
+    planningSignals: 'Planning signals',
+    commits: 'Your commits',
+    steering: 'Steering/corrections',
+    decisions: 'Deliberate decisions',
+    fluency: 'AI fluency level',
+    interaction: 'Interaction (prompting) level',
+    veracity: 'veracity',
+    generatedAt: 'Generated',
+    none: '(none)',
+    notEvaluated: '(not evaluated yet)',
+  },
+};
+
+function line(out, label, value) {
+  out.push(`  ${label}: ${value}`);
+}
+
+function agentName(a) {
+  if (!a || typeof a !== 'object') return null;
+  const name = typeof a.name === 'string' ? a.name : null;
+  if (!name) return null;
+  const role = typeof a.role === 'string' && a.role ? ` — ${a.role}` : '';
+  return `${name}${role}`;
+}
+
+function evaluationText(evaluation, L) {
+  if (!evaluation || typeof evaluation !== 'object' || !evaluation.level) {
+    return L.notEvaluated;
+  }
+  const veracity = evaluation.veracity ? ` (${L.veracity}: ${evaluation.veracity})` : '';
+  return `${evaluation.level}${veracity}`;
+}
+
+function renderUsageReportText(view, { lang = 'en' } = {}) {
+  const L = LABELS[lang] || LABELS.en;
+  const report = view && view.report ? view.report : null;
+  const out = [];
+  out.push('');
+  out.push(`  ${L.title}`);
+  out.push('');
+
+  if (report) {
+    const levelName = typeof report.levelName === 'string' ? report.levelName : '';
+    line(out, L.platform, report.platform || '');
+    line(out, L.level, levelName ? `${levelName} (${report.level})` : `${report.level}`);
+    line(out, L.score, `${report.score}`);
+    line(out, L.tier, report.tierKey ? `${report.tierKey}` : `${report.tier ?? '-'}`);
+    line(out, L.detected, `${report.totalDetected}`);
+    line(out, L.categories, Array.isArray(report.categories) && report.categories.length ? report.categories.join(', ') : L.none);
+
+    const toolCount = detectedTools(report.tools).length;
+    line(out, L.tools, `${toolCount}`);
+
+    const techs = Array.isArray(report.technologies) ? report.technologies : [];
+    line(out, L.technologies, techs.length ? techs.join(', ') : L.none);
+
+    const mcpCount = report.mcp && typeof report.mcp.count === 'number' ? report.mcp.count : 0;
+    line(out, L.mcp, `${mcpCount}`);
+
+    out.push('');
+    out.push(`  ${L.agents}:`);
+    const agents = Array.isArray(report.agents) ? report.agents.map(agentName).filter(Boolean) : [];
+    if (agents.length) {
+      for (const a of agents) out.push(`    - ${a}`);
+    } else {
+      out.push(`    ${L.none}`);
+    }
+
+    out.push('');
+    out.push(`  ${L.activity}:`);
+    const s = report.sessions;
+    if (s && typeof s === 'object') {
+      line(out, `  ${L.sessions}`, `${s.sessionCount}`);
+      line(out, `  ${L.subagentRuns}`, `${s.subagentRunCount ?? 0}`);
+      line(out, `  ${L.activeHours}`, `${s.activeHours ?? 0}`);
+      line(out, `  ${L.crossToolLinks}`, `${s.crossToolLinks}`);
+      line(out, `  ${L.filesTouched}`, `${s.filesTouchedCount}`);
+      line(out, `  ${L.bashCommands}`, `${s.bashCommandsCount}`);
+      line(out, `  ${L.planningSignals}`, `${s.planningSignalCount ?? 0}`);
+    }
+    const git = report.gitActivity;
+    if (git && typeof git === 'object') {
+      line(out, `  ${L.commits}`, `${git.authoredCommitCount ?? 0}`);
+    }
+    line(out, `  ${L.steering}`, `${report.steeringTraceCount ?? 0}`);
+    line(out, `  ${L.decisions}`, `${report.decisionExchangeCount ?? 0}`);
+  }
+
+  out.push('');
+  line(out, L.fluency, evaluationText(view && view.fluency, L));
+  line(out, L.interaction, evaluationText(view && view.interactionQuality, L));
+
+  if (report && report.generatedAt) {
+    out.push('');
+    line(out, L.generatedAt, report.generatedAt);
+  }
+  out.push('');
+  return `${out.join('\n')}\n`;
+}
+
+module.exports = { renderUsageReportText };

package/src/repo-context.js

@@ -0,0 +1,215 @@
+'use strict';
+
+// repo-context.js — collect a COMPACT, content-free structural context of a codebase for the LLM analysis that builds the LOCAL report's graph (`map`).
+
+const fs = require('fs');
+const path = require('path');
+const { scrubString } = require('./graph-generator');
+const { modelNode } = require('./graph-scan'); // exact-model resolver (aliases → exact ids)
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.turbo', 'vendor', '__snapshots__', '__tests__', '__mocks__', 'test', 'tests', 'e2e']);
+const CODE_EXT = new Set(['.ts', '.js', '.tsx', '.jsx', '.mjs', '.cts', '.mts']);
+const SKIP_FILE_RE = /\.(spec|test|e2e-spec|d)\.[tj]sx?$/;
+const MAX_FILES = 6000;
+const MAX_READ = 700;
+const MAX_BYTES_PER = 200 * 1024;
+const LINE_MAX = 160;
+const CAP = { entrypoints: 12, crons: 18, agents: 30, integrations: 20, stores: 12, services: 40, tech: 60 };
+
+const AI_RE = /generateText|streamText|generateObject|streamObject|embedMany|tool\s*\(|@ai-sdk\/|from\s+['"]ai['"]|new\s+OpenAI|new\s+Anthropic|@anthropic-ai\/sdk|GoogleGenerativeAI|@google\/(?:genai|generative-ai)|Gemini\w*Service|Anthropic\w*Service|ShakersAi\w*|\.sendMessage\(|\.messages\.create\(|\.chat\.completions\.create\(|\.generateContent\(|\.responses\.create\(|ChatOpenAI|langchain|llamaindex|createAgent|AgentExecutor/;
+const CRON_RE = /@Cron\b|CronExpression|new\s+CronJob|EVERY_(MINUTE|HOUR|DAY)/;
+const CRON_PATH_RE = /(\.cron\.[tj]s$|(^|\/)cron-jobs?\/|(^|\/)crons?\/)/i;
+const ENTRY_PATH_RE = /(controller|\.route|router|webhook|gateway|resolver|main\.[tj]s|(^|\/)cli\/|(^|\/)commands?\/)/i;
+const IMPORT_RE = /^\s*(import\b|const\b.*=\s*require\()/;
+
+// npm import substring -> integration/provider label
+const INTEG = [
+  [/stripe/i, 'Stripe'], [/hubspot/i, 'HubSpot'], [/(datadog|dd-trace)/i, 'Datadog'],
+  [/twilio/i, 'Twilio'], [/(sendgrid|@sendgrid)/i, 'SendGrid'], [/(@slack|slack-)/i, 'Slack'],
+  [/(bigquery|@google-cloud\/bigquery)/i, 'BigQuery'], [/holded/i, 'Holded'], [/adobe/i, 'Adobe PDF'],
+  [/n8n/i, 'n8n'], [/cloudfront/i, 'CloudFront'], [/(mongoose|mongodb)/i, 'MongoDB'],
+  [/(ioredis|['"]redis['"])/i, 'Redis'], [/@aws-sdk|aws-sdk/i, 'AWS'],
+];
+// integrations/<dir> -> label (a dir under any `integrations/` path = a wired service)
+const INTEG_DIR = {
+  hubspot: 'HubSpot', holded: 'Holded', slack: 'Slack', datadog: 'Datadog', bigquery: 'BigQuery',
+  adobe: 'Adobe PDF', 'adobe-pdf': 'Adobe PDF', n8n: 'n8n', cloudfront: 'CloudFront', s3: 'AWS S3',
+  stripe: 'Stripe', match: 'calc-match', 'shakers-ai': 'shakers-ai-api', 'sh-ai': 'shakers-ai-api',
+  twilio: 'Twilio', sendgrid: 'SendGrid',
+};
+const MODEL_DIRS = new Set(['gemini', 'anthropic', 'openai']); // integration dirs that are MODELS, not externals
+
+function slug(s) { return String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'x'; }
+function clip(s) { s = String(s || '').trim(); return s.length > LINE_MAX ? s.slice(0, LINE_MAX) + '…' : s; }
+function titleize(s) { return String(s || '').replace(/[-_]+/g, ' ').replace(/\.(service|controller|cron|module)$/i, '').trim().replace(/\b\w/g, (c) => c.toUpperCase()).slice(0, 40); }
+function readSafe(p) { try { const st = fs.statSync(p); if (st.size > MAX_BYTES_PER) return null; return fs.readFileSync(p, 'utf8'); } catch { return null; } }
+
+function providerFromLine(line) {
+  const l = String(line || '').toLowerCase();
+  if (/gemini|generatecontent|google.*genai|generativeai/.test(l)) return { label: 'Gemini', domain: 'gemini.google.com' };
+  if (/anthropic|claude|messages\.create/.test(l)) return { label: 'Claude', domain: 'claude.ai' };
+  if (/openai|chat\.completions|responses\.create|\bgpt\b/.test(l)) return { label: 'OpenAI', domain: 'openai.com' };
+  if (/shakersai|sh_ai|shakers-ai|chatgpt/.test(l)) return { label: 'shakers-ai-api', domain: null };
+  return null;
+}
+
+function walk(root) {
+  const files = [];
+  const stack = [root];
+  while (stack.length && files.length < MAX_FILES) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (files.length >= MAX_FILES) break;
+      if (e.name.startsWith('.') && e.name !== '.claude') continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) stack.push(full); }
+      else if (CODE_EXT.has(path.extname(e.name)) && !SKIP_FILE_RE.test(e.name)) files.push(full);
+    }
+  }
+  return files;
+}
+
+function entryGroup(rel) {
+  const p = rel.toLowerCase();
+  const app = (p.match(/(?:^|\/)apps\/([^/]+)\//) || [])[1];
+  if (app) return { key: 'app:' + app, label: titleize(app) + ' API', sub: `apps/${app}` };
+  const integ = (p.match(/(?:^|\/)integrations\/([^/]+)\/.*(webhook|controller)/) || [])[1];
+  if (integ) return { key: 'wh:' + integ, label: titleize(integ) + ' webhook', sub: 'inbound webhook' };
+  if (/gateway|websocket|\bws\b/.test(p)) return { key: 'ws', label: 'WebSocket gateway', sub: 'realtime' };
+  if (/(^|\/)cli\/|(^|\/)commands?\//.test(p)) return { key: 'cli', label: 'CLI', sub: 'commands' };
+  if (/main\.[tj]s$/.test(p)) return { key: 'http', label: 'HTTP server', sub: 'main' };
+  if (/webhook/.test(p)) return { key: 'wh', label: 'Webhook', sub: 'inbound' };
+  return { key: 'ctrl', label: 'HTTP API', sub: 'controllers' };
+}
+
+function collectRepoContext(root, { readFileImpl = readSafe } = {}) {
+  const abs = path.resolve(root || process.cwd());
+  const rel = (p) => path.relative(abs, p) || path.basename(p);
+
+  const ctx = {
+    project: { name: scrubString(path.basename(abs) || 'project'), slug: slug(path.basename(abs)), date: new Date().toISOString().slice(0, 10) },
+    entrypoints: [], crons: [], agents: [], services: [], models: [], integrations: [], stores: [], technologies: [],
+  };
+  const integrationSet = new Set();
+  const modelSet = new Map();
+  const storeSet = new Set();
+  const serviceSet = new Set();
+  const entryGroups = new Map();
+  const cronFiles = new Set();
+  const aiFiles = new Map(); // path -> { provider, line }
+
+  const pkgRaw = readFileImpl(path.join(abs, 'package.json'));
+  if (pkgRaw) {
+    try {
+      const pkg = JSON.parse(pkgRaw);
+      if (pkg.name) { const nm = pkg.name.replace(/^@[^/]+\//, ''); ctx.project.name = scrubString(nm); ctx.project.slug = slug(nm); }
+      if (pkg.description) ctx.project.tagline = scrubString(clip(pkg.description));
+      ctx.technologies = Object.keys({ ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }).slice(0, CAP.tech).map(scrubString);
+    } catch { /* ignore */ }
+  }
+
+  // Prisma stores (datasource provider). schema.prisma OR prisma/schema/ dir.
+  const eatPrisma = (raw) => {
+    if (!raw) return;
+    const provider = (raw.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*"([^"]+)"/m) || [])[1];
+    if (provider) storeSet.add(provider === 'postgresql' ? 'PostgreSQL' : titleize(provider));
+  };
+  for (const cand of ['prisma/schema.prisma', 'schema.prisma']) { const r = readFileImpl(path.join(abs, cand)); if (r) { eatPrisma(r); break; } }
+  for (const dir of ['prisma/schema', 'prisma']) {
+    const d = path.join(abs, dir);
+    try { if (fs.statSync(d).isDirectory()) for (const f of fs.readdirSync(d)) if (f.endsWith('.prisma')) eatPrisma(readFileImpl(path.join(d, f))); } catch { /* none */ }
+  }
+
+  try {
+    for (const f of fs.readdirSync(path.join(abs, '.claude', 'agents'))) {
+      if (!f.endsWith('.md')) continue;
+      const raw = readFileImpl(path.join(abs, '.claude', 'agents', f)) || '';
+      const mm = raw.match(/^\s*model\s*:\s*["']?([^"'\n]+?)["']?\s*$/im);
+      const mn = mm ? modelNode(mm[1].trim()) : null;
+      const provider = mn ? mn.label : null;
+      if (mn) modelSet.set(mn.label, { label: mn.label, ...(mn.domain ? { domain: mn.domain } : {}) });
+      ctx.agents.push({ label: titleize(path.basename(f, '.md')), provider, path: scrubString(`.claude/agents/${f}`) });
+    }
+  } catch { /* none */ }
+
+  // scan code files — AI/flow-likely first
+  const score = (p) => {
+    if (/(gemini|openai|anthropic|claude|ai-footprint|\bai\b|\/ai[-/]|llm|agent|orchestrat|generate-|chat|embed|personaliz|translat|synthes|certif|recomm|summar|extract|classif|briefing|showcase)/i.test(p)) return 0;
+    if (/(\.service\.|controller|\.cron|worker|queue|webhook|gateway|resolver|handler|integrations\/)/i.test(p)) return 1;
+    return 2;
+  };
+  const files = walk(abs).sort((a, b) => score(rel(a)) - score(rel(b)));
+  let readCount = 0;
+  for (const f of files) {
+    const r = rel(f);
+    // integration dirs → externals or models (KNOWN dirs only, to avoid noise
+    // from generic subdirs like ai/chat/http/config)
+    const idir = (r.match(/(?:^|\/)integrations\/([^/]+)\//) || [])[1];
+    if (idir) {
+      const key = idir.toLowerCase();
+      if (MODEL_DIRS.has(key)) { const pv = providerFromLine(key); if (pv) modelSet.set(pv.label, pv); }
+      else if (INTEG_DIR[key]) integrationSet.add(INTEG_DIR[key]);
+    }
+    // module/service dirs
+    const mod = (r.match(/(?:^|\/)modules\/([^/]+)\//) || [])[1];
+    if (mod && !/^(prisma|mongo|base-http|response|counter|shared|common|health)$/i.test(mod)) serviceSet.add(mod);
+    // datastore hints from path/libs
+    if (/aws-sdk\/client-s3|(^|\/)s3\b/i.test(r)) storeSet.add('AWS S3');
+    if (/cloudfront/i.test(r)) storeSet.add('CloudFront KVS');
+    // entrypoints (grouped)
+    if (ENTRY_PATH_RE.test(r) && !CRON_PATH_RE.test(r)) { const g = entryGroup(r); if (!entryGroups.has(g.key)) entryGroups.set(g.key, g); }
+    // crons (per file, by path)
+    if (CRON_PATH_RE.test(r)) cronFiles.add(r);
+
+    if (readCount >= MAX_READ) continue;
+    const src = readFileImpl(f);
+    if (src == null) continue;
+    readCount++;
+    const lines = src.split('\n');
+    let firstAi = null;
+    for (const ln of lines) {
+      if (!firstAi && AI_RE.test(ln)) firstAi = ln;
+      if (CRON_RE.test(ln)) cronFiles.add(r);
+      if (IMPORT_RE.test(ln)) {
+        for (const [re, label] of INTEG) if (re.test(ln)) {
+          if (/mongo/i.test(label)) storeSet.add('MongoDB');
+          else if (/redis/i.test(label)) storeSet.add('Redis');
+          else if (label === 'AWS') storeSet.add('AWS S3');
+          else integrationSet.add(label);
+        }
+        const pv = providerFromLine(ln);
+        if (pv && pv.domain) modelSet.set(pv.label, pv);
+      }
+    }
+    if (firstAi) aiFiles.set(r, { provider: providerFromLine(firstAi), line: clip(firstAi) });
+  }
+
+  const AGENT_SKIP_DIR = /^(gemini|anthropic|openai|http|base-http|event|config|util|shared|common|prisma|mongo|health|logger|integrations)$/i;
+  for (const [p, info] of aiFiles) {
+    if (ctx.agents.length >= CAP.agents) break;
+    if (/(?:^|\/)integrations\//.test(p)) { // the provider client, not an agent
+      if (info.provider && info.provider.domain) modelSet.set(info.provider.label, info.provider);
+      continue;
+    }
+    const dir = p.split('/').slice(-2, -1)[0] || path.basename(p);
+    if (AGENT_SKIP_DIR.test(dir)) continue;
+    ctx.agents.push({ label: titleize(dir), provider: info.provider ? info.provider.label : null, path: scrubString(p) });
+    if (info.provider && info.provider.domain) modelSet.set(info.provider.label, info.provider);
+    else if (info.provider) integrationSet.add(info.provider.label); // shakers-ai-api = external tool
+  }
+  const hasApp = [...entryGroups.keys()].some((k) => k.startsWith('app:'));
+  const hasNamedWebhook = [...entryGroups.keys()].some((k) => k.startsWith('wh:'));
+  if (hasApp) { entryGroups.delete('ctrl'); entryGroups.delete('http'); }
+  if (hasNamedWebhook) entryGroups.delete('wh');
+  ctx.entrypoints = Array.from(entryGroups.values()).slice(0, CAP.entrypoints).map((g) => ({ label: g.label, sub: g.sub }));
+  ctx.crons = Array.from(cronFiles).slice(0, CAP.crons).map((p) => ({ label: titleize(path.basename(p).replace(/\.(cron\.)?[tj]s$/, '')), path: scrubString(p) }));
+  ctx.services = Array.from(serviceSet).slice(0, CAP.services).map((m) => titleize(m));
+  ctx.models = Array.from(modelSet.values());
+  ctx.integrations = Array.from(integrationSet).slice(0, CAP.integrations);
+  ctx.stores = Array.from(storeSet).slice(0, CAP.stores);
+  return ctx;
+}
+
+module.exports = { collectRepoContext, slug };

package/src/report-gating.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { loadAuthSession, sessionStatus, isPlatformTalent } = require('./auth-session-store');
+const { getProfile } = require('./config');
+
+// THE ONE LAYER THAT DECIDES WHAT THE REPORT SHOWS ACCORDING TO IDENTITY (talents-ai-score, issue 123 / ADR-044).
+
+// Pure: identity in, policy out.
+function resolveReportGate({ loggedIn = false, status = null, email = null, userType = null, profile = 'talent' } = {}) {
+  const showEverything = !loggedIn;
+  const resolvedProfile = profile === 'external' ? 'external' : 'talent';
+  return Object.freeze({
+    loggedIn: !!loggedIn,
+    profile: resolvedProfile,
+    sessionStatus: status,
+    email: loggedIn && typeof email === 'string' && email ? email : null,
+    // --roadmap AND its server-side computation/egress (see bin/report.js): a
+    // logged-in Talent's roadmap is not merely hidden, it is not requested.
+    showRoadmap: showEverything,
+    // Per-agent "how to improve this agent" tips in the footprint report.
+    showAgentSuggestions: showEverything,
+    // The copyable remediation prompt in a `certify` verdict.
+    showCertifyRemediation: showEverything,
+    showFrameworkIntro: resolvedProfile === 'talent' && loggedIn && isPlatformTalent({ userType }),
+  });
+}
+
+// The general-user policy, used when a renderer is called without a gate. Frozen
+// and shared so callers cannot accidentally mutate the default for everyone.
+const DEFAULT_REPORT_GATE = resolveReportGate({ loggedIn: false });
+
+// Reads the auth session and resolves the policy.
+function reportGateForIdentity(env = process.env, now = Date.now()) {
+  const session = loadAuthSession(env);
+  const status = sessionStatus(session, now);
+  return resolveReportGate({
+    loggedIn: status === 'active',
+    status,
+    email: session ? session.email : null,
+    userType: session ? session.userType : null,
+    profile: getProfile(env),
+  });
+}
+
+module.exports = {
+  resolveReportGate,
+  reportGateForIdentity,
+  DEFAULT_REPORT_GATE,
+};