agentwaste-core 0.1.0 → 0.1.1

package/src/tools.js

@@ -1,6 +1,6 @@
 import { toReportJson } from "./report.js";
 
-export const TOOL_IDS = ["suckytraces", "keybarf", "tokengoblin", "tooltantrum"];
+export const TOOL_IDS = ["suckytraces", "tooltantrum"];
 
 const TOOL_CONFIGS = {
   suckytraces: {
@@ -8,133 +8,39 @@ const TOOL_CONFIGS = {
     packageName: "suckytraces",
     binName: "suckytraces",
     metricKey: "trace_coverage",
-    emoji: "🕵️",
-    npc: "Trace Goblin",
-    tagline: "sniffs out agent runs that cannot be replayed, explained, or defended in standup.",
-    good: "traceable little angel",
-    bad: "all vibes, no receipts",
     commandHint: "npx suckytraces",
+    tagline: "Trace coverage for local coding-agent sessions.",
+    good: "trace trail intact",
+    bad: "trace blackout",
     score(metric) {
-      if (metric.session_log_files === 0) return 20;
+      if (metric.session_log_files === 0) return 0;
       return clamp(100 - metric.session_file_coverage_percent);
     },
-    findings(metric) {
-      return [
-        finding("coverage", `${metric.session_file_coverage_percent}% replayable`, metric.level),
-        finding("traced files", `${formatNumber(metric.traced_session_log_files)} / ${formatNumber(metric.session_log_files)} session logs`),
-        finding("trace crumbs", `${formatNumber(metric.structured_trace_signals)} structured signals`),
-      ];
-    },
-    roast(metric) {
-      if (metric.session_log_files === 0) return "No session logs found. The goblin is unemployed but suspicious.";
-      if (metric.session_file_coverage_percent >= 80) return "Your traces have shoes, a map, and a tiny flashlight. Respect.";
-      if (metric.session_file_coverage_percent >= 30) return "Some traces exist, but the murder board still has yarn gaps.";
-      return "Debugging these runs is basically reading tea leaves in a server room.";
+    headline(metric) {
+      if (metric.session_log_files === 0) return "NO FOOTAGE FOUND";
+      if (metric.session_file_coverage_percent < 30) return "THE PAPER TRAIL IS ON FIRE";
+      if (metric.session_file_coverage_percent < 80) return "THE ALIBI HAS HOLES";
+      return "THE TRACE TRAIL IS CLEAN";
     },
-    next(metric) {
-      if (metric.session_log_files === 0) return "run an agent once, then re-run this goblin";
-      if (metric.session_file_coverage_percent >= 80) return "keep run_id / trace_id attached to every meaningful tool call";
-      return "add run_id, trace_id, span_id, retry metadata, and final artifacts to agent/tool logs";
-    },
-    evidence(report) {
-      return report.evidence.trace_files_sample;
-    },
-    explain: [
-      "coverage = session log files with structured trace evidence / scanned session log files * 100",
-      "trace evidence includes trace_id, span_id, run_id, OpenTelemetry, or otel",
-      "goal: when an agent breaks prod, you can replay the plot instead of interviewing a ghost",
-    ],
-  },
-  keybarf: {
-    id: "keybarf",
-    packageName: "keybarf",
-    binName: "keybarf",
-    metricKey: "credential_exposure",
-    emoji: "🤮",
-    npc: "Secret Raccoon",
-    tagline: "rummages through local agent logs for API keys that should not be cosplay props.",
-    good: "vault goblin satisfied",
-    bad: "credential confetti cannon",
-    commandHint: "npx keybarf",
-    score(metric) {
-      return clamp(metric.score ?? 0);
+    summary(metric) {
+      const missing = Math.max(0, metric.session_log_files - metric.traced_session_log_files);
+      if (metric.session_log_files === 0) return "No session logs were found, so there is nothing to replay yet.";
+      if (missing === 0) return "Every scanned log has trace evidence. The replay trail is intact.";
+      return `Only ${formatPercent(metric.session_file_coverage_percent)} of session logs include trace/run/span IDs. ${formatCount(missing, "log")} would be hard to replay after an incident.`;
     },
     findings(metric) {
-      const kinds = Object.entries(metric.by_kind ?? {})
-        .filter(([, count]) => count > 0)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 4)
-        .map(([kind, count]) => `${kind}:${count}`)
-        .join(", ");
+      const missing = Math.max(0, metric.session_log_files - metric.traced_session_log_files);
       return [
-        finding("secret fp", `${formatNumber(metric.unique_secret_fingerprints)} unique redacted fingerprints`, metric.level),
-        finding("model-facing", `${formatNumber(metric.model_facing_secret_fingerprints)} fingerprints reached prompt/tool context`, metric.model_facing_secret_fingerprints > 0 ? "CRITICAL" : "LOW"),
-        finding("kinds", kinds || "none spotted"),
-        finding("risk score", `${formatNumber(metric.score)} / 100`, metric.level),
+        finding("coverage", `${formatPercent(metric.session_file_coverage_percent)} traced`, metric.level),
+        finding("with ids", `${formatNumber(metric.traced_session_log_files)} / ${formatNumber(metric.session_log_files)} logs`, metric.level),
+        finding("missing", `${formatNumber(missing)} logs`, missing > 0 ? metric.level : "LOW"),
+        finding("signals", `${formatNumber(metric.structured_trace_signals)} markers`),
       ];
     },
-    roast(metric) {
-      if (metric.model_facing_secret_fingerprints > 0) return "A model saw secret-shaped material. The raccoon is screaming into a paper bag.";
-      if (metric.unique_secret_fingerprints > 0) return "Secrets are sitting in logs/config like snacks on a sidewalk.";
-      return "No obvious key barf. The raccoon found crumbs, not crimes.";
-    },
-    next(metric) {
-      if (metric.model_facing_secret_fingerprints > 0) return "rotate exposed keys, purge logs, and vault credentials before the next agent run";
-      if (metric.unique_secret_fingerprints > 0) return "move keys into a vault/env boundary and stop printing them into logs";
-      return "keep secrets out of prompts, tool args, pasted stack traces, and debug logs";
-    },
-    evidence(report) {
-      return report.evidence.secret_files_sample;
-    },
     explain: [
-      "raw keys = unique redacted fingerprints matched by known API-key patterns",
-      "model-facing keys = those fingerprints inside user/assistant/tool-call records",
-      "level = critical for model-facing material, high for raw secret material in logs/config",
-    ],
-  },
-  tokengoblin: {
-    id: "tokengoblin",
-    packageName: "tokengoblin",
-    binName: "tokengoblin",
-    metricKey: "context_efficiency",
-    emoji: "🧌",
-    npc: "Token Goblin",
-    tagline: "counts prompt calories, cache snacks, and context bloat burps.",
-    good: "lean prompt machine",
-    bad: "context buffet disaster",
-    commandHint: "npx tokengoblin",
-    score(metric) {
-      const levelBase = scoreFromLevel(metric.level);
-      const excessBoost = Math.min(35, metric.excess_fresh_input_percent || 0);
-      const cachePenalty = metric.cache_hit_percent < 20 && metric.fresh_input_tokens > 0 ? 10 : 0;
-      return clamp(levelBase + excessBoost + cachePenalty);
-    },
-    findings(metric, report) {
-      return [
-        finding("fresh/tool", `${formatNumber(metric.fresh_input_tokens_per_tool_call)} tokens`, metric.level),
-        finding("cache hit", `${metric.cache_hit_percent}%`, metric.cache_hit_percent >= 50 ? "LOW" : "MEDIUM"),
-        finding("excess", `${formatNumber(metric.excess_fresh_input_tokens)} fresh tokens over review line`),
-        finding("30d burn", `${formatNumber(report.monthly_impact_estimate.active_tokens_30d)} active tokens`),
-      ];
-    },
-    roast(metric) {
-      if (metric.level === "NO_DATA") return "No token footprints yet. Either pristine, empty, or wearing tiny socks.";
-      if (metric.fresh_input_tokens_per_tool_call >= metric.review_threshold_fresh_input_tokens_per_tool_call) return "Every tool call is dragging a suitcase full of prompt soup.";
-      if (metric.cache_hit_percent < 20 && metric.fresh_input_tokens > 0) return "The cache is basically a decorative bowl.";
-      return "Token goblin nibbled, but did not find a buffet catastrophe.";
-    },
-    next(metric) {
-      if (metric.level === "NO_DATA") return "run agents with token usage enabled, then ask the goblin again";
-      if (metric.fresh_input_tokens_per_tool_call >= metric.review_threshold_fresh_input_tokens_per_tool_call) return "trim repeated context, summarize durable state, and cache stable prompt chunks";
-      return "keep fresh input per tool low and move repeat loops into scripts/jobs";
-    },
-    evidence() {
-      return [];
-    },
-    explain: [
-      "fresh input = model input minus cached reads where providers expose caching",
-      "fresh/tool = sum(fresh input tokens) / tool calls",
-      "excess = fresh input above a conservative 4,000-token-per-tool review line",
+      "coverage = session log files with structured trace evidence / scanned session log files * 100",
+      "trace evidence includes trace_id, span_id, run_id, OpenTelemetry, or otel",
+      "goal: make local agent runs replayable without reading the whole transcript",
     ],
   },
   tooltantrum: {
@@ -142,37 +48,39 @@ const TOOL_CONFIGS = {
     packageName: "tooltantrum",
     binName: "tooltantrum",
     metricKey: "tool_reliability",
-    emoji: "🛠️",
-    npc: "Retry Possum",
-    tagline: "tool reliability: failure rate, retry recovery, and unresolved calls.",
-    good: "healthy tool reliability",
-    bad: "unresolved tool failures",
     commandHint: "npx tooltantrum",
+    tagline: "Tool-call reliability for local coding-agent sessions.",
+    good: "boringly stable",
+    bad: "tool meltdown",
     score(metric) {
+      if (metric.tool_calls === 0) return 0;
       return clamp(scoreFromLevel(metric.level) + Math.min(40, metric.failure_rate_percent));
     },
+    headline(metric) {
+      if (metric.tool_calls === 0) return "NO TOOLS ENTERED THE ARENA";
+      if (metric.unresolved_failures > 0) return "TOOLS ARE THROWING HANDS";
+      if (metric.failure_rate_percent >= 15) return "THE TOOLS ARE BLEEDING";
+      if (metric.failed_tool_calls > 0) return "A FEW TOOLS TRIPPED";
+      return "THE TOOLS BEHAVED";
+    },
+    summary(metric) {
+      if (metric.tool_calls === 0) return "No tool-call records were found, so there is nothing to score yet.";
+      if (metric.unresolved_failures > 0) {
+        return `${formatPercent(metric.failure_rate_percent)} of tool calls failed. Only ${formatPercent(metric.retry_recovery_percent)} of failures showed retry recovery, leaving ${formatCount(metric.unresolved_failures, "failure")} unresolved.`;
+      }
+      if (metric.failed_tool_calls > 0) {
+        return `${formatCount(metric.failed_tool_calls, "call")} failed, but the scanned retry signals recovered them.`;
+      }
+      return "No failed tool calls were detected in the scanned window.";
+    },
     findings(metric) {
       return [
-        finding("failure rate", `${metric.failure_rate_percent}%`, metric.level),
-        finding("failed", `${formatNumber(metric.failed_tool_calls)} / ${formatNumber(metric.tool_calls)} tool calls`),
-        finding("unresolved", `${formatNumber(metric.unresolved_failures)} failures never recovered`, metric.unresolved_failures > 0 ? metric.level : "LOW"),
-        finding("retry rescue", `${metric.retry_recovery_percent}% recovered after retry`),
+        finding("failure", formatPercent(metric.failure_rate_percent), metric.level),
+        finding("failed", `${formatNumber(metric.failed_tool_calls)} / ${formatNumber(metric.tool_calls)} calls`, metric.level),
+        finding("unresolved", `${formatNumber(metric.unresolved_failures)} unresolved`, metric.unresolved_failures > 0 ? metric.level : "LOW"),
+        finding("rescued", `${formatPercent(metric.retry_recovery_percent)} after retry`),
       ];
     },
-    roast(metric) {
-      if (metric.tool_calls === 0) return "No tool calls found, so there is nothing to score yet.";
-      if (metric.failure_rate_percent >= 30) return "Very high tool failure rate. Agents are losing too many actions before finishing.";
-      if (metric.unresolved_failures > 0) return "Most failed tool calls did not show a later recovery signal.";
-      return "Tool calls look stable; retry behavior is boring in the good way.";
-    },
-    next(metric) {
-      if (metric.tool_calls === 0) return "run an agent with tool usage, then scan again";
-      if (metric.unresolved_failures > 0) return "classify retryable errors, make actions idempotent, cap retries, and save failure artifacts";
-      return "keep retries boring: classify failures, cap attempts, and log recovery";
-    },
-    evidence(report) {
-      return report.evidence.diagnostics;
-    },
     explain: [
       "failure rate = failed_tool_calls / tool_calls * 100",
       "retry recovery = retry-after-failure signals / failed_tool_calls * 100",
@@ -196,29 +104,35 @@ export function buildToolReport(stats, options) {
   const color = colorizer(options.color);
   const full = toReportJson(stats, options);
   const metric = full.metrics[config.metricKey];
-  const chaosScore = config.score(metric, full);
-  const verdict = verdictFor(config, metric, chaosScore);
+  const score = config.score(metric, full);
+  const verdict = verdictFor(config, metric, score);
+  const headline = config.headline(metric, full);
+  const summary = config.summary(metric, full);
   const findings = config.findings(metric, full);
-  const evidence = config.evidence(full).slice(0, 5);
+  const sources = sourceEntries(config.id, full);
+  const share = renderShareCard(config, full, metric, score, headline, sources);
+
   const json = {
     version: options.version,
     package: config.packageName,
     command: config.commandHint,
-    npc: config.npc,
-    emoji: config.emoji,
     tagline: config.tagline,
     scanned: full.scanned,
     metric_key: config.metricKey,
     metric,
-    chaos_score: chaosScore,
+    score,
     verdict,
+    headline,
+    summary,
     findings: findings.map(({ label, value }) => ({ label, value })),
-    roast: config.roast(metric, full),
-    evidence_sample: evidence,
+    share,
+    source_breakdown: sources.map((entry) => entry.json),
   };
+
   return {
     json,
-    text: renderToolText(config, full, metric, findings, evidence, verdict, chaosScore, color),
+    share,
+    text: renderToolText(config, full, metric, verdict, score, headline, summary, color),
   };
 }
 
@@ -228,446 +142,172 @@ export function explainTool(toolId, options = {}) {
     version: options.version ?? "0.1.0",
     package: config.packageName,
     command: config.commandHint,
-    npc: config.npc,
     metric_key: config.metricKey,
     formulas: config.explain,
   };
   if (options.json) return JSON.stringify(payload, null, 2);
   return [
     `${config.packageName} explain v${payload.version}`,
-    `${config.emoji} ${config.npc}: ${config.tagline}`,
+    config.tagline,
     "",
     ...config.explain.map((line) => `- ${line}`),
   ].join("\n");
 }
 
-function renderToolText(config, full, metric, findings, evidence, verdict, chaosScore, color) {
+function renderToolText(config, full, metric, verdict, score, headline, summary, color) {
+  const sources = sourceEntries(config.id, full).filter((entry) => entry.showInText);
+  const sourceLabelWidth = Math.max(11, ...sources.map((entry) => entry.label.toLowerCase().length));
   const rows = [
-    reportText(`${config.packageName} postmortem`, color.title(`${config.packageName} postmortem`)),
-    reportText("──────────────────────────────", color.rule("──────────────────────────────")),
-    reportText(""),
-    reportSection("finding", color),
-    ...paragraphRows(toolFinding(config.id, metric), color, { level: metric.level ?? verdict.level }),
-    reportText(""),
-    reportSection("impact", color),
-    ...paragraphRows(toolImpact(config.id, full, metric), color),
-    reportText(""),
-    reportSection("agent leaderboard", color),
-    ...toolAgentLeaderboard(config.id, full, color),
-    reportText(""),
-    reportSection("numbers", color),
-    ...toolNumbers(config.id, full, metric, color),
+    ...heroRows(config, full, metric, score, headline, verdict, color),
+    blankRow(),
+    sectionRow("🚨 WORST OFFENDERS", color),
+    ...(sources.length > 0 ? sources.map((entry, index) => sourceRow(entry, color, index === 0, sourceLabelWidth)) : [detailRow("none", "no active sources found", color)]),
+    blankRow(),
+    sectionRow("STATS", color),
+    ...statRows(config.id, metric, verdict, score, color),
+    blankRow(),
+    sectionRow("SUMMARY", color),
+    ...paragraphRows(summary, color, { level: verdict.level }),
   ];
 
-  return rows.map((row) => row.painted).join("\n");
-}
-
-function toolFinding(toolId, metric) {
-  switch (toolId) {
-    case "suckytraces":
-      if (metric.session_log_files === 0) return "No session log files were found.";
-      return `Only ${formatPercent(metric.session_file_coverage_percent)} of scanned session logs include trace, run, or span IDs.`;
-    case "keybarf":
-      if (metric.model_facing_secret_fingerprints > 0) return "Secret fingerprints appeared in model-facing records.";
-      if (metric.unique_secret_fingerprints > 0) return "Secret fingerprints were found in local logs or config.";
-      return "No known secret fingerprints were found.";
-    case "tokengoblin":
-      if (metric.level === "NO_DATA") return "No token usage records were found.";
-      return `Fresh input averages ${formatNumber(metric.fresh_input_tokens_per_tool_call)} tokens per tool call.`;
-    case "tooltantrum":
-      if (metric.tool_calls === 0) return "No tool-call records were found.";
-      return `${formatPercent(metric.failure_rate_percent)} of tool calls failed; ${formatPercent(metric.retry_recovery_percent)} of failures showed retry recovery.`;
-    default:
-      return "No finding available.";
-  }
+  return `\n${rows.map((row) => (row.raw ? `  ${row.painted}` : "")).join("\n")}`;
 }
 
-function toolImpact(toolId, full, metric) {
-  switch (toolId) {
-    case "suckytraces": {
-      const missing = Math.max(0, metric.session_log_files - metric.traced_session_log_files);
-      if (metric.session_log_files === 0) return "There are no runs to assess yet.";
-      return `${formatNumber(missing)} session logs may be hard to replay or debug after the fact.`;
-    }
-    case "keybarf":
-      if (metric.model_facing_secret_fingerprints > 0) return "Credentials may need rotation because secret-like data reached model-facing context.";
-      if (metric.unique_secret_fingerprints > 0) return "Secret material is present where local tools or logs can retain it.";
-      return "No credential exposure was detected by the current patterns.";
-    case "tokengoblin":
-      if (metric.excess_fresh_input_tokens > 0) return `${formatNumber(metric.excess_fresh_input_tokens)} fresh input tokens exceeded the review threshold in the scanned window.`;
-      return "Fresh input stayed under the review threshold for the scanned window.";
-    case "tooltantrum":
-      if (metric.unresolved_failures > 0) return `${formatNumber(metric.unresolved_failures)} failed tool calls did not show a later recovery signal.`;
-      if (metric.failed_tool_calls > 0) return "Failures occurred, but scanned retry signals recovered them.";
-      return "No failed tool calls were detected in the scanned window.";
-    default:
-      return "No impact available.";
-  }
+function heroRows(config, full, metric, score, headline, verdict, color) {
+  const hero = `${heroEmoji(config.id, score)} ${headline}`;
+  return [
+    textRow(hero, color.level(hero, verdict.level)),
+    textRow(heroStatLine(config.id, metric, score), color.value(heroStatLine(config.id, metric, score))),
+    textRow(
+      `scanned ${formatNumber(full.scanned.sessions)} sessions · ${formatNumber(full.scanned.files)} files · ${scanWindow(full.scanned.days)}`,
+      color.muted(`scanned ${formatNumber(full.scanned.sessions)} sessions · ${formatNumber(full.scanned.files)} files · ${scanWindow(full.scanned.days)}`),
+    ),
+    ruleRow(color),
+  ];
 }
 
-function toolNumbers(toolId, full, metric, color) {
-  switch (toolId) {
-    case "suckytraces":
-      return [
-        metricLine("session logs scanned", formatNumber(metric.session_log_files), color),
-        metricLine("logs with trace/run ids", `${formatNumber(metric.traced_session_log_files)} / ${formatNumber(metric.session_log_files)}`, color, { level: metric.level }),
-        metricLine("trace coverage", formatPercent(metric.session_file_coverage_percent), color, { level: metric.level }),
-        metricLine("trace/run/span markers", formatNumber(metric.structured_trace_signals), color),
-      ];
-    case "keybarf":
-      return [
-        metricLine("unique fingerprints", formatNumber(metric.unique_secret_fingerprints), color, { level: metric.level }),
-        metricLine("model-facing", formatNumber(metric.model_facing_secret_fingerprints), color, { level: metric.model_facing_secret_fingerprints > 0 ? "CRITICAL" : "LOW" }),
-        metricLine("detected kinds", compactKinds(metric.by_kind), color),
-      ];
-    case "tokengoblin":
-      return [
-        metricLine("fresh input/tool", `${formatNumber(metric.fresh_input_tokens_per_tool_call)} tokens`, color, { level: metric.level }),
-        metricLine("review threshold", `${formatNumber(metric.review_threshold_fresh_input_tokens_per_tool_call)} tokens/tool`, color),
-        metricLine("cache hit rate", formatPercent(metric.cache_hit_percent), color, { level: metric.cache_hit_percent >= 50 ? "LOW" : "MEDIUM" }),
-        metricLine("excess fresh input", `${formatNumber(metric.excess_fresh_input_tokens)} tokens`, color, { level: metric.excess_fresh_input_tokens > 0 ? metric.level : "LOW" }),
-        metricLine("30d active tokens", formatNumber(full.monthly_impact_estimate.active_tokens_30d), color),
-      ];
-    case "tooltantrum": {
-      const recovered = Math.max(0, metric.failed_tool_calls - metric.unresolved_failures);
-      return [
-        metricLine("tool calls", formatNumber(metric.tool_calls), color),
-        metricLine("failed calls", formatNumber(metric.failed_tool_calls), color, { level: metric.failed_tool_calls > 0 ? metric.level : "LOW" }),
-        metricLine("failure rate", formatPercent(metric.failure_rate_percent), color, { level: metric.level }),
-        metricLine("recovered after retry", formatNumber(recovered), color, { level: recovered > 0 ? "LOW" : undefined }),
-        metricLine("unresolved failures", formatNumber(metric.unresolved_failures), color, { level: metric.unresolved_failures > 0 ? metric.level : "LOW" }),
-        metricLine("retry recovery rate", formatPercent(metric.retry_recovery_percent), color, { level: metric.retry_recovery_percent >= 80 ? "LOW" : "HIGH" }),
-      ];
-    }
-    default:
-      return [];
+function statRows(toolId, metric, verdict, score, color) {
+  if (toolId === "suckytraces") {
+    const missing = Math.max(0, metric.session_log_files - metric.traced_session_log_files);
+    return [
+      detailRow("severity", `${score}/100 · ${verdict.label}`, color, { level: verdict.level }),
+      detailRow("coverage", formatPercent(metric.session_file_coverage_percent), color, { level: metric.level }),
+      detailRow("with ids", `${formatNumber(metric.traced_session_log_files)} / ${formatNumber(metric.session_log_files)}`, color, { level: metric.level }),
+      detailRow("missing", formatNumber(missing), color, { level: missing > 0 ? metric.level : "LOW" }),
+      detailRow("signals", formatNumber(metric.structured_trace_signals), color),
+    ];
   }
-}
 
-function toolNextStep(toolId, metric) {
-  switch (toolId) {
-    case "suckytraces":
-      return "Write a run_id, trace_id, or span_id into each tool execution log.";
-    case "keybarf":
-      if (metric.model_facing_secret_fingerprints > 0) return "Rotate exposed credentials and move secrets behind environment or secret-manager boundaries.";
-      if (metric.unique_secret_fingerprints > 0) return "Move secrets out of logs/config and keep only redacted values in agent context.";
-      return "Keep secrets out of prompts, tool arguments, stack traces, and debug logs.";
-    case "tokengoblin":
-      if (metric.excess_fresh_input_tokens > 0) return "Trim repeated prompt context and cache stable input before tool-heavy runs.";
-      return "Keep fresh input per tool call below the review threshold.";
-    case "tooltantrum":
-      if (metric.unresolved_failures > 0) return "Classify retryable errors, make tool actions idempotent, and persist final failure details.";
-      return "Keep retry behavior explicit: classify errors, cap attempts, and log recovery.";
-    default:
-      return "Review the finding above.";
-  }
+  const recovered = Math.max(0, metric.failed_tool_calls - metric.unresolved_failures);
+  return [
+    detailRow("severity", `${score}/100 · ${verdict.label}`, color, { level: verdict.level }),
+    detailRow("calls", formatNumber(metric.tool_calls), color),
+    detailRow("failed", `${formatNumber(metric.failed_tool_calls)} (${formatPercent(metric.failure_rate_percent)})`, color, { level: metric.level }),
+    detailRow("rescued", `${formatNumber(recovered)} (${formatPercent(metric.retry_recovery_percent)})`, color),
+    detailRow("unresolved", formatNumber(metric.unresolved_failures), color, { level: metric.unresolved_failures > 0 ? metric.level : "LOW" }),
+  ];
 }
 
-function toolAgentLeaderboard(toolId, full, color) {
-  const ranked = rankAgents(toolId, full).slice(0, 5);
-  if (ranked.length === 0) return paragraphRows("No agent had enough data for a leaderboard.", color);
-  const best = ranked[0];
-  return ranked.map((entry) => {
-    const winner = sameRank(entry, best);
-    return leaderboardLine(winner ? `🏆 ${entry.label}` : `   ${entry.label}`, entry.value, color, winner);
-  });
+function sourceEntries(toolId, full) {
+  return activeSources(full)
+    .map((source) => sourceEntry(toolId, source))
+    .sort((a, b) => b.sort - a.sort || a.label.localeCompare(b.label));
 }
 
-function rankAgents(toolId, full) {
-  const sources = Object.values(full.scanned.sources ?? {})
-    .filter((source) => source.label !== "Agent config" && source.unavailable !== true);
+function sourceEntry(toolId, source) {
+  const files = source.files ?? 0;
+  const sessions = source.sessions ?? 0;
 
   if (toolId === "suckytraces") {
-    return sources
-      .filter((source) => eligibleAgent(toolId, source))
-      .map((source) => {
-        const percent = source.files > 0 ? Math.round(((source.traced_session_log_files ?? 0) / source.files) * 100) : 0;
-        return {
-          label: source.label,
-          sort: -percent,
-          value: `${percent}% coverage (${formatNumber(source.traced_session_log_files ?? 0)} / ${formatNumber(source.files)})`,
-        };
-      })
-      .sort(compareAgentRank);
-  }
-
-  if (toolId === "keybarf") {
-    return sources
-      .filter((source) => eligibleAgent(toolId, source))
-      .map((source) => {
-        const modelFacing = source.model_facing_secret_fingerprints ?? 0;
-        const total = Math.max(source.secret_fingerprints ?? 0, modelFacing);
-        return {
-          label: source.label,
-          sort: modelFacing,
-          tiebreaker: total,
-          value: `${formatNumber(modelFacing)} model-facing · ${formatNumber(total)} total`,
-        };
-      })
-      .sort(compareAgentRank);
-  }
-
-  if (toolId === "tokengoblin") {
-    return sources
-      .filter((source) => eligibleAgent(toolId, source))
-      .map((source) => {
-        const freshPerTool = Math.round((source.fresh_input_tokens ?? 0) / source.tool_calls);
-        return {
-          label: source.label,
-          sort: freshPerTool,
-          value: `${formatNumber(freshPerTool)} fresh input/tool`,
-        };
-      })
-      .sort(compareAgentRank);
-  }
-
-  if (toolId === "tooltantrum") {
-    return sources
-      .filter((source) => eligibleAgent(toolId, source))
-      .map((source) => {
-        const failureRate = round(((source.failed_tool_calls ?? 0) / source.tool_calls) * 100, 1);
-        return {
-          label: source.label,
-          sort: failureRate,
-          tiebreaker: source.failed_tool_calls ?? 0,
-          value: `${failureRate}% failure (${formatNumber(source.failed_tool_calls ?? 0)} / ${formatNumber(source.tool_calls)})`,
-        };
-      })
-      .sort(compareAgentRank);
+    const traced = source.traced_session_log_files ?? 0;
+    const missing = Math.max(0, files - traced);
+    const coverage = files > 0 ? round((traced / files) * 100, 1) : 0;
+    return {
+      label: source.label,
+      sort: ((100 - coverage) * 1_000_000) + files,
+      showInText: files > 0,
+      detail: `${formatPercent(coverage)} traced · ${formatNumber(missing)} missing · ${formatNumber(files)} files`,
+      json: { source: source.label, files, sessions, trace_coverage_percent: coverage, traced_session_log_files: traced, missing_trace_files: missing },
+    };
   }
 
-  return [];
+  const calls = source.tool_calls ?? 0;
+  const failed = source.failed_tool_calls ?? 0;
+  const failureRate = calls > 0 ? round((failed / calls) * 100, 1) : 0;
+  return {
+    label: source.label,
+    sort: (failureRate * 1_000_000) + failed,
+    showInText: calls > 0,
+    detail: `${formatPercent(failureRate)} fail · ${formatNumber(failed)}/${formatNumber(calls)} · ${formatNumber(sessions)} sessions`,
+    json: { source: source.label, files, sessions, tool_calls: calls, failed_tool_calls: failed, failure_rate_percent: failureRate },
+  };
 }
 
-function eligibleAgent(toolId, source) {
-  switch (toolId) {
-    case "suckytraces":
-      return (source.files ?? 0) >= 20;
-    case "keybarf":
-      return (source.files ?? 0) >= 20 || (source.sessions ?? 0) >= 20;
-    case "tokengoblin":
-      return (source.tool_calls ?? 0) >= 50 && (source.fresh_input_tokens ?? 0) > 0;
-    case "tooltantrum":
-      return (source.tool_calls ?? 0) >= 50;
-    default:
-      return false;
-  }
+function activeSources(full) {
+  return Object.values(full.scanned.sources ?? {}).filter((source) => {
+    if (source.label === "Agent config" || source.unavailable === true) return false;
+    return (source.files ?? 0) > 0 ||
+      (source.sessions ?? 0) > 0 ||
+      (source.tool_calls ?? 0) > 0 ||
+      (source.trace_signals ?? 0) > 0;
+  });
 }
 
-function compareAgentRank(a, b) {
-  if (a.sort !== b.sort) return a.sort - b.sort;
-  return (a.tiebreaker ?? 0) - (b.tiebreaker ?? 0);
-}
+function renderShareCard(config, full, metric, score, headline, sources) {
+  const top = sources.find((entry) => entry.showInText);
+  const lines = [
+    `${heroEmoji(config.id, score)} ${headline}`,
+    `Severity: ${score}/100`,
+    `Scanned: ${formatNumber(full.scanned.sessions)} sessions · ${formatNumber(full.scanned.files)} files · ${scanWindow(full.scanned.days)}`,
+  ];
 
-function sameRank(a, b) {
-  return a.sort === b.sort && (a.tiebreaker ?? 0) === (b.tiebreaker ?? 0);
-}
+  if (config.id === "suckytraces") {
+    const missing = Math.max(0, metric.session_log_files - metric.traced_session_log_files);
+    lines.push(`Stats: ${formatPercent(metric.session_file_coverage_percent)} traced · ${formatNumber(metric.traced_session_log_files)}/${formatNumber(metric.session_log_files)} logs with IDs · ${formatNumber(missing)} missing`);
+  } else {
+    lines.push(`Stats: ${formatPercent(metric.failure_rate_percent)} failed · ${formatNumber(metric.failed_tool_calls)}/${formatNumber(metric.tool_calls)} calls · ${formatNumber(metric.unresolved_failures)} unresolved · ${formatPercent(metric.retry_recovery_percent)} rescued`);
+  }
 
-function leaderboardLine(label, value, color, winner) {
-  const safeLabel = shortText(label, 26).padEnd(26);
-  const paintLabel = winner ? color.solution(safeLabel) : color.label(safeLabel);
-  const paintValue = winner ? color.solution(value) : color.value(value);
-  return { raw: `    ${safeLabel} ${value}`, painted: `    ${paintLabel} ${paintValue}` };
+  if (top) lines.push(`Worst: ${top.label} — ${top.detail}`);
+  return lines.join("\n");
 }
 
-function sectionTitle(toolId) {
-  switch (toolId) {
-    case "suckytraces":
-      return "trace coverage";
-    case "keybarf":
-      return "credential exposure";
-    case "tokengoblin":
-      return "context usage";
-    case "tooltantrum":
-      return "tool reliability";
-    default:
-      return "metrics";
-  }
+function heroTitle(toolId) {
+  return toolId === "suckytraces" ? "SUCKY TRACES" : "TOOL TANTRUM";
 }
 
-function compactStatus(toolId, metric) {
-  switch (toolId) {
-    case "suckytraces":
-      if (metric.session_log_files === 0) return "no session log files were found";
-      if (metric.session_file_coverage_percent >= 80) return "most session logs contain trace evidence";
-      if (metric.session_file_coverage_percent >= 30) return "some session logs contain trace evidence";
-      return "fewer than 30% of session logs contain trace evidence";
-    case "keybarf":
-      if (metric.model_facing_secret_fingerprints > 0) return "secret fingerprints reached model-facing records";
-      if (metric.unique_secret_fingerprints > 0) return "secret fingerprints were found in logs or config";
-      return "no secret fingerprints matched known patterns";
-    case "tokengoblin":
-      if (metric.level === "NO_DATA") return "no token usage records were found";
-      if (metric.fresh_input_tokens_per_tool_call >= metric.review_threshold_fresh_input_tokens_per_tool_call) return "fresh input per tool call exceeds the review threshold";
-      if (metric.cache_hit_percent < 20 && metric.fresh_input_tokens > 0) return "cache hit rate is low for observed input";
-      return "fresh input per tool call is within the review threshold";
-    case "tooltantrum":
-      return toolReliabilityStatus(metric);
-    default:
-      return "ok";
-  }
+function heroEmoji(toolId, score) {
+  if (score >= 75) return toolId === "suckytraces" ? "🕳️" : "🔥";
+  if (score >= 45) return "⚠️";
+  return "✅";
 }
 
-function toolReliabilityStatus(metric) {
-  if (metric.tool_calls === 0) return "no tool-call records were found";
-  if (metric.unresolved_failures > 0 && metric.retry_recovery_percent < 20) return "failed calls rarely show retry recovery";
-  if (metric.unresolved_failures > 0) return "some failed calls did not show recovery";
-  if (metric.failure_rate_percent >= 15) return "tool-call failure rate is high";
-  if (metric.failure_rate_percent >= 5) return "tool-call failure rate is moderate";
-  return "tool-call failure rate is low";
+function heroStatLine(toolId, metric, score) {
+  if (toolId === "suckytraces") {
+    const missing = Math.max(0, metric.session_log_files - metric.traced_session_log_files);
+    return `${score}/100 SEVERITY · ${formatPercent(metric.session_file_coverage_percent)} TRACED · ${formatNumber(missing)} MISSING`;
+  }
+  return `${score}/100 SEVERITY · ${formatPercent(metric.failure_rate_percent)} FAILED · ${formatNumber(metric.unresolved_failures)} UNRESOLVED`;
 }
 
 function verdictFor(config, metric, score) {
-  const level = metric.level ?? scoreLevel(score);
-  if (score >= 75 || level === "CRITICAL" || level === "MISSING") return { level, label: config.bad, mood: "bad" };
-  if (score >= 45 || level === "HIGH") return { level, label: "spicy enough to investigate", mood: "spicy" };
-  if (score >= 20 || level === "MEDIUM" || level === "PARTIAL") return { level, label: "a little haunted", mood: "haunted" };
-  return { level, label: config.good, mood: "good" };
+  const level = scoreLevel(score, metric.level);
+  if (score >= 75 || level === "CRITICAL" || level === "MISSING") return { level, label: config.bad };
+  if (score >= 45 || level === "HIGH") return { level, label: "serious" };
+  if (score >= 20 || level === "MEDIUM" || level === "PARTIAL") return { level, label: "watch" };
+  return { level, label: config.good };
 }
 
-function scoreLevel(score) {
+function scoreLevel(score, fallback) {
+  const normalized = String(fallback ?? "").toUpperCase();
+  if (normalized === "CRITICAL" || normalized === "MISSING") return normalized;
   if (score >= 75) return "CRITICAL";
   if (score >= 45) return "HIGH";
   if (score >= 20) return "MEDIUM";
+  if (normalized === "NO_DATA" || normalized === "CONFIG_ONLY") return normalized;
   return "LOW";
 }
 
-function finding(label, value, level) {
-  return { label, value, level };
-}
-
-function pairRow(label, value, color, options = {}) {
-  const safeLabel = String(label).slice(0, 12);
-  const raw = `${safeLabel.padEnd(12)} ${value}`;
-  const paintValue = options.solution ? color.solution(value) : options.level ? color.level(value, options.level) : color.value(value);
-  return { raw, painted: `${color.label(safeLabel.padEnd(12))} ${paintValue}` };
-}
-
-function reportLine(label, value, color, options = {}) {
-  const labelWidth = options.labelWidth ?? 14;
-  const indent = " ".repeat(options.indent ?? 2);
-  const safeLabel = String(label).toLowerCase().slice(0, labelWidth);
-  const raw = `${indent}${safeLabel.padEnd(labelWidth)} ${value}`;
-  const paintValue = options.solution ? color.solution(value) : options.level ? color.level(value, options.level) : color.value(value);
-  return { raw, painted: `${indent}${color.label(safeLabel.padEnd(labelWidth))} ${paintValue}` };
-}
-
-function metricLine(label, value, color, options = {}) {
-  return reportLine(label, value, color, { ...options, indent: 4, labelWidth: 28 });
-}
-
-function reportSection(label, color) {
-  return reportText(String(label).toLowerCase(), color.title(String(label).toLowerCase()));
-}
-
-function paragraphRows(value, color, options = {}) {
-  const indent = "    ";
-  return wrapText(String(value), 76).map((line) => {
-    const paintValue = options.solution ? color.solution(line) : options.level ? color.level(line, options.level) : color.value(line);
-    return { raw: `${indent}${line}`, painted: `${indent}${paintValue}` };
-  });
-}
-
-function reportText(raw, painted = raw) {
-  return { raw, painted: raw ? `  ${painted}` : "" };
-}
-
-function wrappedPairRows(label, value, color, options = {}) {
-  const labelWidth = 12;
-  const width = options.width ?? 74;
-  const textWidth = Math.max(20, width - labelWidth - 1);
-  const lines = wrapText(String(value), textWidth);
-  return lines.map((line, index) => {
-    const visibleLabel = index === 0 ? String(label).slice(0, labelWidth) : "";
-    const paintValue = options.solution ? color.solution(line) : options.level ? color.level(line, options.level) : color.value(line);
-    return {
-      raw: `${visibleLabel.padEnd(labelWidth)} ${line}`,
-      painted: `${color.label(visibleLabel.padEnd(labelWidth))} ${paintValue}`,
-    };
-  });
-}
-
-function ruleRow() {
-  return { rule: true, raw: "", painted: "" };
-}
-
-function textRow(raw, painted = raw) {
-  return { raw, painted };
-}
-
-function blankRow() {
-  return { raw: "", painted: "" };
-}
-
-function box(title, rows, color) {
-  const width = Math.max(48, title.length + 4, ...rows.map((row) => row.raw.length));
-  const topFill = "─".repeat(Math.max(1, width - title.length - 1));
-  const bottomFill = "─".repeat(width + 2);
-  return [
-    `${color.border("╭─")} ${color.title(title)} ${color.border(`${topFill}╮`)}`,
-    ...rows.map((row) => boxRow(row, width, color)),
-    `${color.border("╰")}${color.border(bottomFill)}${color.border("╯")}`,
-  ].join("\n");
-}
-
-function boxRow(row, width, color) {
-  const padding = " ".repeat(Math.max(0, width - row.raw.length));
-  return `${color.border("│")} ${row.painted}${padding} ${color.border("│")}`;
-}
-
-function fixedBox(title, rows, color, width) {
-  const topFill = "─".repeat(Math.max(1, width - title.length - 1));
-  const bottomFill = "─".repeat(width + 2);
-  return [
-    `${color.border("╭─")} ${color.title(title)} ${color.border(`${topFill}╮`)}`,
-    ...rows.map((row) => fixedBoxRow(row, width, color)),
-    `${color.border("╰")}${color.border(bottomFill)}${color.border("╯")}`,
-  ].join("\n");
-}
-
-function fixedBoxRow(row, width, color) {
-  if (row.rule) return `${color.border("├")}${color.border("─".repeat(width + 2))}${color.border("┤")}`;
-  const raw = row.raw.length > width ? `${row.raw.slice(0, Math.max(0, width - 1))}…` : row.raw;
-  const painted = row.raw.length > width ? raw : row.painted;
-  const padding = " ".repeat(Math.max(0, width - raw.length));
-  return `${color.border("│")} ${painted}${padding} ${color.border("│")}`;
-}
-
-function largestFileLine(files) {
-  if (!Array.isArray(files) || files.length === 0) return "none";
-  const file = files[0];
-  if (typeof file === "string") return compactPath(file);
-  return `${compactPath(file.path ?? file.file ?? "unknown")} (${formatNumber(file.lines ?? 0)} lines)`;
-}
-
-function compactPath(value) {
-  const text = String(value ?? "unknown");
-  if (text.length <= 30) return text;
-  const tail = text.split(/[\\/]/).slice(-2).join("/");
-  return `…/${tail}`;
-}
-
-function compactKinds(kinds) {
-  const value = Object.entries(kinds ?? {})
-    .filter(([, count]) => count > 0)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 4)
-    .map(([kind, count]) => `${kind}:${count}`)
-    .join(", ");
-  return value || "none";
-}
-
-function rootSummary(roots) {
-  if (!Array.isArray(roots) || roots.length === 0) return "0";
-  return shortText(`${roots.length} (${roots.slice(0, 3).join(", ")}${roots.length > 3 ? ", …" : ""})`, 44);
-}
-
-function shortText(value, max) {
-  const text = String(value ?? "");
-  if (text.length <= max) return text;
-  return `${text.slice(0, Math.max(0, max - 1))}…`;
-}
-
 function scoreFromLevel(level) {
   switch (String(level).toUpperCase()) {
     case "CRITICAL":
@@ -678,44 +318,57 @@ function scoreFromLevel(level) {
     case "MEDIUM":
     case "PARTIAL":
       return 34;
-    case "CONFIG_ONLY":
-    case "NO_DATA":
-      return 12;
     default:
       return 5;
   }
 }
 
-function clamp(value) {
-  return Math.max(0, Math.min(100, Math.round(Number(value) || 0)));
+function finding(label, value, level) {
+  return { label, value, level };
 }
 
-function round(value, digits) {
-  const factor = 10 ** digits;
-  return Math.round(value * factor) / factor;
+function textRow(raw, painted = raw) {
+  return { raw, painted };
 }
 
-function scanWindow(days) {
-  return days === "all" ? "all sessions" : `last ${days}d`;
+function blankRow() {
+  return { raw: "", painted: "" };
 }
 
-function formatNumber(value) {
-  return Number(value || 0).toLocaleString("en-US");
+function ruleRow(color) {
+  const rule = "━".repeat(58);
+  return textRow(rule, color.rule(rule));
 }
 
-function formatPercent(value) {
-  const number = Number(value || 0);
-  return `${number.toFixed(Number.isInteger(number) ? 0 : 1)}%`;
+function sectionRow(title, color) {
+  return textRow(title, color.title(title));
+}
+
+function detailRow(label, value, color, options = {}) {
+  const safeLabel = String(label).toLowerCase().padEnd(11);
+  const raw = `  ${safeLabel} ${value}`;
+  const paintValue = options.level ? color.level(value, options.level) : color.value(value);
+  return textRow(raw, `  ${color.label(safeLabel)} ${paintValue}`);
 }
 
-function progressBar(value, max, width) {
-  const ratio = Math.max(0, Math.min(1, Number(value || 0) / Math.max(1, max)));
-  const filled = Math.max(value > 0 ? 1 : 0, Math.round(ratio * width));
-  return `${"█".repeat(Math.min(width, filled))}${"░".repeat(Math.max(0, width - filled))}`;
+function sourceRow(entry, color, highlight = false, labelWidth = 11) {
+  const prefix = highlight ? "🚨 " : "   ";
+  const label = `${prefix}${entry.label.toLowerCase()}`.padEnd(labelWidth + prefix.length);
+  const raw = `  ${label} ${entry.detail}`;
+  if (!highlight) return textRow(raw, `  ${color.label(label)} ${color.value(entry.detail)}`);
+  return textRow(raw, `  ${color.level(label, "CRITICAL")} ${color.level(entry.detail, "CRITICAL")}`);
 }
 
-function scoreSparkline(score) {
-  return progressBar(score, 100, 12);
+function mutedRow(raw, color) {
+  return textRow(raw, color.muted(raw));
+}
+
+function paragraphRows(value, color, options = {}) {
+  return wrapText(String(value), 58).map((line) => {
+    const raw = `  ${line}`;
+    const paintedValue = options.level ? color.level(line, options.level) : color.value(line);
+    return textRow(raw, `  ${paintedValue}`);
+  });
 }
 
 function wrapText(value, width) {
@@ -723,14 +376,6 @@ function wrapText(value, width) {
   const lines = [];
   let line = "";
   for (const word of words) {
-    if (word.length > width) {
-      if (line) {
-        lines.push(line);
-        line = "";
-      }
-      lines.push(word.slice(0, width));
-      continue;
-    }
     if (!line) {
       line = word;
       continue;
@@ -746,21 +391,40 @@ function wrapText(value, width) {
   return lines.length > 0 ? lines : [""];
 }
 
-function formatSeconds(ms) {
-  const seconds = Math.max(0.1, Number(ms || 0) / 1000);
-  return `${seconds.toFixed(seconds >= 10 ? 0 : 1)}s`;
+function scanWindow(days) {
+  return days === "all" ? "all sessions" : `last ${days}d`;
+}
+
+function clamp(value) {
+  return Math.max(0, Math.min(100, Math.round(Number(value) || 0)));
+}
+
+function round(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function formatNumber(value) {
+  return Number(value || 0).toLocaleString("en-US");
+}
+
+function formatCount(value, singular, plural = `${singular}s`) {
+  const number = Number(value || 0);
+  return `${formatNumber(number)} ${number === 1 ? singular : plural}`;
+}
+
+function formatPercent(value) {
+  const number = Number(value || 0);
+  return `${number.toFixed(Number.isInteger(number) ? 0 : 1)}%`;
 }
 
 function colorizer(enabled) {
   if (!enabled) return plainColors();
   const paint = (code, value) => `\x1b[${code}m${value}\x1b[0m`;
   return {
-    accent: (value) => paint("38;2;147;197;253", value),
-    border: (value) => paint("38;2;100;116;139", value),
     label: (value) => paint("38;2;186;230;253", value),
     muted: (value) => paint("38;2;148;163;184", value),
-    rule: (value) => paint("38;2;71;85;105", value),
-    solution: (value) => paint("38;2;125;211;252", value),
+    rule: (value) => paint("38;2;51;65;85", value),
     title: (value) => paint("38;2;147;197;253;1", value),
     value: (value) => paint("38;2;226;232;240", value),
     level: (value, level) => paint(levelColor(level), value),
@@ -769,12 +433,9 @@ function colorizer(enabled) {
 
 function plainColors() {
   return {
-    accent: (value) => value,
-    border: (value) => value,
     label: (value) => value,
     muted: (value) => value,
     rule: (value) => value,
-    solution: (value) => value,
     title: (value) => value,
     value: (value) => value,
     level: (value) => value,