edsger 0.82.0 → 0.84.0

package/dist/index.js

@@ -4,12 +4,12 @@
 import { readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
 import { Command, Option } from "commander";
-import pc9 from "picocolors";
+import pc12 from "picocolors";
 
-// src/commands/benchmark.ts
+// src/commands/audit.ts
 import { appendFileSync, mkdirSync, writeFileSync } from "fs";
-import { basename, join as join3 } from "path";
-import pc3 from "picocolors";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join5 } from "path";
+import pc4 from "picocolors";
 
 // src/core/assets.ts
 import { execFileSync } from "child_process";
@@ -127,7 +127,8 @@ function resolveStandard(kind, opts, config, configDir, forcedLanguages) {
   const roots = [
     { path: bundled, label: opts.assetsPath ? `assets:${opts.assetsPath}` : "bundled" }
   ];
-  const overrideSpec = (kind === "benchmark" ? config.benchmark?.standards : config.review?.standards) ?? config.standards;
+  const perKind = kind === "benchmark" ? config.benchmark?.standards : kind === "diagrams" ? config.diagrams?.standards : kind === "mindmap" ? config.mindmap?.standards : kind === "audit" ? config.audit?.standards : config.review?.standards;
+  const overrideSpec = perKind ?? config.standards;
   if (overrideSpec && !opts.assetsPath) {
     roots.push({ path: resolveRootPath(overrideSpec, configDir), label: `config:${overrideSpec}` });
   }
@@ -175,11 +176,68 @@ function mergeLayers(kind, layers) {
       {}
     );
   }
+  if (kind === "diagrams") {
+    return layers.reduce(
+      (acc, layer) => mergeDiagrams(acc, layer),
+      {}
+    );
+  }
+  if (kind === "mindmap") {
+    return layers.reduce(
+      (acc, layer) => mergeMindmap(acc, layer),
+      {}
+    );
+  }
+  if (kind === "audit") {
+    return layers.reduce(
+      (acc, layer) => mergeAudit(acc, layer),
+      {}
+    );
+  }
   return layers.reduce(
     (acc, layer) => mergeReview(acc, layer),
     {}
   );
 }
+function mergeDiagrams(base, overlay) {
+  const groups = mergeById(base.groups ?? [], overlay.groups ?? [], (b, o) => ({
+    ...b,
+    ...o,
+    // Diagrams with the same id are overridden; new ids are appended.
+    diagrams: mergeById(b.diagrams ?? [], o.diagrams ?? [], (bd, od) => ({
+      ...bd,
+      ...od
+    }))
+  }));
+  return {
+    ...base,
+    ...overlay,
+    // Preserve the base layer's identity rather than the last overlay's.
+    id: base.id ?? overlay.id,
+    name: base.name ?? overlay.name,
+    version: base.version ?? overlay.version,
+    kind: "diagrams",
+    groups
+  };
+}
+function mergeMindmap(base, overlay) {
+  const aspects = mergeById(base.aspects ?? [], overlay.aspects ?? [], (b, o) => ({
+    ...b,
+    ...o
+  }));
+  return {
+    ...base,
+    ...overlay,
+    // Preserve the base layer's identity rather than the last overlay's.
+    id: base.id ?? overlay.id,
+    name: base.name ?? overlay.name,
+    version: base.version ?? overlay.version,
+    kind: "mindmap",
+    guidance: overlay.guidance ?? base.guidance,
+    maxDepth: overlay.maxDepth ?? base.maxDepth,
+    aspects
+  };
+}
 function mergeBenchmark(base, overlay) {
   const categories = mergeById(
     base.categories ?? [],
@@ -205,6 +263,25 @@ function mergeBenchmark(base, overlay) {
     categories
   };
 }
+function mergeAudit(base, overlay) {
+  const dimensions = mergeById(
+    base.dimensions ?? [],
+    overlay.dimensions ?? [],
+    (b, o) => ({ ...b, ...o })
+  );
+  return {
+    ...base,
+    ...overlay,
+    // Preserve the base layer's identity rather than the last overlay's.
+    id: base.id ?? overlay.id,
+    name: base.name ?? overlay.name,
+    version: base.version ?? overlay.version,
+    kind: "audit",
+    guidance: overlay.guidance ?? base.guidance,
+    policy: { ...base.policy ?? {}, ...overlay.policy ?? {} },
+    dimensions
+  };
+}
 function mergeReview(base, overlay) {
   const focusAreas = mergeById(
     base.focusAreas ?? [],
@@ -490,6 +567,121 @@ function summarizeTool(name = "tool", input = {}) {
   }
 }
 
+// src/core/dashboard.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+function assembleFrom(dir, latestFile) {
+  const latest = readJson(join3(dir, latestFile));
+  const history = readJsonl(join3(dir, "history.jsonl"));
+  const runs = {};
+  const runsDir = join3(dir, "runs");
+  if (existsSync3(runsDir)) {
+    for (const entry of readdirSync2(runsDir)) {
+      const report = readJson(join3(runsDir, entry, latestFile));
+      if (report) runs[entry] = report;
+    }
+  }
+  const repo = latest && typeof latest === "object" && "repo" in latest ? latest.repo : void 0;
+  return { repo, latest, history, runs };
+}
+function assembleData(benchmarkDir) {
+  return assembleFrom(benchmarkDir, "report.json");
+}
+function assembleDiagramData(diagramsDir) {
+  return assembleFrom(diagramsDir, "diagrams.json");
+}
+function assembleMindmapData(mindmapDir) {
+  return assembleFrom(mindmapDir, "mindmap.json");
+}
+function assembleAuditData(auditDir) {
+  return assembleFrom(auditDir, "report.json");
+}
+function hasData(data) {
+  return Boolean(data.latest) || data.history.length > 0;
+}
+function findViewerDir(subdir = "viewer", index = "index.html") {
+  const dir = join3(findBundledAssetsDir(), subdir);
+  if (!existsSync3(join3(dir, index))) {
+    throw new Error(
+      `Dashboard viewer assets not found (${subdir}/${index}). Reinstall edsger, or run \`npm run sync-viewer\` in a dev checkout.`
+    );
+  }
+  return dir;
+}
+function findDiagramViewerDir() {
+  return findViewerDir("diagrams-viewer", "diagrams.html");
+}
+function findMindmapViewerDir() {
+  return findViewerDir("mindmap-viewer", "mindmap.html");
+}
+function findAuditViewerDir() {
+  return findViewerDir("audit-viewer", "audit.html");
+}
+function readSingleTemplate(file) {
+  const path = join3(findBundledAssetsDir(), file);
+  if (!existsSync3(path)) {
+    throw new Error(
+      `Single-file viewer template not found (${file}). Reinstall edsger, or run \`npm run sync-viewer\`.`
+    );
+  }
+  return readFileSync2(path, "utf8");
+}
+function readViewerSingleTemplate() {
+  return readSingleTemplate("viewer-single.html");
+}
+function readDiagramViewerSingleTemplate() {
+  return readSingleTemplate("diagrams-viewer-single.html");
+}
+function readMindmapViewerSingleTemplate() {
+  return readSingleTemplate("mindmap-viewer-single.html");
+}
+function readAuditViewerSingleTemplate() {
+  return readSingleTemplate("audit-viewer-single.html");
+}
+function renderSingleFileWith(template, data, globalName) {
+  const json = JSON.stringify(data).replace(/<\//g, "<\\/");
+  const tag = `<script>window.${globalName}=${json}</script>`;
+  const placeholder = new RegExp(`<!--[^>]*${globalName}[^>]*-->`);
+  if (placeholder.test(template)) return template.replace(placeholder, () => tag);
+  const scriptIdx = template.indexOf("<script");
+  if (scriptIdx !== -1) return template.slice(0, scriptIdx) + tag + template.slice(scriptIdx);
+  const headIdx = template.lastIndexOf("</head>");
+  if (headIdx !== -1) return template.slice(0, headIdx) + tag + template.slice(headIdx);
+  return tag + template;
+}
+function renderSingleFile(template, data) {
+  return renderSingleFileWith(template, data, "__EDSGER_DATA__");
+}
+function renderDiagramsSingleFile(template, data) {
+  return renderSingleFileWith(template, data, "__EDSGER_DIAGRAMS__");
+}
+function renderMindmapSingleFile(template, data) {
+  return renderSingleFileWith(template, data, "__EDSGER_MINDMAP__");
+}
+function renderAuditSingleFile(template, data) {
+  return renderSingleFileWith(template, data, "__EDSGER_AUDIT__");
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readJsonl(path) {
+  if (!existsSync3(path)) return [];
+  const out = [];
+  for (const line of readFileSync2(path, "utf8").split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {
+    }
+  }
+  return out;
+}
+
 // src/core/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
 function tryGit(args, cwd) {
@@ -514,151 +706,220 @@ function gitInfo(cwd) {
   };
 }
 
-// src/core/report.ts
-function scoreBenchmark(standard, result) {
-  const scale = standard.scoreScale || 4;
-  const totalWeight = standard.categories.reduce((s, c) => s + c.weight, 0) || 1;
-  const tail = (id) => id.slice(id.lastIndexOf("/") + 1);
-  const byKey = /* @__PURE__ */ new Map();
-  const byCrit = /* @__PURE__ */ new Map();
-  for (const cat of result.categories) {
-    for (const cr of cat.criteria) {
-      const meta = {
-        score: cr.score,
-        justification: cr.justification,
-        evidence: cr.evidence ?? []
-      };
-      byKey.set(`${tail(cat.id)}/${tail(cr.id)}`, meta);
-      byCrit.set(tail(cr.id), meta);
-    }
+// src/core/open.ts
+import { spawn } from "child_process";
+function openInBrowser(target) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", target] : [target];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {
   }
-  let matched = 0;
-  const categories = standard.categories.map((cat) => {
-    const critWeightTotal = cat.criteria.reduce((s, c) => s + (c.weight ?? 1), 0) || 1;
-    const scored = cat.criteria.map((cr) => {
-      const meta = byKey.get(`${tail(cat.id)}/${tail(cr.id)}`) ?? byCrit.get(tail(cr.id));
-      if (meta) matched += 1;
-      const raw = clamp(meta?.score ?? 0, 0, scale);
-      return {
-        id: cr.id,
-        title: cr.title,
-        weight: cr.weight ?? 1,
-        rawScore: raw,
-        maxScore: scale,
-        fraction: raw / scale,
-        justification: meta?.justification ?? "Not assessed.",
-        evidence: meta?.evidence ?? []
-      };
+}
+
+// src/core/viewer-server.ts
+import { createReadStream, existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { createServer } from "http";
+import { extname, join as join4, normalize } from "path";
+import pc3 from "picocolors";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".map": "application/json",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff"
+};
+async function startViewerServer(opts) {
+  const server = createServer((req, res) => {
+    const url = (req.url ?? "/").split("?")[0] ?? "/";
+    if (url === opts.dataRoute) {
+      res.writeHead(200, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store"
+      });
+      res.end(JSON.stringify(opts.getData()));
+      return;
+    }
+    const rel = url === "/" ? opts.indexFile : decodeURIComponent(url.replace(/^\/+/, ""));
+    const safe = normalize(rel).replace(/^(\.\.(?:[/\\]|$))+/, "");
+    let file = join4(opts.viewerDir, safe);
+    if (!file.startsWith(opts.viewerDir)) {
+      res.writeHead(403);
+      res.end("forbidden");
+      return;
+    }
+    if (!existsSync4(file) || statSync2(file).isDirectory())
+      file = join4(opts.viewerDir, opts.indexFile);
+    res.writeHead(200, { "content-type": MIME[extname(file)] ?? "application/octet-stream" });
+    createReadStream(file).pipe(res);
+  });
+  return new Promise((resolve3, reject) => {
+    server.on("error", reject);
+    server.listen(opts.port, opts.host, () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : opts.port;
+      const shownHost = opts.host === "0.0.0.0" ? "localhost" : opts.host;
+      const url = `http://${shownHost}:${port}/`;
+      if (opts.emptyHint) log.warn(opts.emptyHint);
+      log.success(`Dashboard at ${pc3.bold(pc3.cyan(url))}  ${pc3.dim("(Ctrl-C to stop)")}`);
+      if (opts.open) openInBrowser(url);
     });
-    const fraction = scored.reduce((s, c) => s + c.fraction * c.weight, 0) / critWeightTotal;
-    const normWeight = cat.weight / totalWeight * 100;
-    return {
-      id: cat.id,
-      name: cat.name,
-      weight: round(normWeight, 1),
-      fraction,
-      points: round(normWeight * fraction, 1),
-      criteria: scored
+    const shutdown = () => {
+      server.close(() => resolve3(0));
     };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
   });
-  const totalCriteria = standard.categories.reduce((s, c) => s + c.criteria.length, 0);
-  if (result.categories.length > 0 && matched === 0) {
-    log.warn(
-      "The agent returned scores but none matched the rubric's criterion ids \u2014 reporting 0. This is a scoring bug, not a real result."
-    );
-  } else if (matched < totalCriteria) {
-    log.warn(`Only ${matched}/${totalCriteria} criteria were scored; the rest default to 0.`);
+}
+
+// src/core/audit-report.ts
+var SEVERITY_ORDER = ["critical", "high", "medium", "low", "info"];
+var DEFAULT_MAX_FINDINGS = 60;
+var SEVERITY_RANK = {
+  critical: 4,
+  high: 3,
+  medium: 2,
+  low: 1,
+  info: 0
+};
+function organizeAudit(standard, result) {
+  const merged = mergeDuplicates(result.findings ?? []);
+  merged.sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]);
+  const cap = Math.max(1, standard.policy?.maxFindings ?? DEFAULT_MAX_FINDINGS);
+  const omitted = Math.max(0, merged.length - cap);
+  const findings = merged.slice(0, cap);
+  const known = new Map(standard.dimensions.map((d) => [d.id, d.title]));
+  const groups = standard.dimensions.map((d) => ({
+    id: d.id,
+    title: d.title,
+    findings: []
+  }));
+  const other = { id: "other", title: "Other", findings: [] };
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  for (const f of findings) {
+    (known.has(f.dimension) ? byId.get(f.dimension) : other).findings.push(f);
   }
-  const overall = round(
-    categories.reduce((s, c) => s + c.points, 0),
-    1
-  );
+  if (other.findings.length) groups.push(other);
+  const counts = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+  for (const f of findings) counts[f.severity]++;
+  const quickWins = findings.filter((f) => f.effort === "quick" && f.severity !== "info");
   return {
     standardName: standard.name,
     standardVersion: standard.version,
-    overall,
-    grade: gradeFor(overall),
-    categories,
     summary: result.summary,
-    strengths: result.strengths ?? [],
-    weaknesses: result.weaknesses ?? [],
-    recommendations: result.recommendations ?? []
+    positives: result.positives ?? [],
+    findings,
+    groups: groups.filter((g) => g.findings.length > 0),
+    counts,
+    total: findings.length,
+    omitted,
+    quickWins
   };
 }
-function gradeFor(score) {
-  if (score >= 90) return "A";
-  if (score >= 80) return "B";
-  if (score >= 70) return "C";
-  if (score >= 60) return "D";
-  return "F";
+function mergeDuplicates(findings) {
+  const byKey = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const f of findings) {
+    const key = `${f.dimension}\0${f.title.trim().toLowerCase()}`;
+    const seen = byKey.get(key);
+    if (!seen) {
+      const first = { ...f, moreLocations: [] };
+      byKey.set(key, first);
+      out.push(first);
+      continue;
+    }
+    const [primary, extra] = SEVERITY_RANK[f.severity] > SEVERITY_RANK[seen.severity] ? [{ ...f, moreLocations: seen.moreLocations }, seen] : [seen, f];
+    const loc = locationKey(extra);
+    const primaryLoc = locationKey(primary);
+    if (loc && loc !== primaryLoc && !primary.moreLocations.includes(loc)) {
+      primary.moreLocations.push(loc);
+    }
+    if (primary !== seen) {
+      out[out.indexOf(seen)] = primary;
+      byKey.set(key, primary);
+    }
+  }
+  return out;
 }
-function renderBenchmarkMarkdown(scored, meta) {
+function hasFindingsAtOrAbove(organized, threshold) {
+  return organized.findings.some((f) => SEVERITY_RANK[f.severity] >= SEVERITY_RANK[threshold]);
+}
+function renderAuditMarkdown(organized, meta) {
   const lines = [];
-  lines.push(`# Edsger Benchmark Report`);
-  lines.push("");
-  lines.push(`**Score: ${scored.overall} / 100 (Grade ${scored.grade})**`);
+  lines.push(`# Edsger Audit Report`);
   lines.push("");
-  lines.push(`> ${scored.summary}`);
+  lines.push(`> ${organized.summary}`);
   lines.push("");
   lines.push(`| Field | Value |`);
   lines.push(`| --- | --- |`);
   lines.push(`| Repository | \`${meta.repo}\` |`);
   lines.push(`| Languages | ${meta.languages.join(", ") || "n/a"} |`);
-  lines.push(`| Standard | ${scored.standardName} v${scored.standardVersion} |`);
+  lines.push(`| Standard | ${organized.standardName} v${organized.standardVersion} |`);
   lines.push(`| Sources | ${meta.layers.join(" \u2192 ")} |`);
   lines.push(`| Model | ${meta.model} |`);
   lines.push(`| Generated | ${meta.generatedAt} |`);
   lines.push("");
-  lines.push(`## Category scores`);
+  lines.push(`## Findings by severity`);
   lines.push("");
-  lines.push(`| Category | Weight | Score | Weighted |`);
-  lines.push(`| --- | ---: | ---: | ---: |`);
-  for (const c of scored.categories) {
-    lines.push(`| ${c.name} | ${c.weight}% | ${Math.round(c.fraction * 100)}% | ${c.points} |`);
+  lines.push(`| Severity | Count |`);
+  lines.push(`| --- | ---: |`);
+  for (const s of SEVERITY_ORDER) {
+    if (organized.counts[s]) lines.push(`| ${s} | ${organized.counts[s]} |`);
   }
-  lines.push(`| **Overall** | **100%** | | **${scored.overall}** |`);
+  lines.push(`| **total** | **${organized.total}** |`);
   lines.push("");
-  if (scored.strengths.length) {
-    lines.push(`## Strengths`);
-    lines.push("");
-    for (const s of scored.strengths) lines.push(`- ${s}`);
+  if (organized.omitted > 0) {
+    lines.push(
+      `_${organized.omitted} lower-severity finding(s) omitted by the standard's maxFindings policy._`
+    );
     lines.push("");
   }
-  if (scored.weaknesses.length) {
-    lines.push(`## Weaknesses`);
+  if (organized.quickWins.length) {
+    lines.push(`## Quick wins`);
     lines.push("");
-    for (const w of scored.weaknesses) lines.push(`- ${w}`);
+    for (const f of organized.quickWins) {
+      lines.push(`- **[${f.severity}] ${f.title}** \u2014 ${location(f)}`);
+    }
     lines.push("");
   }
-  if (scored.recommendations.length) {
-    lines.push(`## Recommendations`);
+  lines.push(`## Findings by dimension`);
+  lines.push("");
+  for (const g of organized.groups) {
+    lines.push(`### ${g.title} (${g.findings.length})`);
     lines.push("");
-    for (const r of scored.recommendations) {
-      lines.push(`- **[${r.priority}] ${r.title}** \u2014 ${r.detail}`);
+    for (const f of g.findings) {
+      lines.push(`- **[${f.severity}] ${f.title}** \u2014 ${location(f)} _(effort: ${f.effort})_`);
+      lines.push(`  - ${f.detail}`);
+      if (f.moreLocations.length) {
+        lines.push(`  - _Also in:_ ${f.moreLocations.map((l) => `\`${l}\``).join(", ")}`);
+      }
+      if (f.suggestion) lines.push(`  - _Fix:_ ${f.suggestion}`);
     }
     lines.push("");
   }
-  lines.push(`## Detailed findings`);
-  lines.push("");
-  for (const c of scored.categories) {
-    lines.push(`### ${c.name} \u2014 ${Math.round(c.fraction * 100)}%`);
+  if (organized.positives.length) {
+    lines.push(`## What the repo does well`);
     lines.push("");
-    for (const cr of c.criteria) {
-      lines.push(`- **${cr.title}** (${cr.rawScore}/${cr.maxScore}) \u2014 ${cr.justification}`);
-      for (const e of cr.evidence) lines.push(`  - \`${e}\``);
-    }
+    for (const p of organized.positives) lines.push(`- ${p}`);
     lines.push("");
   }
   lines.push(`---`);
   lines.push(`<sub>Generated by [edsger](https://www.npmjs.com/package/edsger).</sub>`);
   return lines.join("\n");
 }
-function clamp(n, lo, hi) {
-  return Math.max(lo, Math.min(hi, n));
+function location(f) {
+  const primary = locationKey(f);
+  const more = f.moreLocations.length ? ` (+${f.moreLocations.length} more)` : "";
+  return primary ? `\`${primary}\`${more}` : `repo-wide${more}`;
 }
-function round(n, dp) {
-  const f = 10 ** dp;
-  return Math.round(n * f) / f;
+function locationKey(f) {
+  if (!f.file || f.file === "-") return "";
+  return f.line ? `${f.file}:${f.line}` : f.file;
 }
 
 // src/core/schema.ts
@@ -701,24 +962,439 @@ var ReviewResultSchema = z.object({
   verdict: z.enum(["approve", "request_changes", "comment"]),
   findings: z.array(ReviewFindingSchema).default([])
 });
+var AuditFindingSchema = z.object({
+  dimension: z.string().describe("Dimension id from the audit standard this finding relates to"),
+  severity: SeveritySchema,
+  file: z.string().describe("Repo-relative file path, or '-' if repo-wide"),
+  line: z.number().nullable().default(null).describe("1-based line number, if applicable"),
+  title: z.string().describe("Short, specific statement of the problem"),
+  detail: z.string().describe("What is wrong and why it is unprofessional, outdated, or risky"),
+  suggestion: z.string().nullable().default(null).describe("Concrete fix or modern replacement"),
+  effort: z.enum(["quick", "moderate", "involved"]).default("moderate").describe("Rough effort to fix: quick (<1h), moderate (a day), involved (multi-day)")
+});
+var AuditResultSchema = z.object({
+  summary: z.string().describe("3-5 sentence honest overall assessment of the repository"),
+  findings: z.array(AuditFindingSchema).default([]),
+  positives: z.array(z.string()).default([]).describe("Things the repository genuinely does well (keeps the critique fair)")
+});
 var ResolveResultSchema = z.object({
   summary: z.string().describe("What was changed and why"),
   changes: z.array(z.object({ file: z.string(), description: z.string() })).default([]),
   testsRun: z.string().nullable().default(null).describe("Command used to verify, and its outcome"),
   remaining: z.array(z.string()).default([]).describe("Anything still unresolved")
 });
+var GeneratedDiagramSchema = z.object({
+  id: z.string().describe("Diagram id from the catalog, or a descriptive slug if bespoke"),
+  groupId: z.string().describe("Catalog group id this diagram belongs to (e.g. architecture)"),
+  title: z.string().describe("Human-readable diagram title"),
+  type: z.string().describe(
+    "Mermaid diagram type used, e.g. flowchart, erDiagram, sequenceDiagram, classDiagram"
+  ),
+  mermaid: z.string().describe("Valid Mermaid source for the diagram (renders in HTML/Markdown)"),
+  description: z.string().describe("One or two sentences: what the diagram shows and why it applies to this repo"),
+  evidence: z.array(z.string()).default([]).describe("Repo files this diagram was derived from")
+});
+var DiagramsResultSchema = z.object({
+  profile: z.object({
+    summary: z.string().describe("2-4 sentence characterisation of the project"),
+    kinds: z.array(z.string()).default([]).describe("Project kind tags, e.g. cli, rest-api, spa, library, data-pipeline, monorepo"),
+    characteristics: z.array(z.string()).default([]).describe(
+      "Notable traits that drove diagram selection (owns a Postgres DB, deploys to k8s, \u2026)"
+    )
+  }).describe("The project profile that justifies which diagrams were chosen"),
+  diagrams: z.array(GeneratedDiagramSchema).describe("The diagrams selected for and generated from this repository"),
+  notes: z.string().nullable().default(null).describe("Optional notes, e.g. diagrams intentionally skipped and why")
+});
+var MindmapNodeSchema = z.object({
+  id: z.string().describe("Unique kebab-case node id, e.g. 'core-flows' or 'http-api'"),
+  parentId: z.string().nullable().default(null).describe("id of the parent node; null ONLY for the single root node"),
+  title: z.string().describe("Short outline-bullet title, 2-6 words"),
+  summary: z.string().describe("One or two sentences that are true and specific to this codebase"),
+  kind: z.string().default("topic").describe("Tag: area, module, component, flow, step, data, external, config, or topic"),
+  files: z.array(z.string()).default([]).describe("Repo-relative files this node is grounded in (expected for leaf nodes)")
+});
+var MindmapResultSchema = z.object({
+  profile: z.object({
+    summary: z.string().describe("2-4 sentence characterisation of the project"),
+    kinds: z.array(z.string()).default([]).describe("Project kind tags, e.g. cli, rest-api, spa, library, data-pipeline, monorepo"),
+    characteristics: z.array(z.string()).default([]).describe("Notable traits that shaped the map (owns a Postgres DB, monorepo, \u2026)")
+  }).describe("The project profile behind the map's shape"),
+  nodes: z.array(MindmapNodeSchema).describe(
+    "The whole mind map as a flat node list: exactly one root (parentId=null), children listed in reading order after their parent"
+  ),
+  notes: z.string().nullable().default(null).describe("Optional notes, e.g. areas intentionally left out and why")
+});
+
+// src/commands/audit.ts
+async function runAudit(opts, deps = { agent: runAgent }) {
+  const { config, path: configPath } = loadConfig(opts.cwd);
+  const configDir = configPath ? join5(configPath, "..") : opts.cwd;
+  const resolved = resolveStandard("audit", opts, config, configDir);
+  const standard = narrowDimensions(resolved.standard, opts.only);
+  log.info(
+    `Auditing ${pc4.bold(basename(opts.cwd))} against ${pc4.bold(standard.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
+  );
+  log.debug(`standard layers: ${resolved.layers.join(" \u2192 ")}`);
+  const { result, costUsd, numTurns } = await deps.agent({
+    prompt: buildPrompt(standard, opts.cwd, opts.focus),
+    cwd: opts.cwd,
+    model: opts.model,
+    maxTurns: opts.maxTurns,
+    timeoutMs: opts.timeoutMs,
+    allowWrite: false,
+    verbose: opts.verbose,
+    resultShape: AuditResultSchema.shape,
+    systemPromptAppend: "You are Edsger, an exacting staff-level engineer performing a professionalism audit of an existing repository. Your job is to find what is unprofessional, outdated, fragile, or sloppy \u2014 and to prove it. Every finding must cite real evidence (file, and line where possible) you actually inspected. Be demanding but fair: no invented problems, no vague generalities. Do not modify any files."
+  });
+  if (!result) {
+    log.error(
+      "The agent did not produce a result. Try increasing --max-turns or check credentials."
+    );
+    return 1;
+  }
+  const organized = organizeAudit(standard, result);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = generatedAt.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const git = gitInfo(opts.cwd);
+  const md = renderAuditMarkdown(organized, {
+    repo: basename(opts.cwd),
+    languages: resolved.languages,
+    layers: resolved.layers,
+    generatedAt,
+    model: opts.model
+  });
+  const jsonReport = {
+    schema: "edsger.audit/1",
+    runId,
+    generatedAt,
+    model: opts.model,
+    repo: basename(opts.cwd),
+    git,
+    languages: resolved.languages,
+    standard: { name: standard.name, version: standard.version, layers: resolved.layers },
+    // Dimension titles in standard order, so viewers can label groups properly.
+    dimensions: standard.dimensions.map((d) => ({ id: d.id, title: d.title })),
+    summary: organized.summary,
+    counts: organized.counts,
+    total: organized.total,
+    omitted: organized.omitted,
+    findings: organized.findings,
+    positives: organized.positives,
+    costUsd
+  };
+  const historyRecord = {
+    runId,
+    generatedAt,
+    commit: git.commit,
+    branch: git.branch,
+    dirty: git.dirty,
+    model: opts.model,
+    standardVersion: standard.version,
+    total: organized.total,
+    counts: organized.counts,
+    costUsd
+  };
+  if (!opts.noWrite && !opts.dryRun) {
+    const baseDir = join5(opts.cwd, opts.out);
+    const mdOut = md + "\n";
+    const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
+    const runDir = join5(baseDir, "runs", runId);
+    mkdirSync(runDir, { recursive: true });
+    writeFileSync(join5(runDir, "report.md"), mdOut, "utf8");
+    writeFileSync(join5(runDir, "report.json"), jsonOut, "utf8");
+    writeFileSync(join5(baseDir, "report.md"), mdOut, "utf8");
+    writeFileSync(join5(baseDir, "report.json"), jsonOut, "utf8");
+    appendFileSync(join5(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
+    log.success(
+      `Report written to ${pc4.bold(join5(opts.out, "report.md"))} ${pc4.dim(`(run archived at ${join5(opts.out, "runs", runId)})`)}`
+    );
+  }
+  printSummary(organized, numTurns, costUsd);
+  if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
+  if (opts.failOn && hasFindingsAtOrAbove(organized, opts.failOn)) {
+    log.warn(`Findings at or above ${pc4.bold(opts.failOn)} present \u2014 failing (--fail-on).`);
+    return 2;
+  }
+  return 0;
+}
+async function runAuditServe(opts) {
+  const auditDir = join5(opts.cwd, opts.dir);
+  const viewerDir = findAuditViewerDir();
+  return startViewerServer({
+    viewerDir,
+    indexFile: "audit.html",
+    dataRoute: "/edsger-audit.json",
+    getData: () => assembleAuditData(auditDir),
+    port: opts.port,
+    host: opts.host,
+    open: opts.open,
+    emptyHint: hasData(assembleAuditData(auditDir)) ? void 0 : `No audit data in ${opts.dir} yet \u2014 run \`edsger audit\` first.`
+  });
+}
+async function runAuditReport(opts) {
+  const auditDir = join5(opts.cwd, opts.dir);
+  const data = assembleAuditData(auditDir);
+  if (!hasData(data)) {
+    log.error(`No audit data in ${opts.dir}. Run \`edsger audit\` first.`);
+    return 1;
+  }
+  const html = renderAuditSingleFile(readAuditViewerSingleTemplate(), data);
+  const out = isAbsolute2(opts.html) ? opts.html : join5(opts.cwd, opts.html);
+  mkdirSync(dirname2(out), { recursive: true });
+  writeFileSync(out, html, "utf8");
+  log.success(
+    `Wrote self-contained audit viewer to ${pc4.bold(opts.html)} ${pc4.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
+  );
+  if (opts.open) openInBrowser(out);
+  return 0;
+}
+function narrowDimensions(standard, only) {
+  if (!only || only.length === 0) return standard;
+  const valid = new Set(standard.dimensions.map((d) => d.id));
+  const unknown = only.filter((id) => !valid.has(id));
+  if (unknown.length) {
+    throw new Error(
+      `Unknown dimension id(s): ${unknown.join(", ")}. Available: ${[...valid].join(", ")}`
+    );
+  }
+  const keep = new Set(only);
+  return { ...standard, dimensions: standard.dimensions.filter((d) => keep.has(d.id)) };
+}
+function printSummary(organized, numTurns, costUsd) {
+  log.heading(`Findings: ${organized.total}`);
+  for (const s of SEVERITY_ORDER) {
+    if (organized.counts[s]) {
+      process.stderr.write(`  ${sevColor(s)(s.padEnd(8))} ${organized.counts[s]}
+`);
+    }
+  }
+  if (organized.omitted > 0) {
+    log.warn(`${organized.omitted} lower-severity finding(s) omitted (maxFindings policy)`);
+  }
+  if (organized.quickWins.length) {
+    log.step(`${organized.quickWins.length} quick win(s) \u2014 see the report's "Quick wins" section`);
+  }
+  log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
+}
+function sevColor(s) {
+  if (s === "critical" || s === "high") return pc4.red;
+  if (s === "medium") return pc4.yellow;
+  return pc4.dim;
+}
+function buildPrompt(standard, cwd, focus) {
+  const maxFindings = Math.max(1, standard.policy?.maxFindings ?? DEFAULT_MAX_FINDINGS);
+  const dims = standard.dimensions.map((d) => {
+    const checklist = (d.checklist ?? []).map((c) => `    - ${c}`).join("\n");
+    return `- id: ${d.id} (${d.title}, default severity ${d.defaultSeverity ?? "medium"})
+  guidance: ${d.guidance.trim()}` + (checklist ? `
+  checklist:
+${checklist}` : "");
+  }).join("\n");
+  return [
+    `Audit the repository located at: ${cwd}`,
+    ``,
+    `This is a deliberate fault-finding pass over the WHOLE repository (not a diff): surface`,
+    `everything that keeps it from being truly professional \u2014 sloppy or amateurish`,
+    `implementations, outdated or deprecated patterns, fragility, and neglected hygiene.`,
+    ...standard.guidance ? [``, `Overall guidance: ${standard.guidance.trim()}`] : [],
+    ...focus ? [``, `Extra focus requested by the user: ${truncate(focus.trim(), 2e3)}`] : [],
+    ``,
+    `Method:`,
+    ...numbered([
+      `Explore the repository thoroughly: structure, source, configuration, dependencies,
+CI, tests, and docs. Use Read/Grep/Glob and read-only Bash (ls, cat, git log).
+Do NOT modify anything.`,
+      `For EVERY dimension below, actively hunt for violations of its guidance and
+checklist. Only report findings backed by evidence you actually inspected; cite the
+repo-relative file path and, where it applies, the 1-based line number.`,
+      `For each finding choose a severity (critical/high/medium/low/info; start from the
+dimension's default and adjust for impact), explain why it matters, give a concrete
+fix, and estimate the effort (quick/moderate/involved).`,
+      `When the SAME issue recurs across many files, consolidate it into ONE finding and
+list the other affected locations in its detail \u2014 do not repeat it per file.
+Report at most ${maxFindings} findings: keep the most severe, fold or drop the rest.`,
+      `Also record what the repo genuinely does well (positives) \u2014 the critique must stay fair.`,
+      `When finished, call submit_result exactly once with the summary, all findings, and
+the positives.`
+    ]),
+    ``,
+    `Dimensions:`,
+    dims
+  ].join("\n");
+}
+function numbered(steps) {
+  return steps.map((s, i) => {
+    const [first = "", ...rest] = s.split("\n");
+    return [`${i + 1}. ${first}`, ...rest.map((l) => `   ${l}`)].join("\n");
+  });
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max) + " \u2026 [truncated]" : s;
+}
+
+// src/commands/benchmark.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, join as join6 } from "path";
+import pc5 from "picocolors";
+
+// src/core/report.ts
+function scoreBenchmark(standard, result) {
+  const scale = standard.scoreScale || 4;
+  const totalWeight = standard.categories.reduce((s, c) => s + c.weight, 0) || 1;
+  const tail = (id) => id.slice(id.lastIndexOf("/") + 1);
+  const byKey = /* @__PURE__ */ new Map();
+  const byCrit = /* @__PURE__ */ new Map();
+  for (const cat of result.categories) {
+    for (const cr of cat.criteria) {
+      const meta = {
+        score: cr.score,
+        justification: cr.justification,
+        evidence: cr.evidence ?? []
+      };
+      byKey.set(`${tail(cat.id)}/${tail(cr.id)}`, meta);
+      byCrit.set(tail(cr.id), meta);
+    }
+  }
+  let matched = 0;
+  const categories = standard.categories.map((cat) => {
+    const critWeightTotal = cat.criteria.reduce((s, c) => s + (c.weight ?? 1), 0) || 1;
+    const scored = cat.criteria.map((cr) => {
+      const meta = byKey.get(`${tail(cat.id)}/${tail(cr.id)}`) ?? byCrit.get(tail(cr.id));
+      if (meta) matched += 1;
+      const raw = clamp(meta?.score ?? 0, 0, scale);
+      return {
+        id: cr.id,
+        title: cr.title,
+        weight: cr.weight ?? 1,
+        rawScore: raw,
+        maxScore: scale,
+        fraction: raw / scale,
+        justification: meta?.justification ?? "Not assessed.",
+        evidence: meta?.evidence ?? []
+      };
+    });
+    const fraction = scored.reduce((s, c) => s + c.fraction * c.weight, 0) / critWeightTotal;
+    const normWeight = cat.weight / totalWeight * 100;
+    return {
+      id: cat.id,
+      name: cat.name,
+      weight: round(normWeight, 1),
+      fraction,
+      points: round(normWeight * fraction, 1),
+      criteria: scored
+    };
+  });
+  const totalCriteria = standard.categories.reduce((s, c) => s + c.criteria.length, 0);
+  if (result.categories.length > 0 && matched === 0) {
+    log.warn(
+      "The agent returned scores but none matched the rubric's criterion ids \u2014 reporting 0. This is a scoring bug, not a real result."
+    );
+  } else if (matched < totalCriteria) {
+    log.warn(`Only ${matched}/${totalCriteria} criteria were scored; the rest default to 0.`);
+  }
+  const overall = round(
+    categories.reduce((s, c) => s + c.points, 0),
+    1
+  );
+  return {
+    standardName: standard.name,
+    standardVersion: standard.version,
+    overall,
+    grade: gradeFor(overall),
+    categories,
+    summary: result.summary,
+    strengths: result.strengths ?? [],
+    weaknesses: result.weaknesses ?? [],
+    recommendations: result.recommendations ?? []
+  };
+}
+function gradeFor(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function renderBenchmarkMarkdown(scored, meta) {
+  const lines = [];
+  lines.push(`# Edsger Benchmark Report`);
+  lines.push("");
+  lines.push(`**Score: ${scored.overall} / 100 (Grade ${scored.grade})**`);
+  lines.push("");
+  lines.push(`> ${scored.summary}`);
+  lines.push("");
+  lines.push(`| Field | Value |`);
+  lines.push(`| --- | --- |`);
+  lines.push(`| Repository | \`${meta.repo}\` |`);
+  lines.push(`| Languages | ${meta.languages.join(", ") || "n/a"} |`);
+  lines.push(`| Standard | ${scored.standardName} v${scored.standardVersion} |`);
+  lines.push(`| Sources | ${meta.layers.join(" \u2192 ")} |`);
+  lines.push(`| Model | ${meta.model} |`);
+  lines.push(`| Generated | ${meta.generatedAt} |`);
+  lines.push("");
+  lines.push(`## Category scores`);
+  lines.push("");
+  lines.push(`| Category | Weight | Score | Weighted |`);
+  lines.push(`| --- | ---: | ---: | ---: |`);
+  for (const c of scored.categories) {
+    lines.push(`| ${c.name} | ${c.weight}% | ${Math.round(c.fraction * 100)}% | ${c.points} |`);
+  }
+  lines.push(`| **Overall** | **100%** | | **${scored.overall}** |`);
+  lines.push("");
+  if (scored.strengths.length) {
+    lines.push(`## Strengths`);
+    lines.push("");
+    for (const s of scored.strengths) lines.push(`- ${s}`);
+    lines.push("");
+  }
+  if (scored.weaknesses.length) {
+    lines.push(`## Weaknesses`);
+    lines.push("");
+    for (const w of scored.weaknesses) lines.push(`- ${w}`);
+    lines.push("");
+  }
+  if (scored.recommendations.length) {
+    lines.push(`## Recommendations`);
+    lines.push("");
+    for (const r of scored.recommendations) {
+      lines.push(`- **[${r.priority}] ${r.title}** \u2014 ${r.detail}`);
+    }
+    lines.push("");
+  }
+  lines.push(`## Detailed findings`);
+  lines.push("");
+  for (const c of scored.categories) {
+    lines.push(`### ${c.name} \u2014 ${Math.round(c.fraction * 100)}%`);
+    lines.push("");
+    for (const cr of c.criteria) {
+      lines.push(`- **${cr.title}** (${cr.rawScore}/${cr.maxScore}) \u2014 ${cr.justification}`);
+      for (const e of cr.evidence) lines.push(`  - \`${e}\``);
+    }
+    lines.push("");
+  }
+  lines.push(`---`);
+  lines.push(`<sub>Generated by [edsger](https://www.npmjs.com/package/edsger).</sub>`);
+  return lines.join("\n");
+}
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
+}
+function round(n, dp) {
+  const f = 10 ** dp;
+  return Math.round(n * f) / f;
+}
 
 // src/commands/benchmark.ts
 async function runBenchmark(opts) {
   const { config, path: configPath } = loadConfig(opts.cwd);
-  const configDir = configPath ? join3(configPath, "..") : opts.cwd;
+  const configDir = configPath ? join6(configPath, "..") : opts.cwd;
   const resolved = resolveStandard("benchmark", opts, config, configDir);
   const standard = resolved.standard;
   log.info(
-    `Benchmarking ${pc3.bold(basename(opts.cwd))} against ${pc3.bold(standard.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
+    `Benchmarking ${pc5.bold(basename2(opts.cwd))} against ${pc5.bold(standard.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
   );
   log.debug(`standard layers: ${resolved.layers.join(" \u2192 ")}`);
-  const prompt = buildPrompt(standard, opts.cwd);
+  const prompt = buildPrompt2(standard, opts.cwd);
   const { result, costUsd, numTurns } = await runAgent({
     prompt,
     cwd: opts.cwd,
@@ -741,7 +1417,7 @@ async function runBenchmark(opts) {
   const runId = generatedAt.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
   const git = gitInfo(opts.cwd);
   const md = renderBenchmarkMarkdown(scored, {
-    repo: basename(opts.cwd),
+    repo: basename2(opts.cwd),
     languages: resolved.languages,
     layers: resolved.layers,
     generatedAt,
@@ -752,7 +1428,7 @@ async function runBenchmark(opts) {
     runId,
     generatedAt,
     model: opts.model,
-    repo: basename(opts.cwd),
+    repo: basename2(opts.cwd),
     git,
     languages: resolved.languages,
     standard: { name: standard.name, version: standard.version, layers: resolved.layers },
@@ -779,25 +1455,25 @@ async function runBenchmark(opts) {
     costUsd
   };
   if (!opts.noWrite && !opts.dryRun) {
-    const baseDir = join3(opts.cwd, opts.out);
+    const baseDir = join6(opts.cwd, opts.out);
     const mdOut = md + "\n";
     const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
-    const runDir = join3(baseDir, "runs", runId);
-    mkdirSync(runDir, { recursive: true });
-    writeFileSync(join3(runDir, "report.md"), mdOut, "utf8");
-    writeFileSync(join3(runDir, "report.json"), jsonOut, "utf8");
-    writeFileSync(join3(baseDir, "report.md"), mdOut, "utf8");
-    writeFileSync(join3(baseDir, "report.json"), jsonOut, "utf8");
-    appendFileSync(join3(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
+    const runDir = join6(baseDir, "runs", runId);
+    mkdirSync2(runDir, { recursive: true });
+    writeFileSync2(join6(runDir, "report.md"), mdOut, "utf8");
+    writeFileSync2(join6(runDir, "report.json"), jsonOut, "utf8");
+    writeFileSync2(join6(baseDir, "report.md"), mdOut, "utf8");
+    writeFileSync2(join6(baseDir, "report.json"), jsonOut, "utf8");
+    appendFileSync2(join6(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
     log.success(
-      `Report written to ${pc3.bold(join3(opts.out, "report.md"))} ${pc3.dim(`(run archived at ${join3(opts.out, "runs", runId)})`)}`
+      `Report written to ${pc5.bold(join6(opts.out, "report.md"))} ${pc5.dim(`(run archived at ${join6(opts.out, "runs", runId)})`)}`
     );
   }
-  printSummary(scored, numTurns, costUsd);
+  printSummary2(scored, numTurns, costUsd);
   if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
   return 0;
 }
-function printSummary(scored, numTurns, costUsd) {
+function printSummary2(scored, numTurns, costUsd) {
   log.heading(`Score: ${scored.overall}/100  (Grade ${scored.grade})`);
   for (const c of scored.categories) {
     const pct = Math.round(c.fraction * 100);
@@ -809,10 +1485,10 @@ function printSummary(scored, numTurns, costUsd) {
 function bar(pct) {
   const width = 20;
   const filled = Math.round(pct / 100 * width);
-  const color = pct >= 80 ? pc3.green : pct >= 60 ? pc3.yellow : pc3.red;
-  return color("\u2588".repeat(filled)) + pc3.dim("\u2591".repeat(width - filled));
+  const color = pct >= 80 ? pc5.green : pct >= 60 ? pc5.yellow : pc5.red;
+  return color("\u2588".repeat(filled)) + pc5.dim("\u2591".repeat(width - filled));
 }
-function buildPrompt(standard, cwd) {
+function buildPrompt2(standard, cwd) {
   const rubric = standard.categories.map((cat) => {
     const crits = cat.criteria.map((cr) => {
       const anchors = cr.rubric ? Object.entries(cr.rubric).map(([k, v]) => `      - ${k}: ${v}`).join("\n") : "";
@@ -845,13 +1521,13 @@ ${crits}`;
 }
 
 // src/commands/pr-review.ts
-import pc4 from "picocolors";
+import pc6 from "picocolors";
 
 // src/core/gh.ts
 import { execFile } from "child_process";
-import { mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { join as join7 } from "path";
 import { promisify } from "util";
 var exec = promisify(execFile);
 async function gh(args, cwd) {
@@ -912,9 +1588,9 @@ async function postReview(ctx, repo, event, body, inline, cwd) {
     event,
     comments: inline.map((c) => ({ path: c.path, line: c.line, side: "RIGHT", body: c.body }))
   };
-  const dir = mkdtempSync(join4(tmpdir(), "edsger-review-"));
-  const file = join4(dir, "review.json");
-  writeFileSync2(file, JSON.stringify(payload), "utf8");
+  const dir = mkdtempSync(join7(tmpdir(), "edsger-review-"));
+  const file = join7(dir, "review.json");
+  writeFileSync3(file, JSON.stringify(payload), "utf8");
   try {
     await gh(
       ["api", "--method", "POST", `repos/${target}/pulls/${ctx.number}/reviews`, "--input", file],
@@ -955,7 +1631,7 @@ async function getPrFeedback(ctx, repo, cwd) {
 }
 
 // src/commands/pr-review.ts
-var SEVERITY_RANK = {
+var SEVERITY_RANK2 = {
   critical: 4,
   high: 3,
   medium: 2,
@@ -964,7 +1640,7 @@ var SEVERITY_RANK = {
 };
 async function runPrReview(opts) {
   await ensureGhReady();
-  log.info(`Fetching PR ${pc4.bold(opts.pr)}${opts.repo ? ` from ${opts.repo}` : ""}`);
+  log.info(`Fetching PR ${pc6.bold(opts.pr)}${opts.repo ? ` from ${opts.repo}` : ""}`);
   const ctx = await getPrContext(opts.pr, opts.repo, opts.cwd);
   const { config, path: configPath } = loadConfig(opts.cwd);
   const configDir = configPath ? `${configPath}/..` : opts.cwd;
@@ -975,10 +1651,10 @@ async function runPrReview(opts) {
   const resolved = resolveStandard("review", opts, config, configDir, fileHint);
   const standard = resolved.standard;
   log.info(
-    `Reviewing "${pc4.bold(ctx.title)}" (#${ctx.number}, ${ctx.files.length} files) against ${pc4.bold(standard.name)}`
+    `Reviewing "${pc6.bold(ctx.title)}" (#${ctx.number}, ${ctx.files.length} files) against ${pc6.bold(standard.name)}`
   );
   const { result, costUsd, numTurns } = await runAgent({
-    prompt: buildPrompt2(standard, ctx),
+    prompt: buildPrompt3(standard, ctx),
     cwd: opts.cwd,
     model: opts.model,
     maxTurns: opts.maxTurns,
@@ -1009,7 +1685,7 @@ async function runPrReview(opts) {
     await postReview(ctx, opts.repo, event, body, inline, opts.cwd);
     log.success(`Posted review (${event}) to ${ctx.url}`);
   } else {
-    log.warn(`Preview only. Re-run with ${pc4.bold("--post")} to submit this review to GitHub.`);
+    log.warn(`Preview only. Re-run with ${pc6.bold("--post")} to submit this review to GitHub.`);
     process.stderr.write("\n" + body + "\n");
   }
   return 0;
@@ -1025,7 +1701,7 @@ function decideEvent(result, standard) {
 function buildInlineComments(result, ctx, standard) {
   const changed = new Set(ctx.files.map((f) => f.path));
   const sorted = [...result.findings].sort(
-    (a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]
+    (a, b) => SEVERITY_RANK2[b.severity] - SEVERITY_RANK2[a.severity]
   );
   const out = [];
   for (const f of sorted) {
@@ -1074,7 +1750,7 @@ function printPreview(result, event, numTurns, costUsd) {
   log.heading(`Verdict: ${event}`);
   const counts = countBySeverity(result.findings);
   for (const s of ["critical", "high", "medium", "low", "info"]) {
-    if (counts[s]) process.stderr.write(`  ${sevColor(s)(s.padEnd(8))} ${counts[s]}
+    if (counts[s]) process.stderr.write(`  ${sevColor2(s)(s.padEnd(8))} ${counts[s]}
 `);
   }
   log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
@@ -1084,15 +1760,15 @@ function countBySeverity(findings) {
   for (const f of findings) c[f.severity]++;
   return c;
 }
-function sevColor(s) {
-  if (s === "critical" || s === "high") return pc4.red;
-  if (s === "medium") return pc4.yellow;
-  return pc4.dim;
+function sevColor2(s) {
+  if (s === "critical" || s === "high") return pc6.red;
+  if (s === "medium") return pc6.yellow;
+  return pc6.dim;
 }
 function verdictLabel(v) {
   return v === "approve" ? "Approve" : v === "request_changes" ? "Request changes" : "Comment";
 }
-function buildPrompt2(standard, ctx) {
+function buildPrompt3(standard, ctx) {
   const focus = standard.focusAreas.map((fa) => {
     const checklist = (fa.checklist ?? []).map((c) => `    - ${c}`).join("\n");
     return `- id: ${fa.id} (${fa.title}, default severity ${fa.defaultSeverity ?? "medium"})
@@ -1125,25 +1801,25 @@ ${checklist}` : "");
     ``,
     `Unified diff:`,
     "```diff",
-    truncate(ctx.diff, 18e4),
+    truncate2(ctx.diff, 18e4),
     "```"
   ].join("\n");
 }
 function indent(s) {
   return s.split("\n").map((l) => `  ${l}`).join("\n");
 }
-function truncate(s, max) {
+function truncate2(s, max) {
   return s.length > max ? s.slice(0, max) + "\n... [diff truncated] ..." : s;
 }
 
 // src/commands/pr-resolve.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import pc5 from "picocolors";
+import pc7 from "picocolors";
 var exec2 = promisify2(execFile2);
 async function runPrResolve(opts) {
   await ensureGhReady();
-  log.info(`Fetching PR ${pc5.bold(opts.pr)}${opts.repo ? ` from ${opts.repo}` : ""}`);
+  log.info(`Fetching PR ${pc7.bold(opts.pr)}${opts.repo ? ` from ${opts.repo}` : ""}`);
   const ctx = await getPrContext(opts.pr, opts.repo, opts.cwd);
   const feedback = await getPrFeedback(ctx, opts.repo, opts.cwd).catch(() => ({
     reviewComments: [],
@@ -1154,10 +1830,10 @@ async function runPrResolve(opts) {
     await checkoutPr(opts.pr, opts.repo, opts.cwd);
   }
   log.info(
-    `Resolving "${pc5.bold(ctx.title)}" (#${ctx.number}) \u2014 ${feedback.reviewComments.length} review comments`
+    `Resolving "${pc7.bold(ctx.title)}" (#${ctx.number}) \u2014 ${feedback.reviewComments.length} review comments`
   );
   const { result, costUsd, numTurns } = await runAgent({
-    prompt: buildPrompt3(ctx, feedback, opts.instruction),
+    prompt: buildPrompt4(ctx, feedback, opts.instruction),
     cwd: opts.cwd,
     model: opts.model,
     maxTurns: opts.maxTurns,
@@ -1171,7 +1847,7 @@ async function runPrResolve(opts) {
     log.error("The agent did not produce a result.");
     return 1;
   }
-  printSummary2(result, numTurns, costUsd);
+  printSummary3(result, numTurns, costUsd);
   if (opts.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
   if (opts.push && !opts.dryRun) {
     const pushed = await commitAndPush(ctx, result, opts.cwd, opts.checkout);
@@ -1179,7 +1855,7 @@ async function runPrResolve(opts) {
     else log.warn("Nothing to commit \u2014 working tree is clean.");
   } else {
     log.warn(
-      `Changes left in the working tree. Review them, then commit/push (or re-run with ${pc5.bold("--push")}).`
+      `Changes left in the working tree. Review them, then commit/push (or re-run with ${pc7.bold("--push")}).`
     );
   }
   return 0;
@@ -1216,14 +1892,14 @@ Push manually, or ensure the PR branch was checked out with gh.`
 function errText(err) {
   return err instanceof Error ? err.message.split("\n")[0] ?? "" : String(err);
 }
-function printSummary2(result, numTurns, costUsd) {
+function printSummary3(result, numTurns, costUsd) {
   log.heading("Resolution summary");
   process.stderr.write(`  ${result.summary}
 
 `);
   if (result.changes.length) {
     for (const c of result.changes)
-      process.stderr.write(`  ${pc5.green("~")} ${c.file} \u2014 ${c.description}
+      process.stderr.write(`  ${pc7.green("~")} ${c.file} \u2014 ${c.description}
 `);
   }
   if (result.testsRun) log.step(`verification: ${result.testsRun}`);
@@ -1234,7 +1910,7 @@ function printSummary2(result, numTurns, costUsd) {
   }
   log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
 }
-function buildPrompt3(ctx, feedback, instruction) {
+function buildPrompt4(ctx, feedback, instruction) {
   const reviewComments = feedback.reviewComments.length ? feedback.reviewComments.map((c) => `  - ${c.path}${c.line ? `:${c.line}` : ""} (${c.author}): ${c.body}`).join("\n") : "  (none)";
   const issueComments = feedback.issueComments.length ? feedback.issueComments.map((c) => `  - ${c.author}: ${c.body}`).join("\n") : "  (none)";
   return [
@@ -1262,163 +1938,721 @@ function buildPrompt3(ctx, feedback, instruction) {
 }
 
 // src/commands/serve.ts
-import { createReadStream, existsSync as existsSync4, statSync as statSync2 } from "fs";
-import { createServer } from "http";
-import { extname, join as join6, normalize } from "path";
-import pc6 from "picocolors";
+import { join as join8 } from "path";
+async function runServe(opts) {
+  const benchmarkDir = join8(opts.cwd, opts.dir);
+  const viewerDir = findViewerDir();
+  return startViewerServer({
+    viewerDir,
+    indexFile: "index.html",
+    dataRoute: "/edsger-data.json",
+    getData: () => assembleData(benchmarkDir),
+    port: opts.port,
+    host: opts.host,
+    open: opts.open,
+    emptyHint: hasData(assembleData(benchmarkDir)) ? void 0 : `No benchmark data in ${opts.dir} yet \u2014 run \`edsger benchmark\` first.`
+  });
+}
 
-// src/core/dashboard.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join5 } from "path";
-function assembleData(benchmarkDir) {
-  const latest = readJson(join5(benchmarkDir, "report.json"));
-  const history = readJsonl(join5(benchmarkDir, "history.jsonl"));
-  const runs = {};
-  const runsDir = join5(benchmarkDir, "runs");
-  if (existsSync3(runsDir)) {
-    for (const entry of readdirSync2(runsDir)) {
-      const report = readJson(join5(runsDir, entry, "report.json"));
-      if (report) runs[entry] = report;
+// src/commands/report.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join9 } from "path";
+import pc8 from "picocolors";
+async function runReport(opts) {
+  const benchmarkDir = join9(opts.cwd, opts.dir);
+  const data = assembleData(benchmarkDir);
+  if (!hasData(data)) {
+    log.error(`No benchmark data in ${opts.dir}. Run \`edsger benchmark\` first.`);
+    return 1;
+  }
+  const html = renderSingleFile(readViewerSingleTemplate(), data);
+  const out = isAbsolute3(opts.html) ? opts.html : join9(opts.cwd, opts.html);
+  mkdirSync3(dirname3(out), { recursive: true });
+  writeFileSync4(out, html, "utf8");
+  log.success(
+    `Wrote self-contained report to ${pc8.bold(opts.html)} ${pc8.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
+  );
+  if (opts.open) openInBrowser(out);
+  return 0;
+}
+
+// src/commands/diagram.ts
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute4, join as join10 } from "path";
+import pc9 from "picocolors";
+
+// src/core/diagrams.ts
+function buildDiagramsPrompt(catalog, cwd, only) {
+  const onlySet = only && only.length ? new Set(only.map((s) => s.trim())) : null;
+  const catalogText = catalog.groups.map((group) => {
+    const diagrams = group.diagrams.filter((d) => !onlySet || onlySet.has(d.id)).map((d) => {
+      const detect = d.detect?.length ? `
+      detect: ${d.detect.join(", ")}` : "";
+      return `    - id: ${d.id}
+      title: ${d.title}
+      mermaidType: ${d.type}
+      appliesWhen: ${d.appliesWhen.trim()}` + detect + `
+      guidance: ${d.guidance.trim()}`;
+    }).join("\n");
+    if (!diagrams) return "";
+    return `- group: ${group.id} (${group.name})
+${diagrams}`;
+  }).filter(Boolean).join("\n");
+  return [
+    `Produce a set of professional software diagrams for the repository at: ${cwd}`,
+    ``,
+    `You have a catalog of candidate diagrams below. Your job is to pick the ones`,
+    `that genuinely fit THIS project and generate each as valid Mermaid.`,
+    ``,
+    `Method:`,
+    `1. Explore the repository (Read/Grep/Glob and read-only Bash like ls, cat, git log).`,
+    `   Characterise the project: what kind is it (service, library, CLI, SPA, data`,
+    `   pipeline, monorepo, \u2026), what does it integrate with, does it own a database,`,
+    `   how is it deployed?`,
+    `2. For each catalog diagram, use its appliesWhen/detect to decide whether it adds`,
+    `   value for this repo. Only include diagrams the evidence supports. A library`,
+    `   needs different diagrams than a microservice. Do NOT invent structure that is`,
+    `   not in the code. Aim for the ${onlySet ? "requested" : "5-9 most valuable"} diagrams.`,
+    `3. For each selected diagram, follow its guidance and emit VALID Mermaid of the`,
+    `   given mermaidType, grounded in real files. Rules for the mermaid field:`,
+    `     - Put ONLY the Mermaid source (starting with the diagram keyword, e.g.`,
+    `       "flowchart TD" or "erDiagram"). Do NOT wrap it in \`\`\`mermaid fences and`,
+    `       do NOT add any prose/markdown outside the diagram.`,
+    `     - It MUST parse as-is. Use simple alphanumeric node/participant ids and put`,
+    `       human text in quoted labels, e.g. A["Order Service"] not A[Order Service].`,
+    `       Quote any label containing spaces, punctuation, parentheses or slashes.`,
+    `     - Avoid Mermaid reserved words as bare node ids (especially "end" in`,
+    `       flowcharts \u2014 write End or "end" instead).`,
+    `     - Set "type" to the exact keyword the source starts with.`,
+    `     - Keep each diagram to roughly one screen and legible.`,
+    `     - Prefer faithful over exhaustive; record the files you used as evidence.`,
+    `4. When finished, call submit_result exactly once with the project profile and`,
+    `   the diagrams (each with id, groupId, title, type, mermaid, description, evidence).`,
+    ``,
+    `Diagram catalog:`,
+    catalogText
+  ].join("\n");
+}
+function sanitizeMermaid(src) {
+  let s = src.trim();
+  const fence = s.match(/^```(?:mermaid)?\s*\n([\s\S]*?)\n```$/);
+  if (fence && fence[1] !== void 0) s = fence[1].trim();
+  return s;
+}
+var KNOWN_MERMAID_TYPES = /* @__PURE__ */ new Set([
+  "flowchart",
+  "graph",
+  "sequenceDiagram",
+  "classDiagram",
+  "stateDiagram",
+  "stateDiagram-v2",
+  "erDiagram",
+  "journey",
+  "gantt",
+  "gitGraph",
+  "mindmap",
+  "timeline",
+  "requirementDiagram",
+  "quadrantChart",
+  "pie",
+  "sankey-beta",
+  "xychart-beta",
+  "block-beta",
+  "packet-beta",
+  "kanban",
+  "zenuml",
+  "C4Context",
+  "C4Container",
+  "C4Component",
+  "C4Deployment",
+  "C4Dynamic",
+  "architecture-beta"
+]);
+function firstKeyword(mermaid) {
+  for (const raw of mermaid.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("%%")) continue;
+    return line.split(/[\s({]/)[0] ?? line;
+  }
+  return "";
+}
+function normaliseType(keyword) {
+  const k = keyword.trim();
+  if (k === "graph") return "flowchart";
+  if (k === "stateDiagram") return "stateDiagram-v2";
+  return k;
+}
+function inferType(mermaid) {
+  return firstKeyword(mermaid) || "flowchart";
+}
+function validateMermaid(declaredType, mermaid) {
+  const warnings = [];
+  if (mermaid.includes("```")) warnings.push("source still contains a ``` fence");
+  const keyword = firstKeyword(mermaid);
+  if (!keyword) {
+    warnings.push("no diagram content");
+    return warnings;
+  }
+  if (!KNOWN_MERMAID_TYPES.has(keyword)) {
+    warnings.push(`unrecognised diagram keyword "${keyword}"`);
+  }
+  const body = mermaid.split("\n").filter((l) => {
+    const t = l.trim();
+    return t && !t.startsWith("%%");
+  });
+  if (body.length < 2) warnings.push("header only \u2014 the diagram has no body");
+  if (declaredType && KNOWN_MERMAID_TYPES.has(keyword)) {
+    if (normaliseType(declaredType) !== normaliseType(keyword)) {
+      warnings.push(`declared type "${declaredType}" but source starts with "${keyword}"`);
+    }
+  }
+  return warnings;
+}
+function prepareDiagrams(catalog, result) {
+  const groupName = new Map(catalog.groups.map((g) => [g.id, g.name]));
+  const groupOrder = new Map(catalog.groups.map((g, i) => [g.id, i]));
+  const prepared = [];
+  const seenIds = /* @__PURE__ */ new Map();
+  for (const d of result.diagrams) {
+    const mermaid = sanitizeMermaid(d.mermaid ?? "");
+    if (!mermaid) {
+      log.warn(`Skipping diagram "${d.id}" \u2014 it had no mermaid source.`);
+      continue;
+    }
+    const baseId = d.id || inferType(mermaid);
+    const count = seenIds.get(baseId) ?? 0;
+    seenIds.set(baseId, count + 1);
+    const id = count === 0 ? baseId : `${baseId}-${count + 1}`;
+    const type = d.type?.trim() || inferType(mermaid);
+    prepared.push({
+      ...d,
+      id,
+      mermaid,
+      type,
+      evidence: d.evidence ?? [],
+      groupName: groupName.get(d.groupId) ?? "Other",
+      warnings: validateMermaid(type, mermaid)
+    });
+  }
+  prepared.sort((a, b) => {
+    const oa = groupOrder.get(a.groupId) ?? Number.MAX_SAFE_INTEGER;
+    const ob = groupOrder.get(b.groupId) ?? Number.MAX_SAFE_INTEGER;
+    return oa - ob;
+  });
+  if (prepared.length === 0) {
+    log.warn("The agent returned no usable diagrams.");
+  } else {
+    const flagged = prepared.filter((d) => d.warnings.length);
+    if (flagged.length) {
+      log.warn(
+        `${flagged.length}/${prepared.length} diagram(s) have Mermaid warnings \u2014 they will still render if valid, but check: ${flagged.map((d) => d.id).join(", ")}`
+      );
+    }
+  }
+  return { profile: result.profile, diagrams: prepared, notes: result.notes ?? null };
+}
+function renderDiagramsMarkdown(prepared, meta) {
+  const lines = [];
+  lines.push(`# Edsger Diagrams`);
+  lines.push("");
+  lines.push(`> ${prepared.profile.summary}`);
+  lines.push("");
+  lines.push(`| Field | Value |`);
+  lines.push(`| --- | --- |`);
+  lines.push(`| Repository | \`${meta.repo}\` |`);
+  lines.push(`| Languages | ${meta.languages.join(", ") || "n/a"} |`);
+  lines.push(`| Project kinds | ${prepared.profile.kinds.join(", ") || "n/a"} |`);
+  lines.push(`| Catalog sources | ${meta.layers.join(" \u2192 ")} |`);
+  lines.push(`| Model | ${meta.model} |`);
+  lines.push(`| Generated | ${meta.generatedAt} |`);
+  lines.push("");
+  if (prepared.profile.characteristics.length) {
+    lines.push(`**Characteristics:** ${prepared.profile.characteristics.join(" \xB7 ")}`);
+    lines.push("");
+  }
+  let currentGroup = null;
+  for (const d of prepared.diagrams) {
+    if (d.groupName !== currentGroup) {
+      currentGroup = d.groupName;
+      lines.push(`## ${currentGroup}`);
+      lines.push("");
+    }
+    lines.push(`### ${d.title}`);
+    lines.push("");
+    lines.push(`${d.description} _(${d.type})_`);
+    lines.push("");
+    if (d.warnings.length) {
+      lines.push(`> \u26A0\uFE0F ${d.warnings.join("; ")}`);
+      lines.push("");
     }
+    lines.push("```mermaid");
+    lines.push(d.mermaid);
+    lines.push("```");
+    lines.push("");
+    if (d.evidence.length) {
+      lines.push(`<sub>Evidence: ${d.evidence.map((e) => `\`${e}\``).join(", ")}</sub>`);
+      lines.push("");
+    }
+  }
+  if (prepared.notes) {
+    lines.push(`## Notes`);
+    lines.push("");
+    lines.push(prepared.notes);
+    lines.push("");
+  }
+  lines.push(`---`);
+  lines.push(`<sub>Generated by [edsger](https://www.npmjs.com/package/edsger).</sub>`);
+  return lines.join("\n");
+}
+
+// src/commands/diagram.ts
+async function runDiagramGenerate(opts) {
+  const { config, path: configPath } = loadConfig(opts.cwd);
+  const configDir = configPath ? join10(configPath, "..") : opts.cwd;
+  const resolved = resolveStandard("diagrams", opts, config, configDir);
+  const catalog = resolved.standard;
+  log.info(
+    `Diagramming ${pc9.bold(basename3(opts.cwd))} with ${pc9.bold(catalog.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
+  );
+  log.debug(`catalog layers: ${resolved.layers.join(" \u2192 ")}`);
+  const prompt = buildDiagramsPrompt(catalog, opts.cwd, opts.only);
+  const { result, costUsd, numTurns } = await runAgent({
+    prompt,
+    cwd: opts.cwd,
+    model: opts.model,
+    maxTurns: opts.maxTurns,
+    timeoutMs: opts.timeoutMs,
+    allowWrite: false,
+    verbose: opts.verbose,
+    resultShape: DiagramsResultSchema.shape,
+    systemPromptAppend: "You are Edsger, a staff-level software architect. You produce accurate, legible diagrams of a codebase as valid Mermaid, grounded strictly in the code you inspect. Never invent components, tables, or flows that are not in the repository. Do not modify any files."
+  });
+  if (!result) {
+    log.error(
+      "The agent did not produce a result. Try increasing --max-turns or check credentials."
+    );
+    return 1;
+  }
+  const prepared = prepareDiagrams(catalog, result);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = generatedAt.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const git = gitInfo(opts.cwd);
+  const md = renderDiagramsMarkdown(prepared, {
+    repo: basename3(opts.cwd),
+    languages: resolved.languages,
+    layers: resolved.layers,
+    generatedAt,
+    model: opts.model
+  });
+  const jsonReport = {
+    schema: "edsger.diagrams/1",
+    runId,
+    generatedAt,
+    model: opts.model,
+    repo: basename3(opts.cwd),
+    git,
+    languages: resolved.languages,
+    catalog: { name: catalog.name, version: catalog.version, layers: resolved.layers },
+    profile: prepared.profile,
+    diagrams: prepared.diagrams,
+    notes: prepared.notes,
+    costUsd
+  };
+  const groupCounts = {};
+  for (const d of prepared.diagrams) groupCounts[d.groupId] = (groupCounts[d.groupId] ?? 0) + 1;
+  const historyRecord = {
+    runId,
+    generatedAt,
+    commit: git.commit,
+    branch: git.branch,
+    dirty: git.dirty,
+    model: opts.model,
+    catalogVersion: catalog.version,
+    diagramCount: prepared.diagrams.length,
+    groups: groupCounts,
+    costUsd
+  };
+  if (!opts.noWrite && !opts.dryRun) {
+    const baseDir = join10(opts.cwd, opts.out);
+    const mdOut = md + "\n";
+    const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
+    const runDir = join10(baseDir, "runs", runId);
+    mkdirSync4(runDir, { recursive: true });
+    writeFileSync5(join10(runDir, "diagrams.json"), jsonOut, "utf8");
+    writeFileSync5(join10(runDir, "diagrams.md"), mdOut, "utf8");
+    writeFileSync5(join10(baseDir, "diagrams.json"), jsonOut, "utf8");
+    writeFileSync5(join10(baseDir, "diagrams.md"), mdOut, "utf8");
+    appendFileSync3(join10(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
+    log.success(
+      `Diagrams written to ${pc9.bold(join10(opts.out, "diagrams.md"))} ${pc9.dim(`(run archived at ${join10(opts.out, "runs", runId)})`)}`
+    );
+  }
+  printSummary4(prepared, numTurns, costUsd);
+  if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
+  return 0;
+}
+function printSummary4(prepared, numTurns, costUsd) {
+  log.heading(`${prepared.diagrams.length} diagram(s)`);
+  let currentGroup = null;
+  for (const d of prepared.diagrams) {
+    if (d.groupName !== currentGroup) {
+      currentGroup = d.groupName;
+      process.stderr.write(`  ${pc9.bold(currentGroup)}
+`);
+    }
+    const warn = d.warnings.length ? ` ${pc9.yellow("\u26A0")}` : "";
+    process.stderr.write(`    ${pc9.cyan("\u25C6")} ${d.title} ${pc9.dim(`(${d.type})`)}${warn}
+`);
+  }
+  log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
+}
+async function runDiagramServe(opts) {
+  const diagramsDir = join10(opts.cwd, opts.dir);
+  const viewerDir = findDiagramViewerDir();
+  return startViewerServer({
+    viewerDir,
+    indexFile: "diagrams.html",
+    dataRoute: "/edsger-diagrams.json",
+    getData: () => assembleDiagramData(diagramsDir),
+    port: opts.port,
+    host: opts.host,
+    open: opts.open,
+    emptyHint: hasData(assembleDiagramData(diagramsDir)) ? void 0 : `No diagram data in ${opts.dir} yet \u2014 run \`edsger diagram\` first.`
+  });
+}
+async function runDiagramReport(opts) {
+  const diagramsDir = join10(opts.cwd, opts.dir);
+  const data = assembleDiagramData(diagramsDir);
+  if (!hasData(data)) {
+    log.error(`No diagram data in ${opts.dir}. Run \`edsger diagram\` first.`);
+    return 1;
+  }
+  const html = renderDiagramsSingleFile(readDiagramViewerSingleTemplate(), data);
+  const out = isAbsolute4(opts.html) ? opts.html : join10(opts.cwd, opts.html);
+  mkdirSync4(dirname4(out), { recursive: true });
+  writeFileSync5(out, html, "utf8");
+  log.success(
+    `Wrote self-contained diagram viewer to ${pc9.bold(opts.html)} ${pc9.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
+  );
+  if (opts.open) openInBrowser(out);
+  return 0;
+}
+
+// src/commands/mindmap.ts
+import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute5, join as join11 } from "path";
+import pc10 from "picocolors";
+
+// src/core/mindmap.ts
+function buildMindmapPrompt(standard, cwd, focus) {
+  const maxDepth = standard.maxDepth ?? 5;
+  const aspectsText = standard.aspects.map((a) => {
+    const detect = a.detect?.length ? `
+    detect: ${a.detect.join(", ")}` : "";
+    return `  - id: ${a.id}
+    name: ${a.name}
+    appliesWhen: ${a.appliesWhen.trim()}` + detect + `
+    guidance: ${a.guidance.trim()}`;
+  }).join("\n");
+  return [
+    `Build an implementation mind map of the repository at: ${cwd}`,
+    ``,
+    `The mind map is an outline tree (like Workflowy): the root is the project,`,
+    `and the branches explain how the code is actually implemented, deep enough`,
+    `that leaves point at concrete files.`,
+    ...focus ? [
+      ``,
+      `FOCUS: the user asked the map to concentrate on: "${focus}". Give that`,
+      `area most of the depth; keep other branches to a shallow orientation level.`
+    ] : [],
+    ``,
+    `Method:`,
+    `1. Explore the repository (Read/Grep/Glob and read-only Bash like ls, cat,`,
+    `   git log). Characterise the project: what kind is it (service, library, CLI,`,
+    `   SPA, data pipeline, monorepo, \u2026) and how the source is organised.`,
+    `2. You have a list of candidate top-level branches ("aspects") below. Keep only`,
+    `   the ones THIS project's code supports (use appliesWhen/detect), rename them`,
+    `   to the project's own vocabulary where that is clearer, and grow each into a`,
+    `   subtree by following its guidance. Aim for 3-7 first-level branches.`,
+    `3. Tree rules:`,
+    `   - Root node: the project \u2014 its name as the title, a one-line summary of`,
+    `     what it does. Exactly ONE root.`,
+    `   - Every node: a short title (2-6 words, like an outline bullet) and a one-`,
+    `     or-two-sentence summary that says something true and specific about THIS`,
+    `     codebase \u2014 no generic filler.`,
+    `   - Interior nodes group; leaf nodes land on concrete implementation and MUST`,
+    `     cite the repo-relative file(s) they describe in "files".`,
+    `   - Maximum depth ${maxDepth} (root inclusive). Prefer depth where the code is`,
+    `     interesting, brevity where it is boilerplate. Do NOT invent structure that`,
+    `     is not in the code, and do not just mirror the file listing \u2014 explain it.`,
+    `4. Encode the tree as a FLAT node list: each node has a unique kebab-case "id"`,
+    `   and a "parentId" referencing its parent's id (null only for the root). List`,
+    `   children in reading order right after their parent. Tag each node with a`,
+    `   "kind": area, module, component, flow, step, data, external, config, or topic.`,
+    `5. When finished, call submit_result exactly once with the project profile,`,
+    `   the flat node list, and optional notes.`,
+    ``,
+    ...standard.guidance ? [`Overall guidance: ${standard.guidance.trim()}`, ``] : [],
+    `Candidate top-level branches:`,
+    aspectsText
+  ].join("\n");
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "node";
+}
+function prepareMindmap(result, fallback) {
+  const warnings = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const raw of result.nodes) {
+    const node = { ...raw, id: raw.id?.trim() || slugify(raw.title) };
+    if (!node.title?.trim()) {
+      warnings.push(`dropped a node with no title (id "${node.id}")`);
+      continue;
+    }
+    let id = node.id;
+    for (let n = 2; byId.has(id); n++) id = `${node.id}-${n}`;
+    if (id !== node.id) warnings.push(`renamed duplicate node id "${node.id}" to "${id}"`);
+    byId.set(id, { ...node, id });
+  }
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const node of byId.values()) {
+    const p = node.parentId && node.parentId !== node.id ? node.parentId : null;
+    parentOf.set(node.id, p && byId.has(p) ? p : null);
+    if (node.parentId && !byId.has(node.parentId)) {
+      warnings.push(`node "${node.id}" referenced missing parent "${node.parentId}"`);
+    }
+  }
+  for (const id of parentOf.keys()) {
+    const seen = /* @__PURE__ */ new Set([id]);
+    let cur = parentOf.get(id) ?? null;
+    while (cur) {
+      if (seen.has(cur)) {
+        warnings.push(`broke a parent cycle at node "${cur}"`);
+        parentOf.set(cur, null);
+        break;
+      }
+      seen.add(cur);
+      cur = parentOf.get(cur) ?? null;
+    }
+  }
+  const treeOf = /* @__PURE__ */ new Map();
+  for (const node of byId.values()) {
+    treeOf.set(node.id, {
+      id: node.id,
+      title: node.title.trim(),
+      summary: node.summary?.trim() ?? "",
+      kind: node.kind?.trim() || "topic",
+      files: node.files ?? [],
+      children: []
+    });
   }
-  const repo = latest && typeof latest === "object" && "repo" in latest ? latest.repo : void 0;
-  return { repo, latest, history, runs };
+  const roots = [];
+  for (const node of byId.values()) {
+    const tree = treeOf.get(node.id);
+    const parent = parentOf.get(node.id);
+    if (parent) treeOf.get(parent).children.push(tree);
+    else roots.push(tree);
+  }
+  let root;
+  if (roots.length === 1 && roots[0]) {
+    root = roots[0];
+  } else {
+    if (roots.length > 1) warnings.push(`${roots.length} root nodes \u2014 gathered under the project`);
+    let rootId = "root";
+    for (let n = 2; treeOf.has(rootId); n++) rootId = `root-${n}`;
+    root = {
+      id: rootId,
+      title: fallback.repo,
+      summary: result.profile.summary,
+      kind: "area",
+      files: [],
+      children: roots
+    };
+  }
+  const nodeCount = countNodes(root);
+  const depth = treeDepth(root);
+  if (nodeCount <= 1) log.warn("The agent returned an (almost) empty mind map.");
+  for (const w of warnings) log.warn(`mindmap: ${w}`);
+  return { profile: result.profile, root, nodeCount, depth, warnings, notes: result.notes ?? null };
 }
-function hasData(data) {
-  return Boolean(data.latest) || data.history.length > 0;
+function countNodes(node) {
+  return 1 + node.children.reduce((acc, c) => acc + countNodes(c), 0);
 }
-function findViewerDir() {
-  const dir = join5(findBundledAssetsDir(), "viewer");
-  if (!existsSync3(join5(dir, "index.html"))) {
-    throw new Error(
-      "Dashboard viewer assets not found. Reinstall edsger, or run `npm run sync-viewer` in a dev checkout."
-    );
-  }
-  return dir;
+function treeDepth(node) {
+  return 1 + node.children.reduce((acc, c) => Math.max(acc, treeDepth(c)), 0);
 }
-function readViewerSingleTemplate() {
-  const file = join5(findBundledAssetsDir(), "viewer-single.html");
-  if (!existsSync3(file)) {
-    throw new Error(
-      "Single-file viewer template not found. Reinstall edsger, or run `npm run sync-viewer`."
-    );
+function renderMindmapMarkdown(prepared, meta) {
+  const lines = [];
+  lines.push(`# Edsger Mind Map`);
+  lines.push("");
+  lines.push(`> ${prepared.profile.summary}`);
+  lines.push("");
+  lines.push(`| Field | Value |`);
+  lines.push(`| --- | --- |`);
+  lines.push(`| Repository | \`${meta.repo}\` |`);
+  lines.push(`| Languages | ${meta.languages.join(", ") || "n/a"} |`);
+  lines.push(`| Project kinds | ${prepared.profile.kinds.join(", ") || "n/a"} |`);
+  lines.push(`| Nodes | ${prepared.nodeCount} (depth ${prepared.depth}) |`);
+  lines.push(`| Standard sources | ${meta.layers.join(" \u2192 ")} |`);
+  lines.push(`| Model | ${meta.model} |`);
+  lines.push(`| Generated | ${meta.generatedAt} |`);
+  lines.push("");
+  lines.push(`## ${prepared.root.title}`);
+  if (prepared.root.summary && prepared.root.summary !== prepared.profile.summary) {
+    lines.push("");
+    lines.push(prepared.root.summary);
+  }
+  lines.push("");
+  for (const child of prepared.root.children) renderNode(lines, child, 0);
+  if (prepared.notes) {
+    lines.push("");
+    lines.push(`## Notes`);
+    lines.push("");
+    lines.push(prepared.notes);
   }
-  return readFileSync2(file, "utf8");
+  lines.push("");
+  lines.push(`---`);
+  lines.push(`<sub>Generated by [edsger](https://www.npmjs.com/package/edsger).</sub>`);
+  return lines.join("\n");
 }
-function renderSingleFile(template, data) {
-  const json = JSON.stringify(data).replace(/<\//g, "<\\/");
-  const tag = `<script>window.__EDSGER_DATA__=${json}</script>`;
-  if (template.includes("</head>")) return template.replace("</head>", `${tag}</head>`);
-  return template.replace("<body>", `<body>${tag}`);
+function renderNode(lines, node, indent2) {
+  const pad = "  ".repeat(indent2);
+  const files = node.files.length ? ` ${node.files.map((f) => `\`${f}\``).join(" ")}` : "";
+  const summary = node.summary ? ` \u2014 ${node.summary}` : "";
+  lines.push(`${pad}- **${node.title}**${summary}${files}`);
+  for (const child of node.children) renderNode(lines, child, indent2 + 1);
 }
-function readJson(path) {
-  try {
-    return JSON.parse(readFileSync2(path, "utf8"));
-  } catch {
-    return null;
+
+// src/commands/mindmap.ts
+async function runMindmapGenerate(opts) {
+  const { config, path: configPath } = loadConfig(opts.cwd);
+  const configDir = configPath ? join11(configPath, "..") : opts.cwd;
+  const resolved = resolveStandard("mindmap", opts, config, configDir);
+  const standard = resolved.standard;
+  log.info(
+    `Mind-mapping ${pc10.bold(basename4(opts.cwd))} with ${pc10.bold(standard.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
+  );
+  log.debug(`standard layers: ${resolved.layers.join(" \u2192 ")}`);
+  const prompt = buildMindmapPrompt(standard, opts.cwd, opts.focus);
+  const { result, costUsd, numTurns } = await runAgent({
+    prompt,
+    cwd: opts.cwd,
+    model: opts.model,
+    maxTurns: opts.maxTurns,
+    timeoutMs: opts.timeoutMs,
+    allowWrite: false,
+    verbose: opts.verbose,
+    resultShape: MindmapResultSchema.shape,
+    systemPromptAppend: "You are Edsger, a staff-level engineer explaining a codebase to a newcomer. You produce a faithful implementation mind map grounded strictly in the code you inspect: every node true and specific, every leaf citing real files. Never invent modules, flows, or files that are not in the repository. Do not modify any files."
+  });
+  if (!result) {
+    log.error(
+      "The agent did not produce a result. Try increasing --max-turns or check credentials."
+    );
+    return 1;
   }
-}
-function readJsonl(path) {
-  if (!existsSync3(path)) return [];
-  const out = [];
-  for (const line of readFileSync2(path, "utf8").split("\n")) {
-    const t = line.trim();
-    if (!t) continue;
-    try {
-      out.push(JSON.parse(t));
-    } catch {
-    }
+  const prepared = prepareMindmap(result, { repo: basename4(opts.cwd) });
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = generatedAt.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const git = gitInfo(opts.cwd);
+  const md = renderMindmapMarkdown(prepared, {
+    repo: basename4(opts.cwd),
+    languages: resolved.languages,
+    layers: resolved.layers,
+    generatedAt,
+    model: opts.model
+  });
+  const jsonReport = {
+    schema: "edsger.mindmap/1",
+    runId,
+    generatedAt,
+    model: opts.model,
+    repo: basename4(opts.cwd),
+    git,
+    languages: resolved.languages,
+    standard: { name: standard.name, version: standard.version, layers: resolved.layers },
+    profile: prepared.profile,
+    root: prepared.root,
+    nodeCount: prepared.nodeCount,
+    depth: prepared.depth,
+    focus: opts.focus ?? null,
+    notes: prepared.notes,
+    costUsd
+  };
+  const historyRecord = {
+    runId,
+    generatedAt,
+    commit: git.commit,
+    branch: git.branch,
+    dirty: git.dirty,
+    model: opts.model,
+    standardVersion: standard.version,
+    nodeCount: prepared.nodeCount,
+    depth: prepared.depth,
+    costUsd
+  };
+  if (!opts.noWrite && !opts.dryRun) {
+    const baseDir = join11(opts.cwd, opts.out);
+    const mdOut = md + "\n";
+    const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
+    const runDir = join11(baseDir, "runs", runId);
+    mkdirSync5(runDir, { recursive: true });
+    writeFileSync6(join11(runDir, "mindmap.json"), jsonOut, "utf8");
+    writeFileSync6(join11(runDir, "mindmap.md"), mdOut, "utf8");
+    writeFileSync6(join11(baseDir, "mindmap.json"), jsonOut, "utf8");
+    writeFileSync6(join11(baseDir, "mindmap.md"), mdOut, "utf8");
+    appendFileSync4(join11(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
+    log.success(
+      `Mind map written to ${pc10.bold(join11(opts.out, "mindmap.md"))} ${pc10.dim(`(run archived at ${join11(opts.out, "runs", runId)})`)}`
+    );
   }
-  return out;
+  printSummary5(prepared, numTurns, costUsd);
+  if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
+  return 0;
 }
-
-// src/core/open.ts
-import { spawn } from "child_process";
-function openInBrowser(target) {
-  const platform = process.platform;
-  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
-  const args = platform === "win32" ? ["/c", "start", "", target] : [target];
-  try {
-    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
-  } catch {
+function printSummary5(prepared, numTurns, costUsd) {
+  log.heading(`${prepared.root.title} \u2014 ${prepared.nodeCount} nodes, depth ${prepared.depth}`);
+  const line = (node, indent2) => {
+    const kids = node.children.length ? pc10.dim(` (${countNodes2(node) - 1})`) : "";
+    process.stderr.write(`${indent2}${pc10.cyan("\u2022")} ${node.title}${kids}
+`);
+  };
+  for (const branch of prepared.root.children) {
+    line(branch, "  ");
+    for (const child of branch.children) line(child, "      ");
   }
+  log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
 }
-
-// src/commands/serve.ts
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".map": "application/json",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".woff": "font/woff"
-};
-async function runServe(opts) {
-  const benchmarkDir = join6(opts.cwd, opts.dir);
-  const viewerDir = findViewerDir();
-  const server = createServer((req, res) => {
-    const url = (req.url ?? "/").split("?")[0] ?? "/";
-    if (url === "/edsger-data.json") {
-      res.writeHead(200, {
-        "content-type": "application/json; charset=utf-8",
-        "cache-control": "no-store"
-      });
-      res.end(JSON.stringify(assembleData(benchmarkDir)));
-      return;
-    }
-    const rel = url === "/" ? "index.html" : decodeURIComponent(url.replace(/^\/+/, ""));
-    const safe = normalize(rel).replace(/^(\.\.(?:[/\\]|$))+/, "");
-    let file = join6(viewerDir, safe);
-    if (!file.startsWith(viewerDir)) {
-      res.writeHead(403);
-      res.end("forbidden");
-      return;
-    }
-    if (!existsSync4(file) || statSync2(file).isDirectory()) file = join6(viewerDir, "index.html");
-    res.writeHead(200, { "content-type": MIME[extname(file)] ?? "application/octet-stream" });
-    createReadStream(file).pipe(res);
-  });
-  return new Promise((resolve3, reject) => {
-    server.on("error", reject);
-    server.listen(opts.port, opts.host, () => {
-      const addr = server.address();
-      const port = typeof addr === "object" && addr ? addr.port : opts.port;
-      const shownHost = opts.host === "0.0.0.0" ? "localhost" : opts.host;
-      const url = `http://${shownHost}:${port}/`;
-      if (!hasData(assembleData(benchmarkDir))) {
-        log.warn(`No benchmark data in ${opts.dir} yet \u2014 run \`edsger benchmark\` first.`);
-      }
-      log.success(`Dashboard at ${pc6.bold(pc6.cyan(url))}  ${pc6.dim("(Ctrl-C to stop)")}`);
-      if (opts.open) openInBrowser(url);
-    });
-    const shutdown = () => {
-      server.close(() => resolve3(0));
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+function countNodes2(node) {
+  return 1 + node.children.reduce((acc, c) => acc + countNodes2(c), 0);
+}
+async function runMindmapServe(opts) {
+  const mindmapDir = join11(opts.cwd, opts.dir);
+  const viewerDir = findMindmapViewerDir();
+  return startViewerServer({
+    viewerDir,
+    indexFile: "mindmap.html",
+    dataRoute: "/edsger-mindmap.json",
+    getData: () => assembleMindmapData(mindmapDir),
+    port: opts.port,
+    host: opts.host,
+    open: opts.open,
+    emptyHint: hasData(assembleMindmapData(mindmapDir)) ? void 0 : `No mind-map data in ${opts.dir} yet \u2014 run \`edsger mindmap\` first.`
   });
 }
-
-// src/commands/report.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join7 } from "path";
-import pc7 from "picocolors";
-async function runReport(opts) {
-  const benchmarkDir = join7(opts.cwd, opts.dir);
-  const data = assembleData(benchmarkDir);
+async function runMindmapReport(opts) {
+  const mindmapDir = join11(opts.cwd, opts.dir);
+  const data = assembleMindmapData(mindmapDir);
   if (!hasData(data)) {
-    log.error(`No benchmark data in ${opts.dir}. Run \`edsger benchmark\` first.`);
+    log.error(`No mind-map data in ${opts.dir}. Run \`edsger mindmap\` first.`);
     return 1;
   }
-  const html = renderSingleFile(readViewerSingleTemplate(), data);
-  const out = isAbsolute2(opts.html) ? opts.html : join7(opts.cwd, opts.html);
-  mkdirSync2(dirname2(out), { recursive: true });
-  writeFileSync3(out, html, "utf8");
+  const html = renderMindmapSingleFile(readMindmapViewerSingleTemplate(), data);
+  const out = isAbsolute5(opts.html) ? opts.html : join11(opts.cwd, opts.html);
+  mkdirSync5(dirname5(out), { recursive: true });
+  writeFileSync6(out, html, "utf8");
   log.success(
-    `Wrote self-contained report to ${pc7.bold(opts.html)} ${pc7.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
+    `Wrote self-contained mind-map viewer to ${pc10.bold(opts.html)} ${pc10.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
   );
   if (opts.open) openInBrowser(out);
   return 0;
@@ -1428,22 +2662,22 @@ async function runReport(opts) {
 import {
   cpSync,
   existsSync as existsSync5,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync6,
   readFileSync as readFileSync3,
   readdirSync as readdirSync3,
   rmSync as rmSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join8 } from "path";
-import pc8 from "picocolors";
-var MANAGED = ["benchmark", "pr-review", "pr-resolve"];
+import { join as join12 } from "path";
+import pc11 from "picocolors";
+var MANAGED = ["benchmark", "audit", "pr-review", "pr-resolve"];
 function targetSkillsDir(scope) {
-  return scope.global ? join8(homedir2(), ".claude", "skills") : join8(scope.cwd, ".claude", "skills");
+  return scope.global ? join12(homedir2(), ".claude", "skills") : join12(scope.cwd, ".claude", "skills");
 }
 function sourceSkillsDir() {
-  return join8(findBundledAssetsDir(), "skills");
+  return join12(findBundledAssetsDir(), "skills");
 }
 async function runSkillsInstall(opts) {
   const assetsDir = findBundledAssetsDir();
@@ -1453,20 +2687,20 @@ async function runSkillsInstall(opts) {
     return 1;
   }
   const dest = targetSkillsDir(opts);
-  mkdirSync3(dest, { recursive: true });
-  const available = readdirSync3(src).filter((n) => existsSync5(join8(src, n, "SKILL.md")));
+  mkdirSync6(dest, { recursive: true });
+  const available = readdirSync3(src).filter((n) => existsSync5(join12(src, n, "SKILL.md")));
   let installed = 0;
   for (const name of available) {
-    const outDir = join8(dest, name);
+    const outDir = join12(dest, name);
     if (existsSync5(outDir) && !opts.force) {
       log.warn(`skill "${name}" already exists \u2014 use --force to overwrite`);
       continue;
     }
     rmSync2(outDir, { recursive: true, force: true });
-    cpSync(join8(src, name), outDir, { recursive: true });
-    const skillFile = join8(outDir, "SKILL.md");
+    cpSync(join12(src, name), outDir, { recursive: true });
+    const skillFile = join12(outDir, "SKILL.md");
     const rewritten = readFileSync3(skillFile, "utf8").split("${CLAUDE_PLUGIN_ROOT}").join(assetsDir);
-    writeFileSync4(skillFile, rewritten, "utf8");
+    writeFileSync7(skillFile, rewritten, "utf8");
     installed++;
     log.success(`installed /${name}`);
   }
@@ -1474,17 +2708,17 @@ async function runSkillsInstall(opts) {
     log.info("Nothing installed.");
     return 0;
   }
-  log.heading(`Installed ${installed} skill(s) into ${pc8.bold(dest)}`);
+  log.heading(`Installed ${installed} skill(s) into ${pc11.bold(dest)}`);
   log.step(`scope: ${opts.global ? "user (all projects)" : "this project"}`);
   log.step(`standards: ${assetsDir}`);
-  log.step("Open Claude Code and run /benchmark, /pr-review, or /pr-resolve.");
+  log.step("Open Claude Code and run /benchmark, /audit, /pr-review, or /pr-resolve.");
   return 0;
 }
 async function runSkillsUninstall(opts) {
   const dest = targetSkillsDir(opts);
   let removed = 0;
   for (const name of MANAGED) {
-    const dir = join8(dest, name);
+    const dir = join12(dest, name);
     if (existsSync5(dir)) {
       rmSync2(dir, { recursive: true, force: true });
       removed++;
@@ -1501,13 +2735,13 @@ async function runSkillsList(opts) {
   ]) {
     const dir = targetSkillsDir(scope);
     const present = MANAGED.filter((n) => {
-      const p = join8(dir, n, "SKILL.md");
+      const p = join12(dir, n, "SKILL.md");
       return existsSync5(p) && statSync3(p).isFile();
     });
     log.heading(`${label}: ${dir}`);
-    if (present.length) for (const n of present) process.stderr.write(`  ${pc8.green("\u2713")} /${n}
+    if (present.length) for (const n of present) process.stderr.write(`  ${pc11.green("\u2713")} /${n}
 `);
-    else process.stderr.write(`  ${pc8.dim("(none installed)")}
+    else process.stderr.write(`  ${pc11.dim("(none installed)")}
 `);
   }
   return 0;
@@ -1549,7 +2783,7 @@ async function guard(fn) {
 }
 var program = new Command();
 program.name("edsger").description(
-  "Agentic CLI to benchmark repositories and review/resolve pull requests\nagainst industrial-grade standards (from edsger-assets, fully overridable)."
+  "Agentic CLI to benchmark and audit repositories and review/resolve pull requests\nagainst industrial-grade standards (from edsger-assets, fully overridable)."
 ).version(VERSION, "-V, --version");
 addGlobalOptions(
   program.command("benchmark").description("Score a repository against a benchmark rubric and write a report").option("--out <dir>", "report output directory (relative to repo)", ".edsger/benchmark").option("--no-write", "do not write report files into the repo").option("--serve", "open the dashboard after benchmarking")
@@ -1563,6 +2797,66 @@ addGlobalOptions(
     return code;
   });
 });
+var FAIL_ON_SEVERITIES = ["critical", "high", "medium", "low"];
+var audit = program.command("audit").alias("review").description(
+  "Audit the whole repository: hunt for unprofessional, outdated, or fragile implementations across every dimension and write an organised issue report"
+);
+addGlobalOptions(
+  audit.command("generate", { isDefault: true }).description("Audit the repository and write the findings report").option("--out <dir>", "report output directory (relative to repo)", ".edsger/audit").option("--no-write", "do not write report files into the repo").option("--only <ids>", "comma-separated dimension ids to audit (default: all)").option("--focus <text>", "area or concern the audit should concentrate on").addOption(
+    new Option(
+      "--fail-on <severity>",
+      "exit with code 2 if findings exist at or above this severity (CI gate)"
+    ).choices(FAIL_ON_SEVERITIES)
+  ).option("--serve", "open the findings dashboard after auditing")
+).action(
+  async (opts) => {
+    await guard(async () => {
+      const g = toGlobal(opts);
+      const code = await runAudit({
+        ...g,
+        out: opts.out,
+        noWrite: opts.write === false,
+        only: opts.only ? opts.only.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+        focus: opts.focus,
+        failOn: opts.failOn
+      });
+      if (code !== 1 && opts.serve) {
+        const serveCode = await runAuditServe({
+          cwd: g.cwd,
+          dir: opts.out,
+          port: 4580,
+          host: "127.0.0.1",
+          open: true
+        });
+        return code || serveCode;
+      }
+      return code;
+    });
+  }
+);
+audit.command("serve").description("Serve the audit findings dashboard locally").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "audit output directory (relative to repo)", ".edsger/audit").option("--port <n>", "port to listen on", "4580").option("--host <host>", "host to bind", "127.0.0.1").option("--no-open", "do not open the browser automatically").action(
+  async (opts) => {
+    await guard(
+      () => runAuditServe({
+        cwd: resolve2(opts.cwd ?? process.cwd()),
+        dir: opts.dir,
+        port: Number.parseInt(opts.port, 10) || 4580,
+        host: opts.host,
+        open: opts.open !== false
+      })
+    );
+  }
+);
+audit.command("report").description("Export a self-contained HTML findings viewer (data inlined) for sharing").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "audit output directory (relative to repo)", ".edsger/audit").option("--html <path>", "output HTML file path", "edsger-audit.html").option("--open", "open the exported file after writing").action(async (opts) => {
+  await guard(
+    () => runAuditReport({
+      cwd: resolve2(opts.cwd ?? process.cwd()),
+      dir: opts.dir,
+      html: opts.html,
+      open: Boolean(opts.open)
+    })
+  );
+});
 program.command("serve").description("Serve the benchmark dashboard (current, history, trends) locally").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "benchmark output directory (relative to repo)", ".edsger/benchmark").option("--port <n>", "port to listen on", "4577").option("--host <host>", "host to bind", "127.0.0.1").option("--no-open", "do not open the browser automatically").action(
   async (opts) => {
     await guard(
@@ -1586,6 +2880,105 @@ program.command("report").description("Export a self-contained HTML dashboard (d
     })
   );
 });
+var diagram = program.command("diagram").description("Generate & view diagrams (architecture, ER, sequence, flow) for a repository");
+addGlobalOptions(
+  diagram.command("generate", { isDefault: true }).description("Analyze the repository and generate diagrams as Mermaid").option("--out <dir>", "diagram output directory (relative to repo)", ".edsger/diagrams").option("--no-write", "do not write diagram files into the repo").option("--only <ids>", "comma-separated catalog diagram ids to generate").option("--serve", "open the diagram dashboard after generating")
+).action(
+  async (opts) => {
+    await guard(async () => {
+      const g = toGlobal(opts);
+      const only = opts.only ? opts.only.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+      const code = await runDiagramGenerate({
+        ...g,
+        out: opts.out,
+        noWrite: opts.write === false,
+        only
+      });
+      if (code === 0 && opts.serve) {
+        return runDiagramServe({
+          cwd: g.cwd,
+          dir: opts.out,
+          port: 4578,
+          host: "127.0.0.1",
+          open: true
+        });
+      }
+      return code;
+    });
+  }
+);
+diagram.command("serve").description("Serve the diagram dashboard locally").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "diagram output directory (relative to repo)", ".edsger/diagrams").option("--port <n>", "port to listen on", "4578").option("--host <host>", "host to bind", "127.0.0.1").option("--no-open", "do not open the browser automatically").action(
+  async (opts) => {
+    await guard(
+      () => runDiagramServe({
+        cwd: resolve2(opts.cwd ?? process.cwd()),
+        dir: opts.dir,
+        port: Number.parseInt(opts.port, 10) || 4578,
+        host: opts.host,
+        open: opts.open !== false
+      })
+    );
+  }
+);
+diagram.command("report").description("Export a self-contained HTML diagram viewer (data inlined) for sharing").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "diagram output directory (relative to repo)", ".edsger/diagrams").option("--html <path>", "output HTML file path", "edsger-diagrams.html").option("--open", "open the exported file after writing").action(async (opts) => {
+  await guard(
+    () => runDiagramReport({
+      cwd: resolve2(opts.cwd ?? process.cwd()),
+      dir: opts.dir,
+      html: opts.html,
+      open: Boolean(opts.open)
+    })
+  );
+});
+var mindmap = program.command("mindmap").description("Generate & browse an implementation mind map (Workflowy-style outline) of a repo");
+addGlobalOptions(
+  mindmap.command("generate", { isDefault: true }).description("Analyze the repository and generate the implementation mind map").option("--out <dir>", "mind-map output directory (relative to repo)", ".edsger/mindmap").option("--no-write", "do not write mind-map files into the repo").option("--focus <text>", "area or topic the map should concentrate its depth on").option("--serve", "open the mind-map viewer after generating")
+).action(
+  async (opts) => {
+    await guard(async () => {
+      const g = toGlobal(opts);
+      const code = await runMindmapGenerate({
+        ...g,
+        out: opts.out,
+        noWrite: opts.write === false,
+        focus: opts.focus
+      });
+      if (code === 0 && opts.serve) {
+        return runMindmapServe({
+          cwd: g.cwd,
+          dir: opts.out,
+          port: 4579,
+          host: "127.0.0.1",
+          open: true
+        });
+      }
+      return code;
+    });
+  }
+);
+mindmap.command("serve").description("Serve the mind-map viewer locally").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "mind-map output directory (relative to repo)", ".edsger/mindmap").option("--port <n>", "port to listen on", "4579").option("--host <host>", "host to bind", "127.0.0.1").option("--no-open", "do not open the browser automatically").action(
+  async (opts) => {
+    await guard(
+      () => runMindmapServe({
+        cwd: resolve2(opts.cwd ?? process.cwd()),
+        dir: opts.dir,
+        port: Number.parseInt(opts.port, 10) || 4579,
+        host: opts.host,
+        open: opts.open !== false
+      })
+    );
+  }
+);
+mindmap.command("report").description("Export a self-contained HTML mind-map viewer (data inlined) for sharing").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "mind-map output directory (relative to repo)", ".edsger/mindmap").option("--html <path>", "output HTML file path", "edsger-mindmap.html").option("--open", "open the exported file after writing").action(async (opts) => {
+  await guard(
+    () => runMindmapReport({
+      cwd: resolve2(opts.cwd ?? process.cwd()),
+      dir: opts.dir,
+      html: opts.html,
+      open: Boolean(opts.open)
+    })
+  );
+});
 addGlobalOptions(
   program.command("pr-review").description("Review a pull request against the review standard (requires gh)").argument("<pr>", "PR number, URL, or branch").option("--repo <owner/repo>", "target repository (defaults to current)").option("--post", "submit the review to GitHub (otherwise preview only)")
 ).action(async (pr, opts) => {
@@ -1609,7 +3002,9 @@ addGlobalOptions(
     );
   }
 );
-var skills = program.command("skills").description("install edsger as Claude Code skills (/benchmark, /pr-review, /pr-resolve)");
+var skills = program.command("skills").description(
+  "install edsger as Claude Code skills (/benchmark, /audit, /pr-review, /pr-resolve)"
+);
 skills.command("install").description("install the skills into Claude Code").option("--global", "install for the current user (~/.claude/skills) [default]").option("--project", "install into ./.claude/skills instead").option("-C, --cwd <dir>", "project directory (with --project)").option("--force", "overwrite existing skills").action(async (opts) => {
   await guard(
     () => runSkillsInstall({
@@ -1634,11 +3029,18 @@ program.addHelpText(
   "after",
   `
 Examples:
-  ${pc9.dim("$")} edsger benchmark
-  ${pc9.dim("$")} edsger benchmark -C ./my-repo --json
-  ${pc9.dim("$")} edsger pr-review 123 --post
-  ${pc9.dim("$")} edsger pr-resolve 123 --instruction "fix the failing test" --push
-  ${pc9.dim("$")} edsger skills install   ${pc9.dim("# enable /benchmark etc. in Claude Code")}
+  ${pc12.dim("$")} edsger benchmark
+  ${pc12.dim("$")} edsger benchmark -C ./my-repo --json
+  ${pc12.dim("$")} edsger audit                ${pc12.dim("# nitpick the whole repo, report issues")}
+  ${pc12.dim("$")} edsger audit --fail-on high ${pc12.dim("# CI gate: fail on high/critical findings")}
+  ${pc12.dim("$")} edsger diagram              ${pc12.dim("# generate diagrams for the current repo")}
+  ${pc12.dim("$")} edsger diagram --serve      ${pc12.dim("# \u2026and open them in the browser")}
+  ${pc12.dim("$")} edsger diagram report --html diagrams.html
+  ${pc12.dim("$")} edsger mindmap              ${pc12.dim("# implementation mind map of the repo")}
+  ${pc12.dim("$")} edsger mindmap --serve      ${pc12.dim("# \u2026browse it Workflowy-style")}
+  ${pc12.dim("$")} edsger pr-review 123 --post
+  ${pc12.dim("$")} edsger pr-resolve 123 --instruction "fix the failing test" --push
+  ${pc12.dim("$")} edsger skills install   ${pc12.dim("# enable /benchmark etc. in Claude Code")}
 
 Auth: the agent uses your Claude Code login (run \`claude\` once to sign in); run \`gh auth login\` for PR commands.
 `