@rosh100yx/outlier 0.4.25 → 0.10.2

package/bin/outlier.js

@@ -31,6 +31,20 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/sisteransi/src/index.js
@@ -161,11 +175,52 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
+// src/economics.ts
+var exports_economics = {};
+__export(exports_economics, {
+  projectEconomics: () => projectEconomics
+});
+function projectEconomics(input) {
+  const team = input.teamSize ?? DEFAULTS.teamSize;
+  const days = input.workdaysPerYear ?? DEFAULTS.workdaysPerYear;
+  const ai = Math.max(0, Math.min(1, input.aiRatio));
+  const annualOutflowPerDev = input.estUsdSession * (days / 30);
+  const annualOutflowTeam = annualOutflowPerDev * team;
+  const projections = [
+    {
+      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 };
+}
+var DEFAULTS;
+var init_economics = __esm(() => {
+  DEFAULTS = { teamSize: 1, workdaysPerYear: 230 };
+});
+
 // package.json
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@rosh100yx/outlier",
-    version: "0.4.25",
+    version: "0.10.2",
     description: "AI Code Governance & Capability Auditing for the Terminal. Measures AI reliance, context waste, and enforces local CI/CD policies.",
     bin: {
       outlier: "bin/outlier.js"
@@ -1798,38 +1853,192 @@ async function getAuthorshipStats(repoPath = process.cwd()) {
 }
 
 // src/carbon.ts
-import { homedir } from "os";
-import { join } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 import { readFile, access, readdir } from "fs/promises";
 // data/grid-factors.json
 var grid_factors_default = {
   vietnam: 681,
-  france: 21.7,
-  us_east: 380,
+  india_average: 715,
+  indonesia: 650,
+  china: 581,
   singapore: 408,
-  india_average: 715
+  japan: 470,
+  south_korea: 415,
+  australia: 510,
+  us_east: 380,
+  us_west: 210,
+  canada: 120,
+  brazil: 95,
+  uk: 210,
+  germany: 350,
+  france: 21.7,
+  norway: 28,
+  sweden: 41,
+  global_average: 450
 };
 
+// src/emissions.ts
+var MODEL_ENERGY_KWH_PER_M_OUTPUT = {
+  opus: 0.66,
+  sonnet: 0.3,
+  haiku: 0.1,
+  "gpt-4": 0.55,
+  "gpt-4o": 0.3,
+  "gpt-5": 0.45,
+  gemini: 0.35,
+  flash: 0.1,
+  local: 0.5,
+  default: 0.45
+};
+function modelClass(modelId) {
+  const m2 = (modelId || "").toLowerCase();
+  if (m2.includes("opus"))
+    return "opus";
+  if (m2.includes("sonnet"))
+    return "sonnet";
+  if (m2.includes("haiku"))
+    return "haiku";
+  if (m2.includes("flash") || m2.includes("mini"))
+    return "haiku";
+  if (m2.includes("gpt-5"))
+    return "gpt-5";
+  if (m2.includes("gpt-4o"))
+    return "gpt-4o";
+  if (m2.includes("gpt-4"))
+    return "gpt-4";
+  if (m2.includes("gemini"))
+    return "gemini";
+  if (m2.includes("llama") || m2.includes("qwen") || m2.includes("mistral") || m2.includes("local"))
+    return "local";
+  return "default";
+}
+function energyKwhForModel(modelId, outputTokens) {
+  const cls = modelClass(modelId);
+  const coeff = MODEL_ENERGY_KWH_PER_M_OUTPUT[cls] ?? 0.45;
+  return outputTokens / 1e6 * coeff;
+}
+function energyKwhByModel(outputByModel) {
+  let kwh = 0;
+  for (const [model, out] of Object.entries(outputByModel)) {
+    kwh += energyKwhForModel(model, out);
+  }
+  return kwh;
+}
+
+// src/sources.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+var HOME = homedir();
+function hasCli(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasPath(p2) {
+  try {
+    return existsSync(p2);
+  } catch {
+    return false;
+  }
+}
+function detectSources(cwd = process.cwd()) {
+  const tools = [];
+  const add = (t2) => {
+    if (!tools.includes(t2))
+      tools.push(t2);
+  };
+  const cliTools = {
+    claude: "claude",
+    cursor: "cursor",
+    aider: "aider",
+    gemini: "gemini",
+    opencode: "opencode",
+    cody: "cody",
+    continue: "continue",
+    codex: "codex"
+  };
+  for (const [name, cmd] of Object.entries(cliTools)) {
+    if (hasCli(cmd))
+      add(name);
+  }
+  for (const [name, dir] of Object.entries({
+    claude: ".claude",
+    cursor: ".cursor",
+    gemini: ".gemini",
+    codeium: ".codeium",
+    continue: ".continue",
+    aider: ".aider.conf.yml"
+  })) {
+    if (hasPath(join(HOME, dir)))
+      add(name);
+  }
+  if (hasCli("codecarbon"))
+    add("codecarbon");
+  if (hasCli("ccusage"))
+    add("ccusage");
+  const slug = cwd.replace(/\//g, "-");
+  const claudeProjectDir = join(HOME, ".claude", "projects", slug);
+  const tokenomicsLog = join(HOME, ".claude", "tokenomics-log.jsonl");
+  let tokenSource;
+  if (hasPath(tokenomicsLog)) {
+    tokenSource = { name: "caveman tokenomics log", provenance: "measured" };
+  } else if (hasPath(claudeProjectDir)) {
+    tokenSource = { name: "Claude Code transcripts", provenance: "estimated" };
+  } else if (tools.includes("ccusage")) {
+    tokenSource = { name: "ccusage", provenance: "estimated" };
+  } else {
+    tokenSource = { name: "none", provenance: "none" };
+  }
+  let carbonSource;
+  const codecarbonData = hasPath(join(cwd, "emissions.csv")) || hasPath(join(HOME, ".codecarbon", "emissions.csv"));
+  if (codecarbonData) {
+    carbonSource = { name: "CodeCarbon emissions.csv", provenance: "measured" };
+  } else if (tokenSource.provenance !== "none") {
+    carbonSource = { name: "model+grid estimate", provenance: "estimated" };
+  } else {
+    carbonSource = { name: "none", provenance: "none" };
+  }
+  let capabilitySource;
+  if (hasPath(join(HOME, ".claude", "settings.json")) || hasPath(join(cwd, "AGENTS.md")) || hasPath(join(cwd, ".mcp.json"))) {
+    capabilitySource = { name: "local config (settings/AGENTS/MCP)", provenance: "measured" };
+  } else {
+    capabilitySource = { name: "none", provenance: "none" };
+  }
+  return { tools, tokenSource, carbonSource, capabilitySource };
+}
+function provLabel(s) {
+  if (s.provenance === "none")
+    return "no local data";
+  return `${s.provenance} · ${s.name}`;
+}
+
 // src/carbon.ts
 class ClaudeLogParser {
   baseDir;
   cwd;
-  constructor(baseDir = homedir(), cwd = process.cwd()) {
+  constructor(baseDir = homedir2(), cwd = process.cwd()) {
     this.baseDir = baseDir;
     this.cwd = cwd;
   }
   async parse() {
     const slug = this.cwd.replace(/\//g, "-");
-    const projectDir = join(this.baseDir, ".claude", "projects", slug);
+    const projectDir = join2(this.baseDir, ".claude", "projects", slug);
     try {
       const files = (await readdir(projectDir)).filter((f2) => f2.endsWith(".jsonl"));
       if (files.length > 0) {
         let total2 = 0, output2 = 0, cache2 = 0;
         const sessions2 = new Set;
+        const outputByModel2 = {};
         for (const file of files) {
           let text3 = "";
           try {
-            text3 = await readFile(join(projectDir, file), "utf-8");
+            text3 = await readFile(join2(projectDir, file), "utf-8");
           } catch {
             continue;
           }
@@ -1839,7 +2048,8 @@ class ClaudeLogParser {
               continue;
             try {
               const d = JSON.parse(line);
-              const u4 = d.message && d.message.usage || d.usage;
+              const msg = d.message || {};
+              const u4 = msg.usage || d.usage;
               if (u4) {
                 const inp = u4.input_tokens || 0;
                 const out = u4.output_tokens || 0;
@@ -1848,24 +2058,27 @@ class ClaudeLogParser {
                 total2 += inp + out + cr + cw;
                 output2 += out;
                 cache2 += cr;
+                const model = msg.model || "default";
+                outputByModel2[model] = (outputByModel2[model] || 0) + out;
               }
               if (d.sessionId)
                 sessions2.add(d.sessionId);
             } catch {}
           }
         }
-        return { total: total2, output: output2, cache: cache2, sessions: sessions2.size, cost: 0 };
+        return { total: total2, output: output2, cache: cache2, sessions: sessions2.size, cost: 0, outputByModel: outputByModel2 };
       }
     } catch {}
-    const logPath = join(this.baseDir, ".claude", "tokenomics-log.jsonl");
+    const logPath = join2(this.baseDir, ".claude", "tokenomics-log.jsonl");
     try {
       await access(logPath);
     } catch {
-      return { total: 0, output: 0, cache: 0, sessions: 0, cost: 0 };
+      return { total: 0, output: 0, cache: 0, sessions: 0, cost: 0, outputByModel: {} };
     }
     const text2 = await readFile(logPath, "utf-8");
     let total = 0, output = 0, cache = 0, cost = 0;
     const sessions = new Set;
+    const outputByModel = {};
     for (const line of text2.split(`
 `)) {
       if (!line.trim())
@@ -1878,21 +2091,50 @@ class ClaudeLogParser {
         cost += data.cost_usd || 0;
         if (data.session_id)
           sessions.add(data.session_id);
+        const model = data.model || "default";
+        outputByModel[model] = (outputByModel[model] || 0) + (data.output_tokens || 0);
       } catch {}
     }
-    return { total, output, cache, sessions: sessions.size, cost };
+    return { total, output, cache, sessions: sessions.size, cost, outputByModel };
   }
 }
 
 class CursorLogParser {
   async parse() {
-    return { total: 0, output: 0, cache: 0, sessions: 0, cost: 0 };
+    return { total: 0, output: 0, cache: 0, sessions: 0, cost: 0, outputByModel: {} };
   }
 }
 function estimateUsd(output, cacheRead, total) {
   const otherInput = Math.max(0, total - output - cacheRead);
   return output / 1e6 * 9 + cacheRead / 1e6 * 0.3 + otherInput / 1e6 * 3;
 }
+function readCodeCarbon(cwd, home) {
+  const { readFileSync, existsSync: existsSync2 } = __require("fs");
+  const { join: join3 } = __require("path");
+  for (const p2 of [join3(cwd, "emissions.csv"), join3(home, ".codecarbon", "emissions.csv")]) {
+    try {
+      if (!existsSync2(p2))
+        continue;
+      const lines = readFileSync(p2, "utf-8").trim().split(`
+`);
+      if (lines.length < 2)
+        continue;
+      const header = lines[0].split(",");
+      const iEm = header.indexOf("emissions");
+      const iEn = header.indexOf("energy_consumed");
+      if (iEm === -1 && iEn === -1)
+        continue;
+      let co2 = 0, kwh = 0;
+      for (const row of lines.slice(1)) {
+        const cols = row.split(",");
+        co2 += parseFloat(cols[iEm]) || 0;
+        kwh += parseFloat(cols[iEn]) || 0;
+      }
+      return { energyKwh: kwh, co2Kg: co2 };
+    } catch {}
+  }
+  return null;
+}
 function getLocalGridFactor() {
   try {
     const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -1907,11 +2149,12 @@ function getLocalGridFactor() {
     if (tz.includes("Calcutta") || tz.includes("Kolkata") || tz.includes("Asia/Kabul"))
       return { region: "India", factor: grid_factors_default.india_average };
   } catch (e) {}
-  return { region: "Global Average", factor: 450 };
+  return { region: "Global Average", factor: grid_factors_default.global_average };
 }
 async function getCarbonStats() {
   const parsers = [new ClaudeLogParser, new CursorLogParser];
   let totalTokens = 0, outputTokens = 0, cacheReadTokens = 0, sessions = 0, loggedCost = 0;
+  const outputByModel = {};
   for (const parser of parsers) {
     const stats = await parser.parse();
     totalTokens += stats.total;
@@ -1919,9 +2162,15 @@ async function getCarbonStats() {
     cacheReadTokens += stats.cache;
     sessions += stats.sessions;
     loggedCost += stats.cost;
+    for (const [m2, out] of Object.entries(stats.outputByModel)) {
+      outputByModel[m2] = (outputByModel[m2] || 0) + out;
+    }
   }
-  const energyKwh = outputTokens / 1e6 * 0.662;
   const localGrid = getLocalGridFactor();
+  const measured = readCodeCarbon(process.cwd(), homedir2());
+  const energyKwh = measured ? measured.energyKwh : energyKwhByModel(outputByModel);
+  const measuredCo2 = measured ? measured.co2Kg : null;
+  const sources = detectSources();
   const costIsReal = loggedCost > 0;
   const estUsd = costIsReal ? loggedCost : estimateUsd(outputTokens, cacheReadTokens, totalTokens);
   return {
@@ -1931,84 +2180,271 @@ async function getCarbonStats() {
     energyKwh,
     co2KgVietnam: energyKwh * grid_factors_default.vietnam / 1000,
     co2KgFrance: energyKwh * grid_factors_default.france / 1000,
-    localCo2Kg: energyKwh * localGrid.factor / 1000,
-    localRegion: localGrid.region,
+    localCo2Kg: measuredCo2 !== null ? measuredCo2 : energyKwh * localGrid.factor / 1000,
+    localRegion: measured ? "CodeCarbon (measured)" : localGrid.region,
     sessions,
     estUsd,
-    costIsReal
+    costIsReal,
+    tokenProvenance: sources.tokenSource.provenance,
+    carbonProvenance: sources.carbonSource.provenance,
+    sourceLabel: provLabel(sources.tokenSource)
   };
 }
 
 // src/capabilities.ts
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { existsSync, readdirSync } from "fs";
-async function getCapabilitiesStats(repoPath = process.cwd(), homeDirPath = homedir2()) {
-  const stats = {
-    mcps: [],
-    skills: [],
-    hasOrchestration: false
-  };
-  if (existsSync(join2(repoPath, "AGENTS.md"))) {
-    stats.hasOrchestration = true;
-  }
-  const projectSkillsPath = join2(repoPath, ".agents", "skills");
-  if (existsSync(projectSkillsPath)) {
-    try {
-      const skills = readdirSync(projectSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-      stats.skills.push(...skills);
-    } catch (e) {}
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { existsSync as existsSync2, readdirSync, readFileSync } from "fs";
+function classifyReach(name) {
+  const n2 = name.toLowerCase();
+  if (/(stripe|payment|infinity|kucoin|wallet|billing|payout)/.test(n2))
+    return "money";
+  if (/(shell|bash|exec|terminal|command|sandbox)/.test(n2))
+    return "exec";
+  if (/(cloudflare|vercel|netlify|modal|deploy|fly\.io|render|heroku|aws|gcp|azure)/.test(n2))
+    return "deploy";
+  if (/(github|gitlab|git|bitbucket)/.test(n2))
+    return "write-remote";
+  if (/(filesystem|file|fs|disk)/.test(n2))
+    return "write-local";
+  if (/(memory|supermemory|mem|obsidian|notion|airtable|coda|database|sql|store)/.test(n2))
+    return "data";
+  if (/(openrouter|ollama|openai|anthropic|llm|model|hugging)/.test(n2))
+    return "model";
+  if (/(exa|web|fetch|search|brave|browser|http|scrape)/.test(n2))
+    return "network";
+  return "network";
+}
+var REACH_RISK = {
+  read: 0,
+  model: 1,
+  network: 1,
+  data: 2,
+  "write-local": 2,
+  "write-remote": 3,
+  deploy: 3,
+  exec: 4,
+  money: 4
+};
+function scoreBlast(reaches) {
+  const reasons = [];
+  const has = (r2) => reaches.includes(r2);
+  if (has("money"))
+    reasons.push("can move money");
+  if (has("exec"))
+    reasons.push("can run shell commands");
+  if (has("deploy"))
+    reasons.push("can deploy to production");
+  if (has("write-remote"))
+    reasons.push("can push to your remote repos");
+  if (has("write-local"))
+    reasons.push("can write your local files");
+  if (has("data"))
+    reasons.push("can read/write your stored data");
+  const netCount = reaches.filter((r2) => r2 === "network" || r2 === "model").length;
+  if (netCount >= 3)
+    reasons.push(`reaches ${netCount} external services`);
+  const max = reaches.reduce((m2, r2) => Math.max(m2, REACH_RISK[r2]), 0);
+  let radius = "LOW";
+  if (max >= 4)
+    radius = "CRITICAL";
+  else if (max >= 3)
+    radius = "HIGH";
+  else if (max >= 2)
+    radius = "MEDIUM";
+  return { radius, reasons };
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
   }
-  const geminiSkillsPath = join2(homeDirPath, ".gemini", "skills");
-  if (existsSync(geminiSkillsPath)) {
-    try {
-      const skills = readdirSync(geminiSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-      for (const skill of skills) {
-        if (!stats.skills.includes(skill))
-          stats.skills.push(skill);
-      }
-    } catch (e) {}
+}
+function countDir(path, ext = ".md") {
+  try {
+    return readdirSync(path).filter((f2) => f2.endsWith(ext)).length;
+  } catch {
+    return 0;
   }
-  const geminiMcpPath = join2(homeDirPath, ".gemini", "antigravity-cli", "mcp");
-  if (existsSync(geminiMcpPath)) {
+}
+async function getCapabilitiesStats(repoPath = process.cwd(), homeDirPath = homedir3()) {
+  const mcpNames = new Set;
+  for (const cfg of [
+    join3(homeDirPath, ".claude.json"),
+    join3(homeDirPath, ".claude", "settings.json"),
+    join3(homeDirPath, ".cursor", "mcp.json"),
+    join3(homeDirPath, ".gemini", "config", "mcp_config.json"),
+    join3(homeDirPath, ".gemini", "settings.json"),
+    join3(repoPath, ".mcp.json"),
+    join3(repoPath, ".cursor", "mcp.json"),
+    join3(repoPath, ".claude", "settings.json")
+  ]) {
+    const j = readJson(cfg);
+    if (j?.mcpServers)
+      Object.keys(j.mcpServers).forEach((k) => mcpNames.add(k));
+  }
+  const geminiMcp = join3(homeDirPath, ".gemini", "antigravity-cli", "mcp");
+  if (existsSync2(geminiMcp)) {
     try {
-      const mcps = readdirSync(geminiMcpPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-      stats.mcps.push(...mcps);
-    } catch (e) {}
+      readdirSync(geminiMcp, { withFileTypes: true }).filter((d) => d.isDirectory()).forEach((d) => mcpNames.add(d.name));
+    } catch {}
   }
-  const claudeSettingsPath = join2(homeDirPath, ".claude", "settings.json");
-  if (existsSync(claudeSettingsPath)) {
-    try {
-      const claudeSettings = __require(claudeSettingsPath);
-      if (claudeSettings.enabledPlugins) {
-        Object.keys(claudeSettings.enabledPlugins).forEach((plugin) => {
-          if (claudeSettings.enabledPlugins[plugin] && !stats.mcps.includes(plugin)) {
-            stats.mcps.push(`plugin:${plugin}`);
-          }
+  const mcps = [...mcpNames].map((name) => ({ name, reach: classifyReach(name) }));
+  const skills = [];
+  for (const p2 of [join3(repoPath, ".agents", "skills"), join3(homeDirPath, ".claude", "skills"), join3(homeDirPath, ".gemini", "skills")]) {
+    if (existsSync2(p2)) {
+      try {
+        readdirSync(p2, { withFileTypes: true }).filter((d) => d.isDirectory()).forEach((d) => {
+          if (!skills.includes(d.name))
+            skills.push(d.name);
         });
-      }
-    } catch (e) {}
+      } catch {}
+    }
   }
-  return stats;
+  const subagents = countDir(join3(homeDirPath, ".claude", "agents")) + countDir(join3(repoPath, ".claude", "agents"));
+  const hooks = [];
+  for (const cfg of [join3(homeDirPath, ".claude", "settings.json"), join3(repoPath, ".claude", "settings.json")]) {
+    const j = readJson(cfg);
+    if (j?.hooks)
+      Object.keys(j.hooks).forEach((k) => {
+        if (!hooks.includes(k))
+          hooks.push(k);
+      });
+  }
+  const hasOrchestration = existsSync2(join3(repoPath, "AGENTS.md")) || existsSync2(join3(repoPath, ".mcp.json"));
+  const { radius, reasons } = scoreBlast(mcps.map((m2) => m2.reach));
+  return { mcps, skills, subagents, hooks, hasOrchestration, blastRadius: radius, blastReasons: reasons };
+}
+
+// src/insights.ts
+var RANK = { critical: 0, warn: 1, info: 2, good: 3 };
+function deriveInsights({ authorship, carbon, caps, policyCap = 0.7 }) {
+  const out = [];
+  const ai = authorship ? authorship.ratio : null;
+  const cachePct = carbon && carbon.totalTokens ? carbon.cacheReadTokens / carbon.totalTokens * 100 : null;
+  const blast = caps ? caps.blastRadius : null;
+  const writeOrDeploy = caps ? caps.mcps.filter((m2) => ["money", "exec", "deploy", "write-remote", "write-local"].includes(m2.reach)).length : 0;
+  const heavyTokens = carbon ? carbon.totalTokens > 1e6 : false;
+  if (ai !== null && ai > 0.7 && (blast === "HIGH" || blast === "CRITICAL")) {
+    out.push({
+      severity: "critical",
+      title: "High reliance + high reach",
+      detail: `AI wrote ${(ai * 100).toFixed(0)}% here and your agents can ${writeOrDeploy ? "write/deploy" : "reach external services"}. You may not own code that can ship to prod.`,
+      action: "Review the core paths yourself before delegating more this session."
+    });
+  } else if (ai !== null && ai > 0.7) {
+    out.push({
+      severity: "warn",
+      title: "You are mostly reviewing, not writing",
+      detail: `AI wrote ${(ai * 100).toFixed(0)}% of recent commits — you risk losing the skill to debug it unaided.`,
+      action: "Read the AI-written code through, or hand-write the next core change."
+    });
+  }
+  if (ai !== null && ai < 0.1 && heavyTokens) {
+    out.push({
+      severity: "info",
+      title: "Low AI% may be misleading",
+      detail: "Heavy token use but few AI-tagged commits — your agent probably is not writing Co-Authored-By trailers.",
+      action: "Treat the authorship number as a floor, not the truth, until trailers are on."
+    });
+  }
+  if (caps && (blast === "CRITICAL" || blast === "HIGH")) {
+    out.push({
+      severity: blast === "CRITICAL" ? "critical" : "warn",
+      title: `Blast radius ${blast}`,
+      detail: `If an agent (or a prompt injection) drives your tools, it ${caps.blastReasons.slice(0, 2).join(" and ") || "has broad reach"}.`,
+      action: "Disable the write/deploy MCP tools you do not need this session."
+    });
+  }
+  if (cachePct !== null && cachePct > 80) {
+    out.push({
+      severity: "warn",
+      title: "Most of your spend is re-sent context",
+      detail: `${cachePct.toFixed(0)}% of your tokens just re-read old context — that is most of the bill, not new work.`,
+      action: "Start fresh sessions for new tasks; keep context tight."
+    });
+  }
+  if (ai !== null && ai > policyCap) {
+    out.push({
+      severity: "warn",
+      title: "Over your AI-authorship limit",
+      detail: `AI authorship is ${(ai * 100).toFixed(0)}%, over your ${(policyCap * 100).toFixed(0)}% limit.`,
+      action: "Either raise the cap deliberately, or write the next change yourself."
+    });
+  }
+  if (out.length === 0) {
+    out.push({
+      severity: "good",
+      title: "Low risk",
+      detail: ai !== null ? `You wrote most of this (${(100 - ai * 100).toFixed(0)}%) and your agents have limited reach.` : "No AI logs or git history found to flag.",
+      action: "Carry on — re-run before your next big delegation."
+    });
+  }
+  return out.sort((a2, b2) => RANK[a2.severity] - RANK[b2.severity]);
 }
 
 // src/cli.ts
-import { writeFileSync, readFileSync as readFileSync2, chmodSync, existsSync as existsSync3 } from "fs";
+init_economics();
+
+// src/aggregate.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join4 } from "path";
+var BLAST_ORDER = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
+function aggregateDir(dir) {
+  const files = readdirSync2(dir).filter((f2) => f2.endsWith(".json"));
+  const audits = [];
+  for (const f2 of files) {
+    try {
+      const j = JSON.parse(readFileSync2(join4(dir, f2), "utf-8"));
+      if (j?.tool === "outlier")
+        audits.push(j);
+    } catch {}
+  }
+  const aiPcts = audits.map((a2) => a2.authorship?.aiPercent).filter((x) => typeof x === "number");
+  const spends = audits.map((a2) => a2.cost?.estUsd || 0);
+  const blasts = audits.map((a2) => a2.reach?.blastRadius).filter(Boolean);
+  const overs = audits.filter((a2) => a2.policy?.status === "over").length;
+  const writeDeploy = audits.reduce((s, a2) => s + (a2.reach?.writeOrDeployCount || 0), 0);
+  const worst = blasts.reduce((m2, b2) => BLAST_ORDER.indexOf(b2) > BLAST_ORDER.indexOf(m2) ? b2 : m2, "LOW");
+  const notes = [];
+  if (aiPcts.length && Math.max(...aiPcts) > 70)
+    notes.push("At least one developer is over 70% AI authorship.");
+  if (worst === "HIGH" || worst === "CRITICAL")
+    notes.push(`Worst-case agent blast radius across the team is ${worst}.`);
+  if (overs > 0)
+    notes.push(`${overs} developer(s) over their AI-authorship limit.`);
+  if (audits.length === 0)
+    notes.push("No outlier --json files found in this folder.");
+  return {
+    developers: audits.length,
+    avgAiPercent: aiPcts.length ? +(aiPcts.reduce((a2, b2) => a2 + b2, 0) / aiPcts.length).toFixed(1) : null,
+    maxAiPercent: aiPcts.length ? Math.max(...aiPcts) : null,
+    totalEstUsd: +spends.reduce((a2, b2) => a2 + b2, 0).toFixed(2),
+    worstBlastRadius: worst,
+    overLimit: overs,
+    reachWriteDeploy: writeDeploy,
+    notes
+  };
+}
+
+// src/cli.ts
+import { writeFileSync, readFileSync as readFileSync4, chmodSync, existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
 
 // src/agent.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
 import os from "os";
 function detectAgent() {
   const agents = ["claude", "cursor", "aider", "hermes", "cody", "continue", "opencode", "gemini"];
   try {
     const home = os.homedir();
-    const historyFiles = [join3(home, ".zsh_history"), join3(home, ".bash_history")];
+    const historyFiles = [join5(home, ".zsh_history"), join5(home, ".bash_history")];
     for (const file of historyFiles) {
-      if (existsSync2(file)) {
-        const content = readFileSync(file, "utf8");
+      if (existsSync3(file)) {
+        const content = readFileSync3(file, "utf8");
         const lines = content.split(`
 `).filter(Boolean).slice(-500).reverse();
         for (const line of lines) {
@@ -2045,6 +2481,116 @@ var ASCII_LOGO = `
   \\____/|_| |_| |_| |_| |_|___|_____|_|  \\_\\
 `;
 var finalReceipt = "";
+function closeBox(s, W2 = 66) {
+  const wide = new Set(["⚠", "\uD83D\uDED1", "✈", "\uD83C\uDF31", "\uD83D\uDCF8", "\uD83D\uDD2C", "\uD83D\uDCBE", "\uD83D\uDCA1", "✅", "❌", "\uD83D\uDE3E", "\uD83D\uDE00"]);
+  const chW = (ch) => {
+    const cp = ch.codePointAt(0);
+    return cp >= 126976 || wide.has(ch) ? 2 : 1;
+  };
+  const rail = "\x1B[2m│\x1B[0m";
+  const fit = (line, totalVis) => {
+    const parts = line.split(/(\x1b\[[0-9;]*m)/);
+    let out = "", vis = 0, cut = false;
+    for (const p2 of parts) {
+      if (/^\x1b\[/.test(p2)) {
+        out += p2;
+        continue;
+      }
+      for (const ch of p2) {
+        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(`
+`).map((line) => {
+    const plain = line.replace(/\x1b\[[0-9;]*m/g, "");
+    if (/^\s*┌/.test(plain))
+      return " \x1B[2m┌" + "─".repeat(W2) + "┐\x1B[0m";
+    if (/^\s*├/.test(plain))
+      return " \x1B[2m├" + "─".repeat(W2) + "┤\x1B[0m";
+    if (/^\s*└/.test(plain))
+      return " \x1B[2m└" + "─".repeat(W2) + "┘\x1B[0m";
+    if (/^\s*│/.test(plain))
+      return fit(line, 2 + W2) + rail;
+    return line;
+  }).join(`
+`);
+}
+async function emitJson() {
+  const pkg = require_package();
+  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.7;
+  const writeOrDeploy = caps ? caps.mcps.filter((m2) => ["money", "exec", "deploy", "write-remote", "write-local"].includes(m2.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 })
+  };
+  process.stdout.write(JSON.stringify(out, null, 2) + `
+`);
+}
 async function runOnboarding() {
   console.log(import_picocolors.default.cyan(ASCII_LOGO));
   intro(import_picocolors.default.inverse(" outlier: Welcome "));
@@ -2066,18 +2612,18 @@ As agents write more of our code, we lose visibility into:
     cancel("Onboarding paused. Run outlier again when you are ready.");
     process.exit(0);
   }
-  const configPath = join4(os2.homedir(), ".outlier_config");
+  const configPath = join6(os2.homedir(), ".outlier_config");
   writeFileSync(configPath, JSON.stringify({ onboarded: true, date: new Date().toISOString() }));
 }
 async function main() {
   let action = process.argv[2];
   if (action === "daily-greeting") {
-    const configPath2 = join4(os2.homedir(), ".outlier_config");
+    const configPath2 = join6(os2.homedir(), ".outlier_config");
     const today = new Date().toISOString().split("T")[0];
     let alreadyRun = false;
-    if (existsSync3(configPath2)) {
+    if (existsSync4(configPath2)) {
       try {
-        const cfg = JSON.parse(readFileSync2(configPath2, "utf8"));
+        const cfg = JSON.parse(readFileSync4(configPath2, "utf8"));
         if (cfg.lastGreetingDate === today) {
           alreadyRun = true;
         } else {
@@ -2088,7 +2634,17 @@ async function main() {
     }
     if (alreadyRun)
       process.exit(0);
-    action = "status";
+    const g2 = await getAuthorshipStats().catch(() => null);
+    const cp = await getCapabilitiesStats().catch(() => null);
+    const aiP = g2 ? (g2.ratio * 100).toFixed(0) + "%" : "—";
+    const br = cp ? cp.blastRadius : "—";
+    const brc = br === "HIGH" || br === "CRITICAL" ? import_picocolors.default.red : br === "MEDIUM" ? import_picocolors.default.yellow : import_picocolors.default.green;
+    console.log(`${import_picocolors.default.dim("[outlier]")} AI authorship ${import_picocolors.default.bold(aiP)} · agent reach ${brc(import_picocolors.default.bold(br))} ${import_picocolors.default.dim("· before you delegate, run: outlier preflight")}`);
+    process.exit(0);
+  }
+  if (process.argv.includes("--json")) {
+    await emitJson();
+    process.exit(0);
   }
   console.log(import_picocolors.default.cyan(ASCII_LOGO));
   const pkg = require_package();
@@ -2102,8 +2658,10 @@ WHAT OUTLIER DOES`));
 `));
     console.log(import_picocolors.default.bold("COMMANDS:"));
     console.log(`  ${import_picocolors.default.cyan("outlier")}              Run the audit (the default — same as 'status')`);
+    console.log(`  ${import_picocolors.default.cyan("outlier preflight")}    Quick briefing BEFORE you start an agent (reach + skill + spend)`);
     console.log(`  ${import_picocolors.default.cyan("outlier status")}       Full audit: who wrote the code, what it cost, your limit`);
     console.log(`  ${import_picocolors.default.cyan("outlier status --save")} Save the audit to ./outlier-audit.txt`);
+    console.log(`  ${import_picocolors.default.cyan("outlier --json")}       Machine-readable audit (for agents, CI, swarms)`);
     console.log(`  ${import_picocolors.default.cyan("outlier authorship")}   Just the AI-vs-human commit breakdown`);
     console.log(`  ${import_picocolors.default.cyan("outlier carbon")}       Just the token spend, cache waste & carbon`);
     console.log(`  ${import_picocolors.default.cyan("outlier capabilities")} What tools & skills your agents can reach`);
@@ -2118,8 +2676,8 @@ WHAT OUTLIER DOES`));
     console.log(import_picocolors.default.dim("How it works → https://github.com/rosh100yx/outlier#how-it-works"));
     process.exit(0);
   }
-  const configPath = join4(os2.homedir(), ".outlier_config");
-  if (!existsSync3(configPath) && !action) {
+  const configPath = join6(os2.homedir(), ".outlier_config");
+  if (!existsSync4(configPath) && !action) {
     await runOnboarding();
     action = "status";
   }
@@ -2130,7 +2688,7 @@ WHAT OUTLIER DOES`));
   if (action === "init" || action === "uninit") {
     const shell = process.env.SHELL || "";
     const rcName = shell.includes("zsh") ? ".zshrc" : ".bashrc";
-    const rcPath = join4(os2.homedir(), rcName);
+    const rcPath = join6(os2.homedir(), rcName);
     const START_MARKER = "# --- OUTLIER PRE-FLIGHT RITUAL START ---";
     const END_MARKER = "# --- OUTLIER PRE-FLIGHT RITUAL END ---";
     const BLOCK = `
@@ -2150,8 +2708,8 @@ ${END_MARKER}
         process.exit(0);
       }
       let content = "";
-      if (existsSync3(rcPath))
-        content = readFileSync2(rcPath, "utf8");
+      if (existsSync4(rcPath))
+        content = readFileSync4(rcPath, "utf8");
       if (content.includes(START_MARKER)) {
         note(`Outlier is already initialized in ${rcName}`);
       } else {
@@ -2160,8 +2718,8 @@ ${END_MARKER}
       }
       process.exit(0);
     } else if (action === "uninit") {
-      if (existsSync3(rcPath)) {
-        let content = readFileSync2(rcPath, "utf8");
+      if (existsSync4(rcPath)) {
+        let content = readFileSync4(rcPath, "utf8");
         if (content.includes(START_MARKER)) {
           const regex = new RegExp(`\\n?${START_MARKER}[\\s\\S]*?${END_MARKER}\\n?`, "g");
           content = content.replace(regex, `
@@ -2230,10 +2788,10 @@ Conservative Floor: ${color(nmPct + "%")}`, "Git Authorship Breakdown");
     let carbon = null;
     let capabilities = null;
     let skipDelay = false;
-    const configPath2 = join4(os2.homedir(), ".outlier_config");
-    if (existsSync3(configPath2)) {
+    const configPath2 = join6(os2.homedir(), ".outlier_config");
+    if (existsSync4(configPath2)) {
       try {
-        const cfg = JSON.parse(readFileSync2(configPath2, "utf8"));
+        const cfg = JSON.parse(readFileSync4(configPath2, "utf8"));
         if (cfg.seenNarration)
           skipDelay = true;
       } catch (e) {}
@@ -2271,7 +2829,7 @@ Conservative Floor: ${color(nmPct + "%")}`, "Git Authorship Breakdown");
         await new Promise((r2) => setTimeout(r2, 600));
       if (!skipDelay) {
         try {
-          const cfg = existsSync3(configPath2) ? JSON.parse(readFileSync2(configPath2, "utf8")) : {};
+          const cfg = existsSync4(configPath2) ? JSON.parse(readFileSync4(configPath2, "utf8")) : {};
           cfg.seenNarration = true;
           writeFileSync(configPath2, JSON.stringify(cfg));
         } catch (e) {}
@@ -2299,13 +2857,32 @@ Conservative Floor: ${color(nmPct + "%")}`, "Git Authorship Breakdown");
       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;
       }
+      let reachStr = import_picocolors.default.dim("run: outlier capabilities");
+      if (capabilities) {
+        const rc = capabilities.blastRadius;
+        const col = rc === "CRITICAL" || rc === "HIGH" ? import_picocolors.default.red : rc === "MEDIUM" ? import_picocolors.default.yellow : import_picocolors.default.green;
+        const risky = capabilities.mcps.filter((m2) => ["money", "exec", "deploy", "write-remote", "write-local"].includes(m2.reach)).length;
+        reachStr = `${col(import_picocolors.default.bold(rc))} · ${capabilities.mcps.length} tools` + (risky ? import_picocolors.default.dim(`, ${risky} can write/deploy`) : "");
+      }
+      const insights = deriveInsights({ authorship: gitStats, carbon, caps: capabilities, policyCap: 0.7 });
+      const sevColor = (s2) => s2 === "critical" ? import_picocolors.default.red : s2 === "warn" ? import_picocolors.default.yellow : s2 === "good" ? import_picocolors.default.green : import_picocolors.default.cyan;
+      const sevMark = (s2) => s2 === "critical" ? "✗" : s2 === "warn" ? "⚠" : s2 === "good" ? "✓" : "i";
+      const insightLines = insights.slice(0, 2).map((ins) => ` ${import_picocolors.default.dim("│")} ${sevColor(ins.severity)(sevMark(ins.severity))} ${import_picocolors.default.bold(ins.title)}
+` + ` ${import_picocolors.default.dim("│")}   ${ins.detail.length > 56 ? ins.detail.slice(0, 55) + "…" : ins.detail}
+` + ` ${import_picocolors.default.dim("│")}   ${import_picocolors.default.cyan("→ " + ins.action)}`).join(`
+ ${import_picocolors.default.dim("│")}
+`);
       const isDanger = gitStats && gitStats.ratio > 0.7;
       const verdictZone = isDanger ? import_picocolors.default.red("Mostly AI") : import_picocolors.default.green("You're driving");
       const verdictText = isDanger ? `AI wrote most of this. Read it through so you can
@@ -2353,15 +2930,23 @@ Conservative Floor: ${color(nmPct + "%")}`, "Git Authorship Breakdown");
  ${import_picocolors.default.dim("│")} Tokens used      ${import_picocolors.default.bold(totalTokensStr)}
  ${import_picocolors.default.dim("│")} Est. spend       ${import_picocolors.default.bold(estUsdStr)}
  ${import_picocolors.default.dim("│")} Re-used context  ${cacheBar} ${import_picocolors.default.bold(cachePct + "%")}
- ${import_picocolors.default.dim("│")} Energy           ${import_picocolors.default.bold(co2Str)} ${import_picocolors.default.dim(`(${regionStr} grid, rough)`)}
+ ${import_picocolors.default.dim("│")} Energy           ${import_picocolors.default.bold(co2Str)} ${import_picocolors.default.dim(`(${regionStr} grid)`)}
+ ${import_picocolors.default.dim("│")} ${import_picocolors.default.dim(`Source: ${sourceLabel}`)}
  ${import_picocolors.default.dim("│")}
  ${import_picocolors.default.dim("│")} ${cacheVerdict} — ${cacheText.split(`
 `).join(`
  ` + import_picocolors.default.dim("│") + "   ")}
  ${import_picocolors.default.dim("├────────────────────────────────────────────────────────")}
+ ${import_picocolors.default.dim("│")} ${import_picocolors.default.bold(import_picocolors.default.bgCyan(import_picocolors.default.black(" WHAT YOUR AGENTS CAN REACH ")))}
+ ${import_picocolors.default.dim("│")} Blast radius   ${reachStr}
+ ${import_picocolors.default.dim("│")} ${import_picocolors.default.dim("Full map (deploy/push/write tools): outlier capabilities")}
+ ${import_picocolors.default.dim("├────────────────────────────────────────────────────────")}
  ${import_picocolors.default.dim("│")} ${import_picocolors.default.bold(import_picocolors.default.bgYellow(import_picocolors.default.black(" YOUR LIMIT ")))}
  ${import_picocolors.default.dim("│")} AI cap   ${import_picocolors.default.bold("70%")} ${import_picocolors.default.dim("· change with: outlier policy")}
  ${import_picocolors.default.dim("│")} Status   ${policyStatus} ${import_picocolors.default.dim("·")} ${policyAction}
+ ${import_picocolors.default.dim("├────────────────────────────────────────────────────────")}
+ ${import_picocolors.default.dim("│")} ${import_picocolors.default.bold(import_picocolors.default.bgGreen(import_picocolors.default.black(" WHAT TO DO ")))}
+${insightLines}
  ${import_picocolors.default.dim("├────────────────────────────────────────────────────────")}
  ${import_picocolors.default.dim("│")} ${import_picocolors.default.dim("Numbers are local estimates — authorship is a proxy and")}
  ${import_picocolors.default.dim("│")} ${import_picocolors.default.dim("carbon is rough. How it works: outlier --help")}
@@ -2375,27 +2960,93 @@ Conservative Floor: ${color(nmPct + "%")}`, "Git Authorship Breakdown");
       console.error(import_picocolors.default.red(e.message));
     }
   } 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");
-      note(`Orchestration Policy: ${caps.hasOrchestration ? import_picocolors.default.green("Detected (AGENTS.md)") : import_picocolors.default.yellow("None")}
+      s.stop("Reach map complete");
+      const radiusColor = caps.blastRadius === "CRITICAL" ? import_picocolors.default.red : caps.blastRadius === "HIGH" ? import_picocolors.default.red : caps.blastRadius === "MEDIUM" ? import_picocolors.default.yellow : import_picocolors.default.green;
+      const order = ["money", "exec", "deploy", "write-remote", "write-local", "data", "network", "model", "read"];
+      const reachLabel = {
+        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((r2) => caps.mcps.some((m2) => m2.reach === r2)).map((r2) => {
+        const names = caps.mcps.filter((m2) => m2.reach === r2).map((m2) => m2.name).join(", ");
+        const tag = riskyReaches.has(r2) ? import_picocolors.default.red(`[${reachLabel[r2]}]`) : import_picocolors.default.dim(`[${reachLabel[r2]}]`);
+        return `  ${tag} ${names}`;
+      }).join(`
+`);
+      note(`${import_picocolors.default.bold("BLAST RADIUS:")} ${radiusColor(import_picocolors.default.bold(caps.blastRadius))}  ${import_picocolors.default.dim("— if an agent or a prompt injection drives your tools")}
+${caps.blastReasons.length ? caps.blastReasons.map((r2) => `  ${import_picocolors.default.red("•")} ${r2}`).join(`
+`) : import_picocolors.default.green("  • read-only — limited reach")}
 
-Active Skills (${caps.skills.length}):
-${caps.skills.length > 0 ? import_picocolors.default.cyan(caps.skills.map((s2) => `  • ${s2}`).join(`
-`)) : "  None"}
+${import_picocolors.default.bold(`What your agents can reach (${caps.mcps.length} MCP tools):`)}
+${toolLines}
 
-Active MCP Servers (${caps.mcps.length}):
-${caps.mcps.length > 0 ? import_picocolors.default.magenta(caps.mcps.map((m2) => `  • ${m2}`).join(`
-`)) : "  None"}
+${import_picocolors.default.bold("Automation & agents:")}
+  Hooks that fire for you: ${caps.hooks.length ? import_picocolors.default.yellow(caps.hooks.join(", ")) : "none"}
+  Sub-agents: ${caps.subagents}   Skills: ${caps.skills.length}   Orchestration policy: ${caps.hasOrchestration ? import_picocolors.default.green("yes") : import_picocolors.default.yellow("no")}
 
-${import_picocolors.default.bold("Governance Assessment:")}
-This repository provides agents with ${caps.mcps.length} toolsets and ${caps.skills.length} skills. 
-${caps.skills.length > 5 ? import_picocolors.default.red("⚠ High Surface Area: Ensure strict authorship review is enabled.") : import_picocolors.default.green("✓ Low Surface Area: Risk contained.")}`, "AI Capabilities Map");
+${import_picocolors.default.dim("This is your attack surface. Fewer write/deploy tools per session = smaller blast radius.")}`, "Agent Reach & Blast Radius");
     } catch (e) {
       s.stop("Audit failed");
       console.error(import_picocolors.default.red(e.message));
     }
+  } else if (action === "aggregate") {
+    const dir = process.argv[3];
+    if (!dir || !existsSync4(dir)) {
+      console.error(import_picocolors.default.red("Usage: outlier aggregate <folder-of-json-audits>"));
+      console.log(import_picocolors.default.dim("  Each dev: outlier --json > team/<name>.json   then: outlier aggregate team/"));
+      process.exit(1);
+    }
+    const r2 = aggregateDir(dir);
+    note(`Developers:        ${import_picocolors.default.bold(String(r2.developers))}
+Avg AI authorship: ${import_picocolors.default.bold(r2.avgAiPercent !== null ? r2.avgAiPercent + "%" : "—")}   Max: ${r2.maxAiPercent !== null ? r2.maxAiPercent + "%" : "—"}
+Over their limit:  ${r2.overLimit > 0 ? import_picocolors.default.red(String(r2.overLimit)) : import_picocolors.default.green("0")}
+Team spend (est):  ${import_picocolors.default.bold("$" + r2.totalEstUsd)}
+Worst blast radius:${" "}${r2.worstBlastRadius === "HIGH" || r2.worstBlastRadius === "CRITICAL" ? import_picocolors.default.red(r2.worstBlastRadius) : import_picocolors.default.yellow(r2.worstBlastRadius)}   (${r2.reachWriteDeploy} write/deploy tools across the team)
+${r2.notes.length ? `
+` + r2.notes.map((n2) => `${import_picocolors.default.yellow("•")} ${n2}`).join(`
+`) : ""}`, "Team Rollup (local-first — nothing was exported)");
+  } else if (action === "preflight") {
+    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" ? import_picocolors.default.red : blast === "MEDIUM" ? import_picocolors.default.yellow : import_picocolors.default.green;
+    const risky = caps ? caps.mcps.filter((m2) => ["money", "exec", "deploy", "write-remote", "write-local"].includes(m2.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.7 });
+    const sevCol = (sv) => sv === "critical" ? import_picocolors.default.red : sv === "warn" ? import_picocolors.default.yellow : sv === "good" ? import_picocolors.default.green : import_picocolors.default.cyan;
+    const sevMk = (sv) => sv === "critical" ? "✗" : sv === "warn" ? "⚠" : sv === "good" ? "✓" : "i";
+    const actionLines = insights.slice(0, 3).map((ins) => ` ${sevCol(ins.severity)(sevMk(ins.severity))} ${import_picocolors.default.cyan("→")} ${ins.action}`).join(`
+`);
+    console.log("");
+    console.log(import_picocolors.default.bold(import_picocolors.default.cyan(" ✈  PRE-FLIGHT")) + import_picocolors.default.dim(`  ·  ${process.cwd().split("/").pop()}`));
+    console.log(import_picocolors.default.dim(" ────────────────────────────────────────────────────"));
+    console.log(`  ${import_picocolors.default.bold("Reach")}   ${blastCol(import_picocolors.default.bold(blast))}` + (caps ? import_picocolors.default.dim(` · ${caps.mcps.length} tools, ${risky} can write/deploy`) : ""));
+    console.log(`  ${import_picocolors.default.bold("Skill")}   AI wrote ${import_picocolors.default.bold(aiPct + "%")} · you own ${import_picocolors.default.bold(youPct + "%")}`);
+    console.log(`  ${import_picocolors.default.bold("Spend")}   ${import_picocolors.default.bold(spend)} · ${cachePct} re-sent context`);
+    console.log("");
+    console.log(import_picocolors.default.bold(" Before you delegate:"));
+    console.log(actionLines);
+    console.log("");
+    const agent = detectAgent();
+    console.log(import_picocolors.default.bold(import_picocolors.default.magenta(" ✓ Ready? ")) + "Start your session:  " + import_picocolors.default.bold(agent || "your AI agent"));
+    console.log("");
   } else if (action === "policy") {
     const tier = await select({
       message: "Select the governance tier to configure:",
@@ -2425,8 +3076,8 @@ ${caps.skills.length > 5 ? import_picocolors.default.red("⚠ High Surface Area:
         process.exit(0);
       }
       s.start(`Applying ${tier} policy guardrails...`);
-      const gitDir = join4(process.cwd(), ".git");
-      const isRepo = existsSync3(gitDir);
+      const gitDir = join6(process.cwd(), ".git");
+      const isRepo = existsSync4(gitDir);
       if (!isRepo) {
         console.error(import_picocolors.default.red("Must be run inside a git repository"));
         process.exit(1);
@@ -2434,8 +3085,8 @@ ${caps.skills.length > 5 ? import_picocolors.default.red("⚠ High Surface Area:
       const isStrict = process.argv.includes("--strict");
       const bouncerMsg = isStrict ? `echo "⚠️  outlier policy warning: AI authorship ($CURRENT_RATIO%) exceeds threshold ($MAX_RATIO%)"` : `echo "\uD83D\uDEE1️  Outlier Bouncer: Repository AI-generation ($CURRENT_RATIO%) exceeds your defined mastery threshold ($MAX_RATIO%)."
     echo "Take a moment to review your recent architectural decisions. Ensure you still understand the system."`;
-      const hookPath = join4(gitDir, "hooks", "pre-commit");
-      if (existsSync3(hookPath)) {
+      const hookPath = join6(gitDir, "hooks", "pre-commit");
+      if (existsSync4(hookPath)) {
         const { copyFileSync } = __require("fs");
         copyFileSync(hookPath, `${hookPath}.backup`);
       }
@@ -2466,16 +3117,31 @@ Rule 1:       ${import_picocolors.default.green(`AI Authorship must not exceed $
 Rule 2:       ${import_picocolors.default.green("Require human review on consecutive high-AI sprints")}
 Enforcement:  ${import_picocolors.default.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));
-      const reportPath = join4(process.cwd(), "outlier-audit-report.jsonl");
-      writeFileSync(reportPath, JSON.stringify({ timestamp: new Date().toISOString(), status: "PREVIEW", policy: "Decree 142", simulatedOversight: true }) + `
+      s.start("Generating human-oversight audit record (Decree 142)...");
+      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.3;
+      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 = join6(process.cwd(), "outlier-audit-report.jsonl");
+      writeFileSync(reportPath, JSON.stringify(record) + `
 `);
-      s.stop("Audit Generated");
-      note(`Jurisdiction: ${import_picocolors.default.bold("Vietnam (Decree 142)")}
-Status:       ${import_picocolors.default.green("Compliant - Human oversight logged locally")}
-Privacy:      ${import_picocolors.default.green("Preserved - No citizen data exported")}
-Artifact:     ${import_picocolors.default.cyan(reportPath)}`, "Regulatory Compliance");
+      s.stop("Audit record written");
+      note(`Jurisdiction: ${import_picocolors.default.bold("Vietnam (Decree 142/2026)")}
+Human oversight: ${oversightOk ? import_picocolors.default.green("present") : import_picocolors.default.red("insufficient")} ${import_picocolors.default.dim(`(${humanReviewRate !== null ? (humanReviewRate * 100).toFixed(0) + "% human-authored" : "no git history"})`)}
+Agent reach:  ${caps ? caps.blastRadius : "unknown"}
+Privacy:      ${import_picocolors.default.green("preserved — nothing exported")}
+Artifact:     ${import_picocolors.default.cyan(reportPath)}`, "Human-Oversight Audit Record");
     }
   } else if (action === "participate") {
     s.start("Connecting to the Outlier research project...");
@@ -2547,6 +3213,28 @@ ${import_picocolors.default.bold("Submit here (and drop your screenshot!):")} ${
 ■ 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.
 `);
+    const gitStats = await getAuthorshipStats().catch(() => null);
+    const carbon = await getCarbonStats().catch(() => null);
+    if (gitStats || carbon) {
+      const { projectEconomics: projectEconomics2 } = await Promise.resolve().then(() => (init_economics(), exports_economics));
+      const teamSize = (() => {
+        const i2 = process.argv.indexOf("--team");
+        return i2 > -1 ? parseInt(process.argv[i2 + 1] || "1") || 1 : 1;
+      })();
+      const econ = projectEconomics2({
+        aiRatio: gitStats ? gitStats.ratio : 0,
+        estUsdSession: carbon ? carbon.estUsd : 0,
+        teamSize
+      });
+      console.log(import_picocolors.default.bold(import_picocolors.default.bgMagenta(" THE MACRO SHADOW ")) + import_picocolors.default.dim(`  (team of ${teamSize} — set with --team N)`));
+      for (const p2 of econ.projections) {
+        console.log(`  ${import_picocolors.default.bold(p2.label.padEnd(20))} ${import_picocolors.default.cyan(p2.value)}`);
+        console.log(`  ${import_picocolors.default.dim("  " + p2.note)}`);
+      }
+      console.log(`
+` + import_picocolors.default.dim(" " + econ.assumptions) + `
+`);
+    }
   } else if (action === "knowledge") {
     console.log(`
 ` + import_picocolors.default.bold(import_picocolors.default.bgBlue(" CORE LITERATURE & REFERENCES ")) + `
@@ -2560,12 +3248,13 @@ Read the full academic foundation at: ${import_picocolors.default.underline("htt
   }
   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);
     if (process.argv.includes("--save")) {
       const stripAnsi = (s2) => s2.replace(/\x1b\[[0-9;]*m/g, "");
-      const savePath = join4(process.cwd(), "outlier-audit.txt");
+      const savePath = join6(process.cwd(), "outlier-audit.txt");
       try {
-        writeFileSync(savePath, stripAnsi(finalReceipt).trimStart() + `
+        writeFileSync(savePath, stripAnsi(boxed).trimStart() + `
 `);
         console.log(import_picocolors.default.dim(`
  \uD83D\uDCBE Saved to ${savePath}`));