@rosh100yx/outlier 0.4.25 → 0.7.0

package/bin/outlier.js

@@ -165,7 +165,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@rosh100yx/outlier",
-    version: "0.4.25",
+    version: "0.7.0",
     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 +1798,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 +1993,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 +2003,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,15 +2036,17 @@ 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) {
@@ -1907,11 +2067,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 +2080,13 @@ 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 energyKwh = energyKwhByModel(outputByModel);
   const localGrid = getLocalGridFactor();
+  const sources = detectSources();
   const costIsReal = loggedCost > 0;
   const estUsd = costIsReal ? loggedCost : estimateUsd(outputTokens, cacheReadTokens, totalTokens);
   return {
@@ -1935,80 +2100,152 @@ async function getCarbonStats() {
     localRegion: 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(repoPath, ".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/cli.ts
-import { writeFileSync, readFileSync as readFileSync2, chmodSync, existsSync as existsSync3 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync, readFileSync as readFileSync3, chmodSync, existsSync as existsSync4 } from "fs";
+import { join as join5 } 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 readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join4 } 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 = [join4(home, ".zsh_history"), join4(home, ".bash_history")];
     for (const file of historyFiles) {
-      if (existsSync2(file)) {
-        const content = readFileSync(file, "utf8");
+      if (existsSync3(file)) {
+        const content = readFileSync2(file, "utf8");
         const lines = content.split(`
 `).filter(Boolean).slice(-500).reverse();
         for (const line of lines) {
@@ -2045,6 +2282,66 @@ var ASCII_LOGO = `
   \\____/|_| |_| |_| |_| |_|___|_____|_|  \\_\\
 `;
 var finalReceipt = "";
+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"
+    }
+  };
+  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 +2363,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 = join5(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 = join5(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(readFileSync3(configPath2, "utf8"));
         if (cfg.lastGreetingDate === today) {
           alreadyRun = true;
         } else {
@@ -2090,6 +2387,10 @@ async function main() {
       process.exit(0);
     action = "status";
   }
+  if (process.argv.includes("--json")) {
+    await emitJson();
+    process.exit(0);
+  }
   console.log(import_picocolors.default.cyan(ASCII_LOGO));
   const pkg = require_package();
   console.log(import_picocolors.default.dim(`  Outlier v${pkg.version} · AI Code Reliance & Telemetry Engine
@@ -2104,6 +2405,7 @@ WHAT OUTLIER DOES`));
     console.log(`  ${import_picocolors.default.cyan("outlier")}              Run the audit (the default — same as 'status')`);
     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 +2420,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 = join5(os2.homedir(), ".outlier_config");
+  if (!existsSync4(configPath) && !action) {
     await runOnboarding();
     action = "status";
   }
@@ -2130,7 +2432,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 = join5(os2.homedir(), rcName);
     const START_MARKER = "# --- OUTLIER PRE-FLIGHT RITUAL START ---";
     const END_MARKER = "# --- OUTLIER PRE-FLIGHT RITUAL END ---";
     const BLOCK = `
@@ -2150,8 +2452,8 @@ ${END_MARKER}
         process.exit(0);
       }
       let content = "";
-      if (existsSync3(rcPath))
-        content = readFileSync2(rcPath, "utf8");
+      if (existsSync4(rcPath))
+        content = readFileSync3(rcPath, "utf8");
       if (content.includes(START_MARKER)) {
         note(`Outlier is already initialized in ${rcName}`);
       } else {
@@ -2160,8 +2462,8 @@ ${END_MARKER}
       }
       process.exit(0);
     } else if (action === "uninit") {
-      if (existsSync3(rcPath)) {
-        let content = readFileSync2(rcPath, "utf8");
+      if (existsSync4(rcPath)) {
+        let content = readFileSync3(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 +2532,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 = join5(os2.homedir(), ".outlier_config");
+    if (existsSync4(configPath2)) {
       try {
-        const cfg = JSON.parse(readFileSync2(configPath2, "utf8"));
+        const cfg = JSON.parse(readFileSync3(configPath2, "utf8"));
         if (cfg.seenNarration)
           skipDelay = true;
       } catch (e) {}
@@ -2271,7 +2573,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(readFileSync3(configPath2, "utf8")) : {};
           cfg.seenNarration = true;
           writeFileSync(configPath2, JSON.stringify(cfg));
         } catch (e) {}
@@ -2299,12 +2601,23 @@ 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 isDanger = gitStats && gitStats.ratio > 0.7;
       const verdictZone = isDanger ? import_picocolors.default.red("Mostly AI") : import_picocolors.default.green("You're driving");
@@ -2353,12 +2666,17 @@ 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}
@@ -2375,23 +2693,42 @@ 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));
@@ -2425,8 +2762,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 = join5(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 +2771,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 = join5(gitDir, "hooks", "pre-commit");
+      if (existsSync4(hookPath)) {
         const { copyFileSync } = __require("fs");
         copyFileSync(hookPath, `${hookPath}.backup`);
       }
@@ -2468,7 +2805,7 @@ Enforcement:  ${import_picocolors.default.cyan("Local pre-commit hook installed
     } 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");
+      const reportPath = join5(process.cwd(), "outlier-audit-report.jsonl");
       writeFileSync(reportPath, JSON.stringify({ timestamp: new Date().toISOString(), status: "PREVIEW", policy: "Decree 142", simulatedOversight: true }) + `
 `);
       s.stop("Audit Generated");
@@ -2563,7 +2900,7 @@ Read the full academic foundation at: ${import_picocolors.default.underline("htt
     console.log(finalReceipt);
     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 = join5(process.cwd(), "outlier-audit.txt");
       try {
         writeFileSync(savePath, stripAnsi(finalReceipt).trimStart() + `
 `);