@rosh100yx/outlier 0.4.25 → 0.10.2

package/src/cli.ts

@@ -5,6 +5,9 @@ import pc from 'picocolors';
 import { getAuthorshipStats } from './git';
 import { getCarbonStats } from './carbon';
 import { getCapabilitiesStats } from './capabilities';
+import { deriveInsights, type Insight } from './insights';
+import { projectEconomics } from './economics';
+import { aggregateDir } from './aggregate';
 import { writeFileSync, readFileSync, chmodSync, existsSync } from 'fs';
 import { join } from 'path';
 import { detectAgent } from './agent';
@@ -20,6 +23,110 @@ const ASCII_LOGO = `
 
 let finalReceipt = '';
 
+// Turn the left-rail receipt into a clean closed rectangle (adds the right border,
+// padding each line to a fixed inner width). Width-aware: strips ANSI and counts a few
+// known wide glyphs as 2 columns so the right edge lines up in a terminal and on GitHub.
+function closeBox(s: string, W = 66): string {
+  const wide = new Set(['⚠', '🛑', '✈', '🌱', '📸', '🔬', '💾', '💡', '✅', '❌', '😾', '😀']);
+  const chW = (ch: string) => { const cp = ch.codePointAt(0)!; return (cp >= 0x1F000 || wide.has(ch)) ? 2 : 1; };
+  const rail = '\x1b[2m│\x1b[0m';
+  // Fit a (possibly ANSI-coloured) line to exactly `totalVis` visible columns: pad with
+  // spaces, or truncate with an ellipsis — preserving colour codes either way.
+  const fit = (line: string, totalVis: number) => {
+    const parts = line.split(/(\x1b\[[0-9;]*m)/);
+    let out = '', vis = 0, cut = false;
+    for (const p of parts) {
+      if (/^\x1b\[/.test(p)) { out += p; continue; }
+      for (const ch of p) {
+        const w = chW(ch);
+        if (vis + w > totalVis - 1) { cut = true; break; }
+        out += ch; vis += w;
+      }
+      if (cut) break;
+    }
+    if (cut) { out += '…'; vis += 1; }
+    return out + ' '.repeat(Math.max(0, totalVis - vis)) + '\x1b[0m';
+  };
+  return s.split('\n').map(line => {
+    const plain = line.replace(/\x1b\[[0-9;]*m/g, '');
+    if (/^\s*┌/.test(plain)) return ' \x1b[2m┌' + '─'.repeat(W) + '┐\x1b[0m';
+    if (/^\s*├/.test(plain)) return ' \x1b[2m├' + '─'.repeat(W) + '┤\x1b[0m';
+    if (/^\s*└/.test(plain)) return ' \x1b[2m└' + '─'.repeat(W) + '┘\x1b[0m';
+    if (/^\s*│/.test(plain)) return fit(line, 2 + W) + rail; // 2 = leading space + left rail
+    return line;
+  }).join('\n');
+}
+
+// Build a stable, machine-readable audit object. This is the contract agents,
+// swarms, and CI parse — everything the human receipt shows, as plain JSON.
+async function emitJson() {
+  const pkg = require('../package.json');
+  const [gitStats, carbon, caps] = await Promise.all([
+    getAuthorshipStats().catch(() => null),
+    getCarbonStats().catch(() => null),
+    getCapabilitiesStats().catch(() => null),
+  ]);
+
+  const aiRatio = gitStats ? gitStats.ratio : 0;
+  const cap = 0.70;
+  const writeOrDeploy = caps
+    ? caps.mcps.filter((m: any) => ['money', 'exec', 'deploy', 'write-remote', 'write-local'].includes(m.reach)).length
+    : 0;
+
+  const out = {
+    tool: 'outlier',
+    version: pkg.version,
+    repo: process.cwd().split('/').pop(),
+    generatedAt: new Date().toISOString(),
+    localFirst: true,
+    authorship: gitStats ? {
+      aiPercent: +(gitStats.ratio * 100).toFixed(1),
+      aiRatio: gitStats.ratio,
+      totalCommits: gitStats.total,
+      aiCommits: gitStats.ai,
+      nonMergePercent: +(gitStats.ratioNoMerges * 100).toFixed(1),
+      provenance: 'proxy',
+      note: 'git Co-Authored-By trailers; under-counts if the agent omits the trailer',
+    } : null,
+    cost: carbon ? {
+      totalTokens: carbon.totalTokens,
+      outputTokens: carbon.outputTokens,
+      cacheReusePercent: carbon.totalTokens ? +((carbon.cacheReadTokens / carbon.totalTokens) * 100).toFixed(1) : 0,
+      estUsd: +carbon.estUsd.toFixed(2),
+      costIsReal: carbon.costIsReal,
+      provenance: carbon.tokenProvenance,
+      source: carbon.sourceLabel,
+    } : null,
+    carbon: carbon ? {
+      energyKwh: +carbon.energyKwh.toFixed(4),
+      co2Kg: +carbon.localCo2Kg.toFixed(4),
+      region: carbon.localRegion,
+      provenance: carbon.carbonProvenance,
+      note: 'counterfactual: cloud inference runs on the provider grid, not yours',
+    } : null,
+    reach: caps ? {
+      blastRadius: caps.blastRadius,
+      reasons: caps.blastReasons,
+      toolCount: caps.mcps.length,
+      writeOrDeployCount: writeOrDeploy,
+      tools: caps.mcps,
+      subagents: caps.subagents,
+      hooks: caps.hooks,
+      skills: caps.skills.length,
+      orchestration: caps.hasOrchestration,
+    } : null,
+    policy: {
+      aiCapPercent: cap * 100,
+      status: aiRatio > cap ? 'over' : 'within',
+    },
+    insights: deriveInsights({ authorship: gitStats, carbon, caps, policyCap: cap }),
+    economics: projectEconomics({ aiRatio, estUsdSession: carbon ? carbon.estUsd : 0, teamSize: 1 }),
+  };
+
+  // Only JSON on stdout — nothing else.
+  process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+}
+
 async function runOnboarding() {
   console.log(pc.cyan(ASCII_LOGO));
   intro(pc.inverse(' outlier: Welcome '));
@@ -75,22 +182,39 @@ async function main() {
       } catch (e) {}
     }
     if (alreadyRun) process.exit(0);
-    action = 'status';
+    // Compact once-per-day greeting (for the Claude Code plugin SessionStart hook) —
+    // a single line, fast, no full receipt.
+    const g = await getAuthorshipStats().catch(() => null);
+    const cp = await getCapabilitiesStats().catch(() => null);
+    const aiP = g ? (g.ratio * 100).toFixed(0) + '%' : '—';
+    const br = cp ? cp.blastRadius : '—';
+    const brc = br === 'HIGH' || br === 'CRITICAL' ? pc.red : br === 'MEDIUM' ? pc.yellow : pc.green;
+    console.log(`${pc.dim('[outlier]')} AI authorship ${pc.bold(aiP)} · agent reach ${brc(pc.bold(br))} ${pc.dim('· before you delegate, run: outlier preflight')}`);
+    process.exit(0);
+  }
+
+  // Agent / CI / swarm contract: --json emits a structured audit and nothing else
+  // (no logo, no spinner, no ANSI). This is how an agent perceives outlier.
+  if (process.argv.includes('--json')) {
+    await emitJson();
+    process.exit(0);
   }
 
   console.log(pc.cyan(ASCII_LOGO));
   const pkg = require('../package.json');
   console.log(pc.dim(`  Outlier v${pkg.version} · AI Code Reliance & Telemetry Engine\n`));
-  
-  
+
+
   if (action === '--help' || action === '-h' || action === 'help') {
     console.log(pc.bold('\nWHAT OUTLIER DOES'));
     console.log(pc.dim('  Reads your local git history and AI logs — on your machine — to show'));
     console.log(pc.dim('  how much of your code AI wrote, what it cost, and how to keep your skill.\n'));
     console.log(pc.bold('COMMANDS:'));
     console.log(`  ${pc.cyan('outlier')}              Run the audit (the default — same as 'status')`);
+    console.log(`  ${pc.cyan('outlier preflight')}    Quick briefing BEFORE you start an agent (reach + skill + spend)`);
     console.log(`  ${pc.cyan('outlier status')}       Full audit: who wrote the code, what it cost, your limit`);
     console.log(`  ${pc.cyan('outlier status --save')} Save the audit to ./outlier-audit.txt`);
+    console.log(`  ${pc.cyan('outlier --json')}       Machine-readable audit (for agents, CI, swarms)`);
     console.log(`  ${pc.cyan('outlier authorship')}   Just the AI-vs-human commit breakdown`);
     console.log(`  ${pc.cyan('outlier carbon')}       Just the token spend, cache waste & carbon`);
     console.log(`  ${pc.cyan('outlier capabilities')} What tools & skills your agents can reach`);
@@ -301,14 +425,37 @@ Conservative Floor: ${color(nmPct + '%')}`,
         let cachePct = '0';
         let co2Str = '0.0kg';
         let regionStr = 'Global Average';
+        let sourceLabel = 'no local AI logs found';
+        let noData = true;
         if (carbon) {
           if (carbon.totalTokens > 0) {
             cachePct = ((carbon.cacheReadTokens / carbon.totalTokens) * 100).toFixed(1);
+            noData = false;
           }
           co2Str = `${carbon.localCo2Kg.toFixed(2)}kg CO2`;
           regionStr = carbon.localRegion;
+          sourceLabel = carbon.sourceLabel;
+        }
+
+        // One-line agent-reach summary (full detail in `outlier capabilities`).
+        let reachStr = pc.dim('run: outlier capabilities');
+        if (capabilities) {
+          const rc = capabilities.blastRadius;
+          const col = rc === 'CRITICAL' || rc === 'HIGH' ? pc.red : rc === 'MEDIUM' ? pc.yellow : pc.green;
+          const risky = capabilities.mcps.filter((m: any) => ['money','exec','deploy','write-remote','write-local'].includes(m.reach)).length;
+          reachStr = `${col(pc.bold(rc))} · ${capabilities.mcps.length} tools` + (risky ? pc.dim(`, ${risky} can write/deploy`) : '');
         }
 
+        // Insight engine: turn the numbers into the top thing to actually do.
+        const insights = deriveInsights({ authorship: gitStats, carbon, caps: capabilities, policyCap: 0.70 });
+        const sevColor = (s: string) => s === 'critical' ? pc.red : s === 'warn' ? pc.yellow : s === 'good' ? pc.green : pc.cyan;
+        const sevMark = (s: string) => s === 'critical' ? '✗' : s === 'warn' ? '⚠' : s === 'good' ? '✓' : 'i';
+        const insightLines = insights.slice(0, 2).map((ins: Insight) =>
+          ` ${pc.dim('│')} ${sevColor(ins.severity)(sevMark(ins.severity))} ${pc.bold(ins.title)}\n` +
+          ` ${pc.dim('│')}   ${ins.detail.length > 56 ? ins.detail.slice(0, 55) + '…' : ins.detail}\n` +
+          ` ${pc.dim('│')}   ${pc.cyan('→ ' + ins.action)}`
+        ).join(`\n ${pc.dim('│')}\n`);
+
         // The thermal receipt below is the single canonical output for `status`.
         // (The old @clack dashboard panel was removed: it duplicated the receipt's
         // numbers in a second format, doubling the output on every run.)
@@ -370,13 +517,21 @@ Conservative Floor: ${color(nmPct + '%')}`,
  ${pc.dim('│')} Tokens used      ${pc.bold(totalTokensStr)}
  ${pc.dim('│')} Est. spend       ${pc.bold(estUsdStr)}
  ${pc.dim('│')} Re-used context  ${cacheBar} ${pc.bold(cachePct + '%')}
- ${pc.dim('│')} Energy           ${pc.bold(co2Str)} ${pc.dim(`(${regionStr} grid, rough)`)}
+ ${pc.dim('│')} Energy           ${pc.bold(co2Str)} ${pc.dim(`(${regionStr} grid)`)}
+ ${pc.dim('│')} ${pc.dim(`Source: ${sourceLabel}`)}
  ${pc.dim('│')}
  ${pc.dim('│')} ${cacheVerdict} — ${cacheText.split('\n').join('\n ' + pc.dim('│') + '   ')}
  ${pc.dim('├────────────────────────────────────────────────────────')}
+ ${pc.dim('│')} ${pc.bold(pc.bgCyan(pc.black(' WHAT YOUR AGENTS CAN REACH ')))}
+ ${pc.dim('│')} Blast radius   ${reachStr}
+ ${pc.dim('│')} ${pc.dim('Full map (deploy/push/write tools): outlier capabilities')}
+ ${pc.dim('├────────────────────────────────────────────────────────')}
  ${pc.dim('│')} ${pc.bold(pc.bgYellow(pc.black(' YOUR LIMIT ')))}
  ${pc.dim('│')} AI cap   ${pc.bold('70%')} ${pc.dim('· change with: outlier policy')}
  ${pc.dim('│')} Status   ${policyStatus} ${pc.dim('·')} ${policyAction}
+ ${pc.dim('├────────────────────────────────────────────────────────')}
+ ${pc.dim('│')} ${pc.bold(pc.bgGreen(pc.black(' WHAT TO DO ')))}
+${insightLines}
  ${pc.dim('├────────────────────────────────────────────────────────')}
  ${pc.dim('│')} ${pc.dim('Numbers are local estimates — authorship is a proxy and')}
  ${pc.dim('│')} ${pc.dim('carbon is rough. How it works: outlier --help')}
@@ -394,29 +549,103 @@ Conservative Floor: ${color(nmPct + '%')}`,
     }
 
   } else if (action === 'capabilities') {
-    s.start('Auditing AI surface area (MCPs, Skills, Orchestrators)...');
+    s.start('Mapping what your agents can reach...');
     try {
       const caps = await getCapabilitiesStats();
-      s.stop('Capabilities Scan Complete');
+      s.stop('Reach map complete');
+
+      const radiusColor = caps.blastRadius === 'CRITICAL' ? pc.red
+        : caps.blastRadius === 'HIGH' ? pc.red
+        : caps.blastRadius === 'MEDIUM' ? pc.yellow : pc.green;
+
+      // Group tools by reach so the risky ones stand out.
+      const order: string[] = ['money', 'exec', 'deploy', 'write-remote', 'write-local', 'data', 'network', 'model', 'read'];
+      const reachLabel: Record<string, string> = {
+        money: 'can move money', exec: 'can run shell', deploy: 'can deploy', 'write-remote': 'can push to repos',
+        'write-local': 'can write files', data: 'data stores', network: 'network', model: 'models', read: 'read-only',
+      };
+      const riskyReaches = new Set(['money', 'exec', 'deploy', 'write-remote', 'write-local']);
+      const toolLines = caps.mcps.length === 0 ? '  None detected'
+        : order.filter(r => caps.mcps.some(m => m.reach === r)).map(r => {
+            const names = caps.mcps.filter(m => m.reach === r).map(m => m.name).join(', ');
+            const tag = riskyReaches.has(r) ? pc.red(`[${reachLabel[r]}]`) : pc.dim(`[${reachLabel[r]}]`);
+            return `  ${tag} ${names}`;
+          }).join('\n');
 
       note(
-        `Orchestration Policy: ${caps.hasOrchestration ? pc.green('Detected (AGENTS.md)') : pc.yellow('None')}
+        `${pc.bold('BLAST RADIUS:')} ${radiusColor(pc.bold(caps.blastRadius))}  ${pc.dim('— if an agent or a prompt injection drives your tools')}
+${caps.blastReasons.length ? caps.blastReasons.map(r => `  ${pc.red('•')} ${r}`).join('\n') : pc.green('  • read-only — limited reach')}
 
-Active Skills (${caps.skills.length}):
-${caps.skills.length > 0 ? pc.cyan(caps.skills.map(s => `  • ${s}`).join('\n')) : '  None'}
+${pc.bold(`What your agents can reach (${caps.mcps.length} MCP tools):`)}
+${toolLines}
 
-Active MCP Servers (${caps.mcps.length}):
-${caps.mcps.length > 0 ? pc.magenta(caps.mcps.map(m => `  • ${m}`).join('\n')) : '  None'}
+${pc.bold('Automation & agents:')}
+  Hooks that fire for you: ${caps.hooks.length ? pc.yellow(caps.hooks.join(', ')) : 'none'}
+  Sub-agents: ${caps.subagents}   Skills: ${caps.skills.length}   Orchestration policy: ${caps.hasOrchestration ? pc.green('yes') : pc.yellow('no')}
 
-${pc.bold('Governance Assessment:')}
-This repository provides agents with ${caps.mcps.length} toolsets and ${caps.skills.length} skills. 
-${caps.skills.length > 5 ? pc.red('⚠ High Surface Area: Ensure strict authorship review is enabled.') : pc.green('✓ Low Surface Area: Risk contained.')}`,
-        'AI Capabilities Map'
+${pc.dim('This is your attack surface. Fewer write/deploy tools per session = smaller blast radius.')}`,
+        'Agent Reach & Blast Radius'
       );
     } catch (e: any) {
       s.stop('Audit failed');
       console.error(pc.red(e.message));
     }
+  } else if (action === 'aggregate') {
+    // Team/fleet rollup from a folder of `outlier --json` files. Local-first, no export.
+    const dir = process.argv[3];
+    if (!dir || !existsSync(dir)) {
+      console.error(pc.red('Usage: outlier aggregate <folder-of-json-audits>'));
+      console.log(pc.dim('  Each dev: outlier --json > team/<name>.json   then: outlier aggregate team/'));
+      process.exit(1);
+    }
+    const r = aggregateDir(dir);
+    note(
+      `Developers:        ${pc.bold(String(r.developers))}
+Avg AI authorship: ${pc.bold(r.avgAiPercent !== null ? r.avgAiPercent + '%' : '—')}   Max: ${r.maxAiPercent !== null ? r.maxAiPercent + '%' : '—'}
+Over their limit:  ${r.overLimit > 0 ? pc.red(String(r.overLimit)) : pc.green('0')}
+Team spend (est):  ${pc.bold('$' + r.totalEstUsd)}
+Worst blast radius:${' '}${r.worstBlastRadius === 'HIGH' || r.worstBlastRadius === 'CRITICAL' ? pc.red(r.worstBlastRadius) : pc.yellow(r.worstBlastRadius)}   (${r.reachWriteDeploy} write/deploy tools across the team)
+${r.notes.length ? '\n' + r.notes.map(n => `${pc.yellow('•')} ${n}`).join('\n') : ''}`,
+      'Team Rollup (local-first — nothing was exported)'
+    );
+  } else if (action === 'preflight') {
+    // Forward-looking briefing — the reason to run outlier BEFORE you start an agent.
+    // Same engine as status, framed for the session you are about to begin: reach,
+    // skill, spend, and the one thing to do, ending with the handoff to your agent.
+    s.start('Pre-flight check...');
+    const gitStats = await getAuthorshipStats().catch(() => null);
+    const carbon = await getCarbonStats().catch(() => null);
+    const caps = await getCapabilitiesStats().catch(() => null);
+    s.stop('Ready for take-off');
+
+    const aiPct = gitStats ? (gitStats.ratio * 100).toFixed(0) : '—';
+    const youPct = gitStats ? (100 - gitStats.ratio * 100).toFixed(0) : '—';
+    const blast = caps ? caps.blastRadius : 'UNKNOWN';
+    const blastCol = blast === 'CRITICAL' || blast === 'HIGH' ? pc.red : blast === 'MEDIUM' ? pc.yellow : pc.green;
+    const risky = caps ? caps.mcps.filter(m => ['money','exec','deploy','write-remote','write-local'].includes(m.reach)).length : 0;
+    const spend = carbon ? `$${carbon.estUsd.toFixed(0)}` : '—';
+    const cachePct = carbon && carbon.totalTokens ? ((carbon.cacheReadTokens / carbon.totalTokens) * 100).toFixed(0) + '%' : '—';
+
+    const insights = deriveInsights({ authorship: gitStats, carbon, caps, policyCap: 0.70 });
+    const sevCol = (sv: string) => sv === 'critical' ? pc.red : sv === 'warn' ? pc.yellow : sv === 'good' ? pc.green : pc.cyan;
+    const sevMk = (sv: string) => sv === 'critical' ? '✗' : sv === 'warn' ? '⚠' : sv === 'good' ? '✓' : 'i';
+    const actionLines = insights.slice(0, 3)
+      .map(ins => ` ${sevCol(ins.severity)(sevMk(ins.severity))} ${pc.cyan('→')} ${ins.action}`)
+      .join('\n');
+
+    console.log('');
+    console.log(pc.bold(pc.cyan(' ✈  PRE-FLIGHT')) + pc.dim(`  ·  ${process.cwd().split('/').pop()}`));
+    console.log(pc.dim(' ────────────────────────────────────────────────────'));
+    console.log(`  ${pc.bold('Reach')}   ${blastCol(pc.bold(blast))}` + (caps ? pc.dim(` · ${caps.mcps.length} tools, ${risky} can write/deploy`) : ''));
+    console.log(`  ${pc.bold('Skill')}   AI wrote ${pc.bold(aiPct + '%')} · you own ${pc.bold(youPct + '%')}`);
+    console.log(`  ${pc.bold('Spend')}   ${pc.bold(spend)} · ${cachePct} re-sent context`);
+    console.log('');
+    console.log(pc.bold(' Before you delegate:'));
+    console.log(actionLines);
+    console.log('');
+    const agent = detectAgent();
+    console.log(pc.bold(pc.magenta(' ✓ Ready? ')) + 'Start your session:  ' + pc.bold(agent || 'your AI agent'));
+    console.log('');
   } else if (action === 'policy') {
     const tier = await select({
       message: 'Select the governance tier to configure:',
@@ -501,19 +730,34 @@ Enforcement:  ${pc.cyan('Local pre-commit hook installed (backup created)')}`,
         'Active Governance Policy'
       );
     } else if (tier === 'regulatory') {
-      s.start('Generating Regulatory Compliance Audit (Decree 142)...');
-      await new Promise(resolve => setTimeout(resolve, 1200));
-      
+      s.start('Generating human-oversight audit record (Decree 142)...');
+      // A real, honest compliance record from the actual local numbers — not a stub.
+      const gitStats = await getAuthorshipStats().catch(() => null);
+      const caps = await getCapabilitiesStats().catch(() => null);
+      const humanReviewRate = gitStats ? +(1 - gitStats.ratio).toFixed(3) : null;
+      const oversightOk = humanReviewRate !== null && humanReviewRate >= 0.30; // ≥30% human-authored
+      const record = {
+        timestamp: new Date().toISOString(),
+        policy: 'Vietnam Decree 142/2026 — human oversight of high-risk AI',
+        repo: process.cwd().split('/').pop(),
+        humanAuthorshipRate: humanReviewRate,
+        aiAuthorshipRate: gitStats ? +gitStats.ratio.toFixed(3) : null,
+        humanOversight: oversightOk ? 'present' : 'insufficient',
+        agentBlastRadius: caps ? caps.blastRadius : 'unknown',
+        dataExported: false,
+        note: 'Derived from local git history only. No code, prompts, or citizen data leave the machine. Authorship is a proxy for human oversight.',
+      };
       const reportPath = join(process.cwd(), 'outlier-audit-report.jsonl');
-      writeFileSync(reportPath, JSON.stringify({ timestamp: new Date().toISOString(), status: 'PREVIEW', policy: 'Decree 142', simulatedOversight: true }) + '\n');
-      s.stop('Audit Generated');
+      writeFileSync(reportPath, JSON.stringify(record) + '\n');
+      s.stop('Audit record written');
 
       note(
-        `Jurisdiction: ${pc.bold('Vietnam (Decree 142)')}
-Status:       ${pc.green('Compliant - Human oversight logged locally')}
-Privacy:      ${pc.green('Preserved - No citizen data exported')}
+        `Jurisdiction: ${pc.bold('Vietnam (Decree 142/2026)')}
+Human oversight: ${oversightOk ? pc.green('present') : pc.red('insufficient')} ${pc.dim(`(${humanReviewRate !== null ? (humanReviewRate * 100).toFixed(0) + '% human-authored' : 'no git history'})`)}
+Agent reach:  ${caps ? caps.blastRadius : 'unknown'}
+Privacy:      ${pc.green('preserved — nothing exported')}
 Artifact:     ${pc.cyan(reportPath)}`,
-        'Regulatory Compliance'
+        'Human-Oversight Audit Record'
       );
     }
   } else if (action === 'participate') {
@@ -576,6 +820,25 @@ Artifact:     ${pc.cyan(reportPath)}`,
     console.log(`  ${pc.red('Lose:')} Architectural intimacy. You become a reviewer.`);
     console.log(pc.cyan('\n■ Next 5-10 Years (The 1M+ LOC Crisis)'));
     console.log(`  When an agent introduces a fatal state bug in a monolithic architecture, human reviewers will lack the muscle memory to debug it. Outlier measures this exact sovereignty erosion.\n`);
+
+    // Economic translation: the macro shadow of your individual number.
+    const gitStats = await getAuthorshipStats().catch(() => null);
+    const carbon = await getCarbonStats().catch(() => null);
+    if (gitStats || carbon) {
+      const { projectEconomics } = await import('./economics');
+      const teamSize = (() => { const i = process.argv.indexOf('--team'); return i > -1 ? (parseInt(process.argv[i + 1] || '1') || 1) : 1; })();
+      const econ = projectEconomics({
+        aiRatio: gitStats ? gitStats.ratio : 0,
+        estUsdSession: carbon ? carbon.estUsd : 0,
+        teamSize,
+      });
+      console.log(pc.bold(pc.bgMagenta(' THE MACRO SHADOW ')) + pc.dim(`  (team of ${teamSize} — set with --team N)`));
+      for (const p of econ.projections) {
+        console.log(`  ${pc.bold(p.label.padEnd(20))} ${pc.cyan(p.value)}`);
+        console.log(`  ${pc.dim('  ' + p.note)}`);
+      }
+      console.log('\n' + pc.dim(' ' + econ.assumptions) + '\n');
+    }
   } else if (action === 'knowledge') {
     console.log('\n' + pc.bold(pc.bgBlue(' CORE LITERATURE & REFERENCES ')) + '\n');
     console.log(`1. ${pc.cyan('METR (Measuring AI Ability)')} - Evaluating AI on long-horizon software tasks.`);
@@ -587,14 +850,15 @@ Artifact:     ${pc.cyan(reportPath)}`,
   outro('Done — nothing left your machine. (How it works: outlier --help)');
 
   if (typeof finalReceipt !== 'undefined' && finalReceipt) {
-    console.log(finalReceipt);
+    const boxed = closeBox(finalReceipt);
+    console.log(boxed);
 
     // --save: write a plain-text (no color) copy of the receipt next to the repo.
     if (process.argv.includes('--save')) {
       const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '');
       const savePath = join(process.cwd(), 'outlier-audit.txt');
       try {
-        writeFileSync(savePath, stripAnsi(finalReceipt).trimStart() + '\n');
+        writeFileSync(savePath, stripAnsi(boxed).trimStart() + '\n');
         console.log(pc.dim(`\n 💾 Saved to ${savePath}`));
       } catch {}
     }

package/src/economics.ts

@@ -0,0 +1,66 @@
+// Economic translation layer.
+//
+// The paper's core claim is that an individual authorship/spend number has a macro
+// shadow: at team and national scale it becomes skill-ladder erosion, offshore value
+// capture, and a hard-currency (forex) drain. This module turns the local numbers into
+// that projection — explicitly as a *projection with stated assumptions*, not a measurement.
+
+export interface EconProjection {
+  label: string;
+  value: string;
+  note: string;
+}
+
+export interface EconInput {
+  aiRatio: number;        // 0..1, share of authored output that is AI
+  estUsdSession: number;  // measured/estimated spend reflected by local logs
+  teamSize?: number;      // default 1 (solo); orgs override
+  workdaysPerYear?: number;
+}
+
+// Assumptions are surfaced in the output so nothing is hidden.
+const DEFAULTS = { teamSize: 1, workdaysPerYear: 230 };
+
+export function projectEconomics(input: EconInput): { projections: EconProjection[]; assumptions: string } {
+  const team = input.teamSize ?? DEFAULTS.teamSize;
+  const days = input.workdaysPerYear ?? DEFAULTS.workdaysPerYear;
+  const ai = Math.max(0, Math.min(1, input.aiRatio));
+
+  // Treat the local spend as a per-active-period hard-currency outflow to the AI vendor.
+  // Annualize crudely (the local logs are a sample window, not a day) and scale by team.
+  const annualOutflowPerDev = input.estUsdSession * (days / 30); // sample window ≈ a month of work
+  const annualOutflowTeam = annualOutflowPerDev * team;
+
+  const projections: EconProjection[] = [
+    {
+      label: 'Authorship shift',
+      value: `${(ai * 100).toFixed(0)}% of output → AI`,
+      note: team > 1
+        ? `≈ ${(ai * team).toFixed(1)} of ${team} dev-equivalents of authorship now machine-produced.`
+        : 'At team scale, this many dev-equivalents move to the machine.',
+    },
+    {
+      label: 'Value capture (offshore)',
+      value: `~$${Math.round(annualOutflowTeam).toLocaleString()}/yr`,
+      note: 'Hard-currency spend leaving to a foreign AI vendor — value captured offshore, not by the local worker.',
+    },
+    {
+      label: 'Skill ladder',
+      value: ai > 0.7 ? 'AT RISK' : ai > 0.4 ? 'watch' : 'intact',
+      note: ai > 0.7
+        ? 'Above ~70%, juniors stop building the skill that makes seniors — premature deprofessionalization.'
+        : 'Humans still author enough core work to keep building expertise.',
+    },
+    {
+      label: 'Forex / tax base',
+      value: `$${Math.round(annualOutflowPerDev).toLocaleString()}/dev/yr imported`,
+      note: 'Locally-taxed wages give way to foreign-billed inference: income-tax erosion + a recurring forex import.',
+    },
+  ];
+
+  const assumptions =
+    `Projection only. Assumes: team of ${team}, the local log window ≈ one month of work, ` +
+    `${days} workdays/yr. Spend is your measured/estimated local outflow scaled up — an order-of-magnitude shadow, not an audit.`;
+
+  return { projections, assumptions };
+}

package/src/emissions.ts

@@ -0,0 +1,73 @@
+// Offline, model-aware emissions engine.
+//
+// Local-first means NO network: no Electricity Maps / WattTime API calls. We bundle
+// the coefficients and look them up. This is the same approach CodeCarbon uses for its
+// offline tracker. Two inputs:
+//   1. per-model energy  (kWh per 1M output tokens) — output tokens dominate inference cost
+//   2. grid carbon intensity (gCO2 per kWh) for the assumed region
+//
+// All numbers are estimates with wide uncertainty (inference energy varies ~4-20x in the
+// literature). We expose the method so the UI can label provenance honestly. We never
+// claim precision we don't have.
+
+// Energy per 1M OUTPUT tokens, by model class (kWh).
+// Grounded in: the paper's measured ~10 kWh / 15.1M output on Opus-class (~0.66);
+// EcoLogits (genai-impact) per-call energy methodology; and the Hugging Face AI Energy
+// Score (which ranks small/mid/large model inference energy). Larger models = more
+// active parameters per token = more energy. These remain order-of-magnitude class
+// estimates (the literature spread is ~4-20x), labelled "estimate" in the UI — not vendor
+// figures. CodeCarbon, when present, overrides these with measured hardware energy.
+const MODEL_ENERGY_KWH_PER_M_OUTPUT: Record<string, number> = {
+  'opus':    0.66,  // large frontier (Claude Opus, GPT-4 class)
+  'sonnet':  0.30,  // mid (Claude Sonnet, GPT-4o)
+  'haiku':   0.10,  // small/fast (Claude Haiku, GPT-4o-mini)
+  'gpt-4':   0.55,
+  'gpt-4o':  0.30,
+  'gpt-5':   0.45,
+  'gemini':  0.35,  // Gemini Pro class
+  'flash':   0.10,  // Gemini Flash class
+  'local':   0.50,  // self-hosted / unknown open weights
+  'default': 0.45,  // unknown model -> conservative mid
+};
+
+// Map a raw model id (e.g. "claude-opus-4-8", "gpt-4o-mini", "gemini-2.5-flash") to a class.
+export function modelClass(modelId: string): string {
+  const m = (modelId || '').toLowerCase();
+  if (m.includes('opus')) return 'opus';
+  if (m.includes('sonnet')) return 'sonnet';
+  if (m.includes('haiku')) return 'haiku';
+  if (m.includes('flash') || m.includes('mini')) return 'haiku';
+  if (m.includes('gpt-5')) return 'gpt-5';
+  if (m.includes('gpt-4o')) return 'gpt-4o';
+  if (m.includes('gpt-4')) return 'gpt-4';
+  if (m.includes('gemini')) return 'gemini';
+  if (m.includes('llama') || m.includes('qwen') || m.includes('mistral') || m.includes('local')) return 'local';
+  return 'default';
+}
+
+export function energyKwhForModel(modelId: string, outputTokens: number): number {
+  const cls = modelClass(modelId);
+  const coeff = MODEL_ENERGY_KWH_PER_M_OUTPUT[cls] ?? 0.45;
+  return (outputTokens / 1_000_000) * coeff;
+}
+
+// Sum energy across a per-model output-token breakdown. Falls back to 'default' when the
+// model is unknown. Returns total kWh.
+export function energyKwhByModel(outputByModel: Record<string, number>): number {
+  let kwh = 0;
+  for (const [model, out] of Object.entries(outputByModel)) {
+    kwh += energyKwhForModel(model, out);
+  }
+  return kwh;
+}
+
+export interface EmissionsResult {
+  energyKwh: number;
+  co2Kg: number;
+  gridFactor: number;
+  method: string; // human-readable provenance for the UI
+}
+
+export function co2FromEnergy(energyKwh: number, gridFactorGPerKwh: number): number {
+  return (energyKwh * gridFactorGPerKwh) / 1000; // kg
+}