@jaimevalasek/aioson 1.4.0 → 1.5.1

package/src/commands/squad-processes.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const path = require('node:path');
+const { getActiveProcesses, stopProcess, stopSquadProcesses } = require('../squad-dashboard/process-monitor');
+
+function formatElapsed(seconds) {
+  if (seconds == null) return '-';
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m${seconds % 60}s`;
+  return `${Math.floor(seconds / 3600)}h${Math.floor((seconds % 3600) / 60)}m`;
+}
+
+async function runSquadProcesses({ args, options, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadFilter = options.squad || null;
+
+  // --stop <pid>
+  if (options.stop && options.stop !== true) {
+    const result = await stopProcess(projectDir, options.stop);
+    if (result.ok) {
+      logger.log(`Process ${options.stop} stopped.`);
+    } else {
+      logger.error(`Failed to stop ${options.stop}: ${result.error}`);
+    }
+    return result;
+  }
+
+  // --stop-squad <squad>
+  if (options['stop-squad']) {
+    const slug = options['stop-squad'];
+    const results = await stopSquadProcesses(projectDir, slug);
+    const stopped = results.filter(r => r.ok).length;
+    logger.log(`Stopped ${stopped}/${results.length} processes for squad "${slug}".`);
+    return { ok: true, results };
+  }
+
+  // List
+  const processes = await getActiveProcesses(projectDir, squadFilter);
+  if (processes.length === 0) {
+    logger.log(squadFilter ? `No active processes for squad "${squadFilter}".` : 'No active processes.');
+    return { ok: true, processes: [] };
+  }
+
+  logger.log(`Active processes (${processes.length}):`);
+  for (const proc of processes) {
+    const status = proc.alive ? '[*]' : '[ ]';
+    const elapsed = formatElapsed(proc.elapsedSeconds);
+    const ctx = proc.contextPct != null ? ` ctx:${proc.contextPct}%` : '';
+    const url = proc.url ? `  ${proc.url}` : '';
+    logger.log(`  ${status} [${proc.squadSlug}] ${proc.agentSlug}  pid:${proc.pid}  elapsed:${elapsed}${ctx}${url}`);
+  }
+
+  return { ok: true, processes };
+}
+
+module.exports = { runSquadProcesses };

package/src/commands/squad-recovery.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const path = require('node:path');
+const { generateRecovery, readRecovery } = require('../squad/recovery-context');
+
+/**
+ * aioson squad:recovery <project> --squad <squad> --agent <agent> [--show]
+ *
+ * Generates (or re-generates) the recovery-context.md for an agent.
+ * --show: print the generated content to stdout instead of just confirming.
+ */
+async function runSquadRecovery({ args, options, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = options.squad || args[1];
+  const agentSlug = options.agent || args[2];
+
+  if (!squadSlug || !agentSlug) {
+    logger.error('Usage: aioson squad:recovery <project> --squad <squad> --agent <agent> [--show]');
+    return { ok: false };
+  }
+
+  const result = await generateRecovery(projectDir, squadSlug, agentSlug);
+
+  if (!result.ok) {
+    logger.error(`Failed to generate recovery context: ${result.error}`);
+    return result;
+  }
+
+  logger.log(`Recovery context generated: ${result.path} (~${result.tokens} tokens)`);
+
+  if (options.show) {
+    const content = await readRecovery(projectDir, squadSlug);
+    if (content) {
+      logger.log('');
+      logger.log(content);
+    }
+  }
+
+  return result;
+}
+
+module.exports = { runSquadRecovery };

package/src/commands/squad-roi.js

@@ -0,0 +1,291 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  upsertSquadMetric,
+  listSquadMetrics,
+  upsertROIConfig,
+  getROIConfig
+} = require('../runtime-store');
+
+async function runSquadRoi({ args, options, logger, t }) {
+  const projectDir = path.resolve(args[0] || options.path || '.');
+  const squadSlug = options.squad;
+  const sub = options.sub || 'report';
+
+  if (!squadSlug) {
+    logger.log(t('squad_roi.squad_required'));
+    return { ok: false, error: 'squad_required' };
+  }
+
+  if (sub === 'config') {
+    return handleConfig({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'metric') {
+    return handleMetric({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'report') {
+    return handleReport({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'export') {
+    return handleExport({ projectDir, squadSlug, options, logger, t });
+  }
+
+  logger.log(t('squad_roi.unknown_sub', { sub }));
+  return { ok: false, error: 'unknown_sub' };
+}
+
+async function handleConfig({ projectDir, squadSlug, options, logger, t }) {
+  const handle = await openRuntimeDb(projectDir);
+
+  upsertROIConfig(handle.db, {
+    squadSlug,
+    pricingModel: options.pricing || options.pricing_model,
+    setupFee: options.setup ? parseFloat(options.setup) : undefined,
+    monthlyFee: options.monthly ? parseFloat(options.monthly) : undefined,
+    percentageFee: options.percentage ? parseFloat(options.percentage) : undefined,
+    percentageBase: options.base,
+    currency: options.currency,
+    contractMonths: options.months ? parseInt(options.months, 10) : undefined
+  });
+
+  const config = getROIConfig(handle.db, squadSlug);
+  handle.db.close();
+
+  logger.log(t('squad_roi.config_saved', { squad: squadSlug }));
+  logger.log(`  ${t('squad_roi.pricing_model')}: ${config.pricing_model}`);
+  if (config.setup_fee) logger.log(`  ${t('squad_roi.setup_fee')}: ${config.currency} ${config.setup_fee}`);
+  if (config.monthly_fee) logger.log(`  ${t('squad_roi.monthly_fee')}: ${config.currency} ${config.monthly_fee}`);
+  if (config.percentage_fee) logger.log(`  ${t('squad_roi.percentage')}: ${config.percentage_fee}% (${config.percentage_base || 'n/a'})`);
+  logger.log(`  ${t('squad_roi.contract')}: ${config.contract_months} months`);
+
+  return { ok: true, config };
+}
+
+async function handleMetric({ projectDir, squadSlug, options, logger, t }) {
+  const key = options.key;
+  const value = options.value;
+  const period = options.period;
+
+  if (!key || value === undefined) {
+    logger.log(t('squad_roi.metric_required'));
+    return { ok: false, error: 'metric_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir);
+  upsertSquadMetric(handle.db, {
+    squadSlug,
+    metricKey: key,
+    value: parseFloat(value),
+    unit: options.unit || null,
+    period: period || null,
+    baseline: options.baseline ? parseFloat(options.baseline) : null,
+    target: options.target ? parseFloat(options.target) : null,
+    source: options.source || 'manual',
+    notes: options.notes || null
+  });
+  handle.db.close();
+
+  logger.log(t('squad_roi.metric_saved', { key, value, squad: squadSlug }));
+  return { ok: true, key, value: parseFloat(value), period };
+}
+
+function calculateROI(metrics, config) {
+  if (!config) return null;
+
+  const improvements = [];
+  for (const m of metrics) {
+    if (m.baseline === null || m.baseline === undefined) continue;
+    const improvement = m.baseline - m.metric_value;
+    improvements.push({
+      key: m.metric_key,
+      baseline: m.baseline,
+      actual: m.metric_value,
+      target: m.target,
+      improvement,
+      unit: m.metric_unit,
+      period: m.period
+    });
+  }
+
+  const monthlyCost = (config.monthly_fee || 0) + ((config.setup_fee || 0) / (config.contract_months || 12));
+
+  return {
+    improvements,
+    monthly_cost: monthlyCost,
+    pricing: {
+      model: config.pricing_model,
+      setup_fee: config.setup_fee,
+      monthly_fee: config.monthly_fee,
+      percentage_fee: config.percentage_fee,
+      currency: config.currency
+    }
+  };
+}
+
+async function handleReport({ projectDir, squadSlug, options, logger, t }) {
+  const handle = await openRuntimeDb(projectDir);
+  const config = getROIConfig(handle.db, squadSlug);
+  const metrics = listSquadMetrics(handle.db, squadSlug);
+  handle.db.close();
+
+  if (metrics.length === 0) {
+    logger.log(t('squad_roi.no_metrics', { squad: squadSlug }));
+    return { ok: true, metrics: [], roi: null };
+  }
+
+  const period = options.period || null;
+  const filtered = period ? metrics.filter(m => m.period === period) : metrics;
+
+  logger.log(t('squad_roi.report_title', { squad: squadSlug }));
+  logger.log('');
+
+  // Group by metric_key
+  const byKey = {};
+  for (const m of filtered) {
+    if (!byKey[m.metric_key]) byKey[m.metric_key] = [];
+    byKey[m.metric_key].push(m);
+  }
+
+  for (const [key, entries] of Object.entries(byKey)) {
+    const latest = entries[entries.length - 1];
+    logger.log(`  ${key}`);
+    if (latest.baseline !== null) {
+      logger.log(`    ${t('squad_roi.baseline')}: ${latest.baseline}${latest.metric_unit || ''}`);
+    }
+    logger.log(`    ${t('squad_roi.actual')}: ${latest.metric_value}${latest.metric_unit || ''}`);
+    if (latest.target !== null) {
+      logger.log(`    ${t('squad_roi.target')}: ${latest.target}${latest.metric_unit || ''}`);
+      // Progress bar
+      if (latest.baseline !== null && latest.baseline !== latest.target) {
+        const totalGap = Math.abs(latest.baseline - latest.target);
+        const achieved = Math.abs(latest.baseline - latest.metric_value);
+        const pct = Math.min(100, Math.round((achieved / totalGap) * 100));
+        const filled = Math.round(pct / 5);
+        const bar = '#'.repeat(filled) + '.'.repeat(20 - filled);
+        logger.log(`    [${bar}] ${pct}%`);
+      }
+    }
+    if (latest.period) {
+      logger.log(`    ${t('squad_roi.period')}: ${latest.period}`);
+    }
+    logger.log('');
+  }
+
+  const roi = calculateROI(filtered, config);
+  if (roi && config) {
+    logger.log(t('squad_roi.cost_section'));
+    logger.log(`  ${t('squad_roi.monthly_cost')}: ${config.currency} ${roi.monthly_cost.toFixed(2)}`);
+  }
+
+  return { ok: true, metrics: filtered, roi };
+}
+
+function renderReportHtml(squadSlug, metrics, config) {
+  const roi = calculateROI(metrics, config);
+  const currency = (config && config.currency) || 'BRL';
+
+  const byKey = {};
+  for (const m of metrics) {
+    if (!byKey[m.metric_key]) byKey[m.metric_key] = [];
+    byKey[m.metric_key].push(m);
+  }
+
+  const metricsHtml = Object.entries(byKey).map(([key, entries]) => {
+    const latest = entries[entries.length - 1];
+    let progressBar = '';
+    if (latest.baseline !== null && latest.target !== null && latest.baseline !== latest.target) {
+      const totalGap = Math.abs(latest.baseline - latest.target);
+      const achieved = Math.abs(latest.baseline - latest.metric_value);
+      const pct = Math.min(100, Math.round((achieved / totalGap) * 100));
+      progressBar = `<div style="background:#333;border-radius:4px;overflow:hidden;height:8px;margin-top:4px">
+        <div style="background:#4ade80;height:100%;width:${pct}%"></div>
+      </div><small>${pct}% of target</small>`;
+    }
+    return `<div style="background:#1e1e2e;padding:16px;border-radius:8px;margin-bottom:12px">
+      <h3 style="margin:0 0 8px">${esc(key)}</h3>
+      ${latest.baseline !== null ? `<p>Baseline: <strong>${latest.baseline}${latest.metric_unit || ''}</strong></p>` : ''}
+      <p>Current: <strong>${latest.metric_value}${latest.metric_unit || ''}</strong></p>
+      ${latest.target !== null ? `<p>Target: <strong>${latest.target}${latest.metric_unit || ''}</strong></p>` : ''}
+      ${progressBar}
+      ${latest.period ? `<small>Period: ${esc(latest.period)}</small>` : ''}
+    </div>`;
+  }).join('\n');
+
+  const costHtml = roi && config ? `
+    <div style="background:#1e1e2e;padding:16px;border-radius:8px;margin-top:16px">
+      <h3>Cost Summary</h3>
+      <p>Pricing: ${esc(config.pricing_model)}</p>
+      ${config.setup_fee ? `<p>Setup: ${currency} ${config.setup_fee}</p>` : ''}
+      ${config.monthly_fee ? `<p>Monthly: ${currency} ${config.monthly_fee}</p>` : ''}
+      <p>Monthly effective cost: <strong>${currency} ${roi.monthly_cost.toFixed(2)}</strong></p>
+    </div>` : '';
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>ROI Report — ${esc(squadSlug)}</title>
+<style>
+  body{font-family:system-ui,sans-serif;background:#0d1117;color:#e6edf3;margin:0;padding:24px}
+  .container{max-width:720px;margin:0 auto}
+  h1{border-bottom:1px solid #30363d;padding-bottom:12px}
+  h3{color:#58a6ff}
+  p{margin:4px 0}
+  small{color:#8b949e}
+</style>
+</head>
+<body>
+<div class="container">
+  <h1>ROI Report — ${esc(squadSlug)}</h1>
+  <p style="color:#8b949e">Generated: ${new Date().toISOString().slice(0, 10)}</p>
+  <h2>Metrics</h2>
+  ${metricsHtml}
+  ${costHtml}
+  <footer style="margin-top:32px;color:#8b949e;font-size:12px">
+    Generated by aioson squad:roi:export
+  </footer>
+</div>
+</body>
+</html>`;
+}
+
+function esc(str) {
+  if (!str) return '';
+  return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+async function handleExport({ projectDir, squadSlug, options, logger, t }) {
+  const format = options.format || 'html';
+  const handle = await openRuntimeDb(projectDir);
+  const config = getROIConfig(handle.db, squadSlug);
+  const metrics = listSquadMetrics(handle.db, squadSlug);
+  handle.db.close();
+
+  if (metrics.length === 0) {
+    logger.log(t('squad_roi.no_metrics', { squad: squadSlug }));
+    return { ok: true, exported: false };
+  }
+
+  const period = options.period || null;
+  const filtered = period ? metrics.filter(m => m.period === period) : metrics;
+
+  if (format === 'json') {
+    const roi = calculateROI(filtered, config);
+    const output = JSON.stringify({ squad: squadSlug, metrics: filtered, roi, config }, null, 2);
+    logger.log(output);
+    return { ok: true, exported: true, format: 'json' };
+  }
+
+  // HTML
+  const html = renderReportHtml(squadSlug, filtered, config);
+  const fs = require('node:fs/promises');
+  const outFile = options.output || `roi-report-${squadSlug}.html`;
+  await fs.writeFile(outFile, html);
+  logger.log(t('squad_roi.exported', { file: outFile, format: 'html' }));
+  return { ok: true, exported: true, format: 'html', file: outFile };
+}
+
+module.exports = { runSquadRoi, calculateROI, renderReportHtml, esc };

package/src/commands/squad-score.js

@@ -0,0 +1,250 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function readJsonIfExists(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch { return null; }
+}
+
+function scoreCompletude(manifest) {
+  let score = 0;
+  const details = {};
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+  const checklists = Array.isArray(manifest.checklists) ? manifest.checklists : [];
+
+  // Executors typed (5pts)
+  const allTyped = executors.length > 0 && executors.every(e => e.type);
+  if (allTyped) { score += 5; details.executorsTyped = true; }
+
+  // Workflow defined (5pts)
+  const hasWorkflow = workflows.some(w => Array.isArray(w.phases) && w.phases.length >= 2);
+  if (hasWorkflow) { score += 5; details.workflowDefined = true; }
+
+  // Checklists present (3pts)
+  if (checklists.length > 0) { score += 3; details.checklistsPresent = true; }
+
+  // Tasks decomposed (5pts)
+  const hasTask = executors.some(e => Array.isArray(e.tasks) && e.tasks.length > 0);
+  if (hasTask) { score += 5; details.tasksDecomposed = true; }
+
+  // Workers present (2pts)
+  const hasWorker = executors.some(e => e.type === 'worker' || e.usesLLM === false);
+  if (hasWorker) { score += 2; details.workersPresent = true; }
+
+  // Investigation report (3pts)
+  if (manifest._investigationPath) { score += 3; details.investigationReport = true; }
+
+  // Model tiering (2pts)
+  const allTiered = executors.length > 0 && executors.every(e => e.modelTier);
+  if (allTiered) { score += 2; details.modelTiering = true; }
+
+  return { score, max: 25, details };
+}
+
+function scoreProfundidade(manifest) {
+  let score = 0;
+  const details = {};
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+
+  // Executor focus areas avg >= 3 (5pts)
+  const focusCounts = executors.map(e => (Array.isArray(e.focus) ? e.focus : []).length);
+  const avgFocus = focusCounts.length > 0 ? focusCounts.reduce((a, b) => a + b, 0) / focusCounts.length : 0;
+  if (avgFocus >= 3) { score += 5; details.focusAreas = true; }
+
+  // Task quality criteria avg >= 3 (5pts)
+  const allTasks = executors.flatMap(e => Array.isArray(e.tasks) ? e.tasks : []);
+  if (allTasks.length > 0) { score += 5; details.taskCriteria = true; }
+
+  // Veto conditions (5pts)
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+  const hasVeto = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p =>
+      Array.isArray(p.vetoConditions) && p.vetoConditions.length > 0
+    )
+  );
+  if (hasVeto) { score += 5; details.vetoConditions = true; }
+
+  // Content blueprints with 3+ sections (5pts)
+  const blueprints = Array.isArray(manifest.contentBlueprints) ? manifest.contentBlueprints : [];
+  const hasBp = blueprints.some(bp => Array.isArray(bp.sections) && bp.sections.length >= 3);
+  if (hasBp) { score += 5; details.contentBlueprints = true; }
+
+  // Skills declared >= 2 (5pts)
+  const skills = Array.isArray(manifest.skills) ? manifest.skills : [];
+  if (skills.length >= 2) { score += 5; details.skillsDeclared = true; }
+
+  return { score, max: 25, details };
+}
+
+function scoreQualidadeEstrutural(manifest) {
+  let score = 0;
+  const details = {};
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+
+  // Review loops (5pts)
+  const hasReview = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p => p.review)
+  );
+  if (hasReview) { score += 5; details.reviewLoops = true; }
+
+  // Human gates (5pts)
+  const hasGate = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p => p.humanGate)
+  );
+  if (hasGate) { score += 5; details.humanGates = true; }
+
+  // Cross-squad awareness (3pts) — orchestrator mentions cross-squad
+  // Simplified: check if ports are defined
+  if (manifest.ports && (Array.isArray(manifest.ports.inputs) || Array.isArray(manifest.ports.outputs))) {
+    score += 3; details.crossSquad = true;
+  }
+
+  // Output strategy configured (4pts)
+  const os = manifest.outputStrategy;
+  if (os && os.mode && os.mode !== 'hybrid') { score += 4; details.outputStrategy = true; }
+  else if (os && os.mode === 'hybrid') { score += 4; details.outputStrategy = true; }
+
+  // Genome bindings (3pts)
+  const genomes = manifest.genomes;
+  const hasGenome = genomes && (
+    (Array.isArray(genomes) && genomes.length > 0) ||
+    (typeof genomes === 'object' && !Array.isArray(genomes))
+  );
+  if (hasGenome) { score += 3; details.genomeBindings = true; }
+
+  // Format references (5pts)
+  const hasFormat = executors.some(e => Array.isArray(e.formats) && e.formats.length > 0);
+  if (hasFormat) { score += 5; details.formatReferences = true; }
+
+  return { score, max: 25, details };
+}
+
+function scorePotencial(manifest) {
+  let score = 0;
+  const details = {};
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+
+  // Anti-pattern guards via veto conditions (5pts)
+  const hasVeto = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p =>
+      Array.isArray(p.vetoConditions) && p.vetoConditions.length > 0
+    )
+  );
+  if (hasVeto) { score += 5; details.antiPatternGuards = true; }
+
+  // Domain vocabulary — investigation (5pts)
+  if (manifest._investigationPath) { score += 5; details.domainVocabulary = true; }
+
+  // Structural patterns — content blueprints (5pts)
+  const blueprints = Array.isArray(manifest.contentBlueprints) ? manifest.contentBlueprints : [];
+  if (blueprints.length > 0) { score += 5; details.structuralPatterns = true; }
+
+  // Executor coherence + Output realism (10pts) → LLM-only, mark as partial
+  details.llmAssessmentPending = true;
+
+  return { score, max: 25, details };
+}
+
+function gradeFromScore(total) {
+  if (total >= 90) return 'S (Exceptional)';
+  if (total >= 80) return 'A (Excellent)';
+  if (total >= 70) return 'B (Good)';
+  if (total >= 50) return 'C (Adequate)';
+  return 'D (Needs work)';
+}
+
+function suggestQuickWins(d1, d2, d3, d4) {
+  const wins = [];
+  if (!d3.details.reviewLoops) wins.push({ action: 'Add review loop to a workflow phase', pts: 5 });
+  if (!d1.details.tasksDecomposed) wins.push({ action: 'Decompose at least 1 executor into tasks', pts: 5 });
+  if (!d3.details.formatReferences) wins.push({ action: 'Add a format reference to an executor', pts: 5 });
+  if (!d2.details.vetoConditions) wins.push({ action: 'Add veto conditions to a workflow phase', pts: 5 });
+  if (!d1.details.modelTiering) wins.push({ action: 'Assign modelTier to all executors', pts: 2 });
+  if (!d1.details.workersPresent) wins.push({ action: 'Add a worker executor (no LLM)', pts: 2 });
+  return wins.slice(0, 3);
+}
+
+async function runSquadScore({ args = [], options = {}, logger = console, translator } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.squad || args[1];
+
+  if (!slug) {
+    logger.error('Usage: aioson squad:score [path] --squad=<slug>');
+    return { valid: false, error: 'No slug provided' };
+  }
+
+  const manifestPath = path.join(projectDir, '.aioson', 'squads', slug, 'squad.manifest.json');
+  const manifest = await readJsonIfExists(manifestPath);
+
+  if (!manifest) {
+    logger.error(`Squad "${slug}" not found or invalid manifest`);
+    return { valid: false, error: 'Manifest not found' };
+  }
+
+  // Check for investigation
+  const squadSearchDir = path.join(projectDir, 'squad-searches', slug);
+  try {
+    await fs.access(squadSearchDir);
+    manifest._investigationPath = squadSearchDir;
+  } catch { /* no investigation */ }
+
+  const d1 = scoreCompletude(manifest);
+  const d2 = scoreProfundidade(manifest);
+  const d3 = scoreQualidadeEstrutural(manifest);
+  const d4 = scorePotencial(manifest);
+
+  const total = d1.score + d2.score + d3.score + d4.score;
+  const maxTotal = d1.max + d2.max + d3.max + d4.max;
+  const grade = gradeFromScore(total);
+  const wins = suggestQuickWins(d1, d2, d3, d4);
+
+  logger.log('');
+  logger.log(`  Squad: ${slug}`);
+  logger.log('');
+  logger.log(`  Completude:              ${String(d1.score).padStart(2)}/${d1.max}`);
+  logger.log(`  Profundidade:            ${String(d2.score).padStart(2)}/${d2.max}`);
+  logger.log(`  Qualidade Estrutural:    ${String(d3.score).padStart(2)}/${d3.max}`);
+  logger.log(`  Potencial de Resultado:  ${String(d4.score).padStart(2)}/${d4.max}*`);
+  logger.log(`  ${'─'.repeat(40)}`);
+  logger.log(`  TOTAL:                   ${String(total).padStart(2)}/${maxTotal}`);
+  logger.log(`  Grade: ${grade}`);
+  logger.log('');
+  logger.log('  * Dimensão 4 parcial (sem LLM assessment)');
+
+  if (wins.length > 0) {
+    logger.log('');
+    logger.log('  Quick wins:');
+    wins.forEach((w, i) => logger.log(`    ${i + 1}. ${w.action} → +${w.pts} pts`));
+  }
+
+  logger.log('');
+
+  // Store in runtime if available
+  try {
+    const { openRuntimeDb } = require('../runtime-store');
+    const { db } = openRuntimeDb(projectDir);
+    const now = new Date().toISOString();
+    const stmt = db.prepare('INSERT OR REPLACE INTO squad_scores (squad_slug, dimension, score, max_score, details_json, scored_at) VALUES (?, ?, ?, ?, ?, ?)');
+    stmt.run(slug, 'completude', d1.score, d1.max, JSON.stringify(d1.details), now);
+    stmt.run(slug, 'profundidade', d2.score, d2.max, JSON.stringify(d2.details), now);
+    stmt.run(slug, 'qualidade', d3.score, d3.max, JSON.stringify(d3.details), now);
+    stmt.run(slug, 'potencial', d4.score, d4.max, JSON.stringify(d4.details), now);
+  } catch { /* runtime not available */ }
+
+  return {
+    slug,
+    total,
+    max: maxTotal,
+    grade,
+    dimensions: { completude: d1, profundidade: d2, qualidade: d3, potencial: d4 },
+    quickWins: wins
+  };
+}
+
+module.exports = { runSquadScore, scoreCompletude, scoreProfundidade, scoreQualidadeEstrutural, scorePotencial, gradeFromScore };