edsger 0.83.0 → 0.85.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 pc10 from "picocolors";
+import pc13 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,7 @@ function resolveStandard(kind, opts, config, configDir, forcedLanguages) {
   const roots = [
     { path: bundled, label: opts.assetsPath ? `assets:${opts.assetsPath}` : "bundled" }
   ];
-  const perKind = kind === "benchmark" ? config.benchmark?.standards : kind === "diagrams" ? config.diagrams?.standards : config.review?.standards;
+  const perKind = kind === "benchmark" ? config.benchmark?.standards : kind === "diagrams" ? config.diagrams?.standards : kind === "mindmap" ? config.mindmap?.standards : kind === "testcases" ? config.testcases?.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}` });
@@ -182,6 +182,24 @@ function mergeLayers(kind, layers) {
       {}
     );
   }
+  if (kind === "mindmap") {
+    return layers.reduce(
+      (acc, layer) => mergeMindmap(acc, layer),
+      {}
+    );
+  }
+  if (kind === "testcases") {
+    return layers.reduce(
+      (acc, layer) => mergeTestcases(acc, layer),
+      {}
+    );
+  }
+  if (kind === "audit") {
+    return layers.reduce(
+      (acc, layer) => mergeAudit(acc, layer),
+      {}
+    );
+  }
   return layers.reduce(
     (acc, layer) => mergeReview(acc, layer),
     {}
@@ -208,6 +226,42 @@ function mergeDiagrams(base, overlay) {
     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 mergeTestcases(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: "testcases",
+    guidance: overlay.guidance ?? base.guidance,
+    maxDepth: overlay.maxDepth ?? base.maxDepth,
+    aspects
+  };
+}
 function mergeBenchmark(base, overlay) {
   const categories = mergeById(
     base.categories ?? [],
@@ -233,6 +287,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 ?? [],
@@ -518,6 +591,133 @@ 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 assembleTestcasesData(testcasesDir) {
+  return assembleFrom(testcasesDir, "testcases.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 findTestcasesViewerDir() {
+  return findViewerDir("testcases-viewer", "testcases.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 readTestcasesViewerSingleTemplate() {
+  return readSingleTemplate("testcases-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 renderTestcasesSingleFile(template, data) {
+  return renderSingleFileWith(template, data, "__EDSGER_TESTCASES__");
+}
+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) {
@@ -542,151 +742,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.`);
-  }
-  const overall = round(
-    categories.reduce((s, c) => s + c.points, 0),
-    1
-  );
+}
+
+// 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);
+  }
+  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
@@ -729,6 +998,21 @@ 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([]),
@@ -757,28 +1041,70 @@ var DiagramsResultSchema = z.object({
   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")
+});
+var TestcasePrioritySchema = z.enum(["critical", "high", "medium", "low"]);
+var TestcaseNodeSchema = z.object({
+  id: z.string().describe("Unique kebab-case node id, e.g. 'core-flows' or 'login-empty-password'"),
+  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-8 words"),
+  summary: z.string().describe("One or two sentences: what this area covers, or what this case verifies"),
+  kind: z.string().default("topic").describe("Tag: area, feature, flow, scenario, case, or topic ('case' = executable leaf)"),
+  priority: TestcasePrioritySchema.nullable().default(null).describe("Case priority (critical/high/medium/low); null for grouping nodes"),
+  preconditions: z.array(z.string()).default([]).describe("State a tester must prepare before the steps (cases only)"),
+  steps: z.array(z.string()).default([]).describe("Exact, observable manual actions, in order (cases only)"),
+  expected: z.string().nullable().default(null).describe("The single expected outcome the tester verifies (cases only)"),
+  files: z.array(z.string()).default([]).describe("Repo-relative files implementing the behaviour under test")
+});
+var TestcasesResultSchema = 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 plan (owns a Postgres DB, monorepo, \u2026)")
+  }).describe("The project profile behind the plan's shape"),
+  nodes: z.array(TestcaseNodeSchema).describe(
+    "The whole test plan as a flat node list: exactly one root (parentId=null), children listed in reading order after their parent, leaves as concrete cases"
+  ),
+  notes: z.string().nullable().default(null).describe("Optional notes, e.g. areas intentionally left untested and why")
+});
 
-// src/commands/benchmark.ts
-async function runBenchmark(opts) {
+// src/commands/audit.ts
+async function runAudit(opts, deps = { agent: runAgent }) {
   const { config, path: configPath } = loadConfig(opts.cwd);
-  const configDir = configPath ? join3(configPath, "..") : opts.cwd;
-  const resolved = resolveStandard("benchmark", opts, config, configDir);
-  const standard = resolved.standard;
+  const configDir = configPath ? join5(configPath, "..") : opts.cwd;
+  const resolved = resolveStandard("audit", opts, config, configDir);
+  const standard = narrowDimensions(resolved.standard, opts.only);
   log.info(
-    `Benchmarking ${pc3.bold(basename(opts.cwd))} against ${pc3.bold(standard.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
+    `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 prompt = buildPrompt(standard, opts.cwd);
-  const { result, costUsd, numTurns } = await runAgent({
-    prompt,
+  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: BenchmarkResultSchema.shape,
-    systemPromptAppend: "You are Edsger, a meticulous staff-level engineer performing an objective repository assessment. Inspect the actual code and configuration before scoring. Be evidence-driven and fair; cite concrete files. Do not modify any files."
+    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(
@@ -786,11 +1112,11 @@ async function runBenchmark(opts) {
     );
     return 1;
   }
-  const scored = scoreBenchmark(standard, result);
+  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 = renderBenchmarkMarkdown(scored, {
+  const md = renderAuditMarkdown(organized, {
     repo: basename(opts.cwd),
     languages: resolved.languages,
     layers: resolved.layers,
@@ -798,7 +1124,7 @@ async function runBenchmark(opts) {
     model: opts.model
   });
   const jsonReport = {
-    schema: "edsger.benchmark/1",
+    schema: "edsger.audit/1",
     runId,
     generatedAt,
     model: opts.model,
@@ -806,13 +1132,14 @@ async function runBenchmark(opts) {
     git,
     languages: resolved.languages,
     standard: { name: standard.name, version: standard.version, layers: resolved.layers },
-    overall: scored.overall,
-    grade: scored.grade,
-    categories: scored.categories,
-    summary: scored.summary,
-    strengths: scored.strengths,
-    weaknesses: scored.weaknesses,
-    recommendations: scored.recommendations,
+    // 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 = {
@@ -823,112 +1150,471 @@ async function runBenchmark(opts) {
     dirty: git.dirty,
     model: opts.model,
     standardVersion: standard.version,
-    overall: scored.overall,
-    grade: scored.grade,
-    categories: Object.fromEntries(scored.categories.map((c) => [c.id, c.fraction])),
+    total: organized.total,
+    counts: organized.counts,
     costUsd
   };
   if (!opts.noWrite && !opts.dryRun) {
-    const baseDir = join3(opts.cwd, opts.out);
+    const baseDir = join5(opts.cwd, opts.out);
     const mdOut = md + "\n";
     const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
-    const runDir = join3(baseDir, "runs", runId);
+    const runDir = join5(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");
+    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 ${pc3.bold(join3(opts.out, "report.md"))} ${pc3.dim(`(run archived at ${join3(opts.out, "runs", runId)})`)}`
+      `Report written to ${pc4.bold(join5(opts.out, "report.md"))} ${pc4.dim(`(run archived at ${join5(opts.out, "runs", runId)})`)}`
     );
   }
-  printSummary(scored, numTurns, costUsd);
+  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;
 }
-function printSummary(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);
-    process.stderr.write(`  ${bar(pct)} ${String(pct).padStart(3)}%  ${c.name}
+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 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));
+function sevColor(s) {
+  if (s === "critical" || s === "high") return pc4.red;
+  if (s === "medium") return pc4.yellow;
+  return pc4.dim;
 }
-function buildPrompt(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") : "";
-      return `    - id: ${cr.id}
-      title: ${cr.title}
-      guidance: ${cr.guidance.trim()}` + (anchors ? `
-      anchors:
-${anchors}` : "");
-    }).join("\n");
-    return `- category: ${cat.id} (${cat.name}, weight ${cat.weight})
-${crits}`;
+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 [
-    `Assess the repository located at: ${cwd}`,
+    `Audit the repository located at: ${cwd}`,
     ``,
-    `Score it against the rubric below. Each criterion is scored from 0 to ${standard.scoreScale}`,
-    `(0 = absent/harmful, ${standard.scoreScale} = exemplary), using the level anchors as a guide.`,
+    `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:`,
-    `1. Explore the repository structure, key source files, configuration, CI, tests, and docs.`,
-    `   Use Read/Grep/Glob and read-only Bash (e.g. ls, cat, git log). Do NOT modify anything.`,
-    `2. For each criterion, gather concrete evidence (file paths) before deciding a score.`,
-    `3. Be objective and consistent. Absence of evidence for a practice means a low score.`,
-    `4. When finished, call submit_result exactly once with a score for EVERY criterion id below,`,
-    `   grouped by category. Include a short justification and evidence paths for each.`,
+    ...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.`
+    ]),
     ``,
-    `Rubric:`,
-    rubric
+    `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/pr-review.ts
-import pc4 from "picocolors";
+// 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/gh.ts
-import { execFile } from "child_process";
-import { mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-import { promisify } from "util";
-var exec = promisify(execFile);
-async function gh(args, cwd) {
-  const { stdout } = await exec("gh", args, {
-    cwd,
-    maxBuffer: 64 * 1024 * 1024,
-    env: process.env
+// 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
+    };
   });
-  return stdout;
-}
-async function ensureGhReady() {
-  try {
-    await exec("gh", ["--version"]);
-  } catch {
-    throw new Error(
-      "GitHub CLI (gh) not found. Install it from https://cli.github.com and run `gh auth login`."
+  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.`);
   }
-  try {
-    await exec("gh", ["auth", "status"]);
-  } catch {
-    throw new Error("Not authenticated with GitHub. Run `gh auth login` first.");
-  }
-}
-async function getPrContext(ref, repo, cwd) {
-  const repoArgs = repo ? ["--repo", repo] : [];
-  const fields = "number,title,body,author,baseRefName,headRefName,state,url,isCrossRepository,files";
+  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 ? join6(configPath, "..") : opts.cwd;
+  const resolved = resolveStandard("benchmark", opts, config, configDir);
+  const standard = resolved.standard;
+  log.info(
+    `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 = buildPrompt2(standard, opts.cwd);
+  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: BenchmarkResultSchema.shape,
+    systemPromptAppend: "You are Edsger, a meticulous staff-level engineer performing an objective repository assessment. Inspect the actual code and configuration before scoring. Be evidence-driven and fair; cite concrete files. 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 scored = scoreBenchmark(standard, result);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = generatedAt.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const git = gitInfo(opts.cwd);
+  const md = renderBenchmarkMarkdown(scored, {
+    repo: basename2(opts.cwd),
+    languages: resolved.languages,
+    layers: resolved.layers,
+    generatedAt,
+    model: opts.model
+  });
+  const jsonReport = {
+    schema: "edsger.benchmark/1",
+    runId,
+    generatedAt,
+    model: opts.model,
+    repo: basename2(opts.cwd),
+    git,
+    languages: resolved.languages,
+    standard: { name: standard.name, version: standard.version, layers: resolved.layers },
+    overall: scored.overall,
+    grade: scored.grade,
+    categories: scored.categories,
+    summary: scored.summary,
+    strengths: scored.strengths,
+    weaknesses: scored.weaknesses,
+    recommendations: scored.recommendations,
+    costUsd
+  };
+  const historyRecord = {
+    runId,
+    generatedAt,
+    commit: git.commit,
+    branch: git.branch,
+    dirty: git.dirty,
+    model: opts.model,
+    standardVersion: standard.version,
+    overall: scored.overall,
+    grade: scored.grade,
+    categories: Object.fromEntries(scored.categories.map((c) => [c.id, c.fraction])),
+    costUsd
+  };
+  if (!opts.noWrite && !opts.dryRun) {
+    const baseDir = join6(opts.cwd, opts.out);
+    const mdOut = md + "\n";
+    const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
+    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 ${pc5.bold(join6(opts.out, "report.md"))} ${pc5.dim(`(run archived at ${join6(opts.out, "runs", runId)})`)}`
+    );
+  }
+  printSummary2(scored, numTurns, costUsd);
+  if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
+  return 0;
+}
+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);
+    process.stderr.write(`  ${bar(pct)} ${String(pct).padStart(3)}%  ${c.name}
+`);
+  }
+  log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
+}
+function bar(pct) {
+  const width = 20;
+  const filled = Math.round(pct / 100 * width);
+  const color = pct >= 80 ? pc5.green : pct >= 60 ? pc5.yellow : pc5.red;
+  return color("\u2588".repeat(filled)) + pc5.dim("\u2591".repeat(width - filled));
+}
+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") : "";
+      return `    - id: ${cr.id}
+      title: ${cr.title}
+      guidance: ${cr.guidance.trim()}` + (anchors ? `
+      anchors:
+${anchors}` : "");
+    }).join("\n");
+    return `- category: ${cat.id} (${cat.name}, weight ${cat.weight})
+${crits}`;
+  }).join("\n");
+  return [
+    `Assess the repository located at: ${cwd}`,
+    ``,
+    `Score it against the rubric below. Each criterion is scored from 0 to ${standard.scoreScale}`,
+    `(0 = absent/harmful, ${standard.scoreScale} = exemplary), using the level anchors as a guide.`,
+    ``,
+    `Method:`,
+    `1. Explore the repository structure, key source files, configuration, CI, tests, and docs.`,
+    `   Use Read/Grep/Glob and read-only Bash (e.g. ls, cat, git log). Do NOT modify anything.`,
+    `2. For each criterion, gather concrete evidence (file paths) before deciding a score.`,
+    `3. Be objective and consistent. Absence of evidence for a practice means a low score.`,
+    `4. When finished, call submit_result exactly once with a score for EVERY criterion id below,`,
+    `   grouped by category. Include a short justification and evidence paths for each.`,
+    ``,
+    `Rubric:`,
+    rubric
+  ].join("\n");
+}
+
+// src/commands/pr-review.ts
+import pc6 from "picocolors";
+
+// src/core/gh.ts
+import { execFile } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join7 } from "path";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function gh(args, cwd) {
+  const { stdout } = await exec("gh", args, {
+    cwd,
+    maxBuffer: 64 * 1024 * 1024,
+    env: process.env
+  });
+  return stdout;
+}
+async function ensureGhReady() {
+  try {
+    await exec("gh", ["--version"]);
+  } catch {
+    throw new Error(
+      "GitHub CLI (gh) not found. Install it from https://cli.github.com and run `gh auth login`."
+    );
+  }
+  try {
+    await exec("gh", ["auth", "status"]);
+  } catch {
+    throw new Error("Not authenticated with GitHub. Run `gh auth login` first.");
+  }
+}
+async function getPrContext(ref, repo, cwd) {
+  const repoArgs = repo ? ["--repo", repo] : [];
+  const fields = "number,title,body,author,baseRefName,headRefName,state,url,isCrossRepository,files";
   const metaRaw = await gh(["pr", "view", ref, ...repoArgs, "--json", fields], cwd);
   const meta = JSON.parse(metaRaw);
   const diff = await gh(["pr", "diff", ref, ...repoArgs], cwd);
@@ -962,9 +1648,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],
@@ -1005,7 +1691,7 @@ async function getPrFeedback(ctx, repo, cwd) {
 }
 
 // src/commands/pr-review.ts
-var SEVERITY_RANK = {
+var SEVERITY_RANK2 = {
   critical: 4,
   high: 3,
   medium: 2,
@@ -1014,7 +1700,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;
@@ -1025,10 +1711,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,
@@ -1059,7 +1745,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;
@@ -1075,7 +1761,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) {
@@ -1124,7 +1810,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)}`);
@@ -1134,15 +1820,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"})
@@ -1175,25 +1861,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: [],
@@ -1204,10 +1890,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,
@@ -1221,7 +1907,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);
@@ -1229,7 +1915,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;
@@ -1266,14 +1952,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}`);
@@ -1284,7 +1970,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 [
@@ -1312,175 +1998,9 @@ function buildPrompt3(ctx, feedback, instruction) {
 }
 
 // src/commands/serve.ts
-import { join as join7 } from "path";
-
-// src/core/dashboard.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join5 } from "path";
-function assembleFrom(dir, latestFile) {
-  const latest = readJson(join5(dir, latestFile));
-  const history = readJsonl(join5(dir, "history.jsonl"));
-  const runs = {};
-  const runsDir = join5(dir, "runs");
-  if (existsSync3(runsDir)) {
-    for (const entry of readdirSync2(runsDir)) {
-      const report = readJson(join5(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 hasData(data) {
-  return Boolean(data.latest) || data.history.length > 0;
-}
-function findViewerDir(subdir = "viewer", index = "index.html") {
-  const dir = join5(findBundledAssetsDir(), subdir);
-  if (!existsSync3(join5(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 readSingleTemplate(file) {
-  const path = join5(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 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 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/viewer-server.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";
-
-// 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 {
-  }
-}
-
-// src/core/viewer-server.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 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 = join6(opts.viewerDir, safe);
-    if (!file.startsWith(opts.viewerDir)) {
-      res.writeHead(403);
-      res.end("forbidden");
-      return;
-    }
-    if (!existsSync4(file) || statSync2(file).isDirectory())
-      file = join6(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 ${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);
-  });
-}
-
-// src/commands/serve.ts
+import { join as join8 } from "path";
 async function runServe(opts) {
-  const benchmarkDir = join7(opts.cwd, opts.dir);
+  const benchmarkDir = join8(opts.cwd, opts.dir);
   const viewerDir = findViewerDir();
   return startViewerServer({
     viewerDir,
@@ -1495,31 +2015,31 @@ async function runServe(opts) {
 }
 
 // src/commands/report.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join8 } from "path";
-import pc7 from "picocolors";
+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 = join8(opts.cwd, opts.dir);
+  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 = isAbsolute2(opts.html) ? opts.html : join8(opts.cwd, opts.html);
-  mkdirSync2(dirname2(out), { recursive: true });
-  writeFileSync3(out, html, "utf8");
+  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 ${pc7.bold(opts.html)} ${pc7.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
+    `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 appendFileSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute3, join as join9 } from "path";
-import pc8 from "picocolors";
+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) {
@@ -1648,52 +2168,750 @@ function validateMermaid(declaredType, mermaid) {
   }
   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.`);
+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 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 countNodes(node) {
+  return 1 + node.children.reduce((acc, c) => acc + countNodes(c), 0);
+}
+function treeDepth(node) {
+  return 1 + node.children.reduce((acc, c) => Math.max(acc, treeDepth(c)), 0);
+}
+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);
+  }
+  lines.push("");
+  lines.push(`---`);
+  lines.push(`<sub>Generated by [edsger](https://www.npmjs.com/package/edsger).</sub>`);
+  return lines.join("\n");
+}
+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);
+}
+
+// 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;
+  }
+  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)})`)}`
+    );
+  }
+  printSummary5(prepared, numTurns, costUsd);
+  if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
+  return 0;
+}
+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)}`);
+}
+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.`
+  });
+}
+async function runMindmapReport(opts) {
+  const mindmapDir = join11(opts.cwd, opts.dir);
+  const data = assembleMindmapData(mindmapDir);
+  if (!hasData(data)) {
+    log.error(`No mind-map data in ${opts.dir}. Run \`edsger mindmap\` first.`);
+    return 1;
+  }
+  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 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;
+}
+
+// src/commands/testcases.ts
+import { appendFileSync as appendFileSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute6, join as join12 } from "path";
+import pc11 from "picocolors";
+
+// src/core/testcases.ts
+var PRIORITY_ORDER = ["critical", "high", "medium", "low"];
+function isCase(node) {
+  return node.steps.length > 0 || Boolean(node.expected);
+}
+function buildTestcasesPrompt(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 [
+    `Derive a MANUAL test-case plan for the repository at: ${cwd}`,
+    ``,
+    `The plan is an outline tree (like Workflowy): the root is the project, the`,
+    `branches are the areas a human tester should exercise, and every leaf is a`,
+    `single concrete test case a tester who has never read the code can execute.`,
+    `These are NOT automated code tests \u2014 they describe how a person verifies the`,
+    `software behaves correctly by actually using it.`,
+    ...focus ? [
+      ``,
+      `FOCUS: the user asked the plan to concentrate on: "${focus}". Give that`,
+      `area most of the depth; keep other areas 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), what its real entry points and user-facing`,
+    `   behaviours are, and what failure modes the code actually handles.`,
+    `2. You have a list of candidate top-level test areas ("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 areas.`,
+    `3. Tree rules:`,
+    `   - Root node: the project \u2014 its name as the title, one line on what a tester`,
+    `     is validating. Exactly ONE root.`,
+    `   - Interior nodes group features/scenarios: short title (2-8 words) plus a`,
+    `     one-sentence summary specific to THIS codebase. Tag them kind: area,`,
+    `     feature, flow, scenario, or topic.`,
+    `   - EVERY leaf is one executable test case, tagged kind: "case", with:`,
+    `       * summary \u2014 what the case verifies and why it matters;`,
+    `       * preconditions \u2014 the state to prepare (install done, env var set, \u2026);`,
+    `       * steps \u2014 exact, observable manual actions in order ("Run \`x --y\`",`,
+    `         "Click Save", "Delete the config file"), each independently checkable;`,
+    `       * expected \u2014 the SINGLE outcome the tester verifies (message, exit`,
+    `         code, UI state, file contents);`,
+    `       * priority \u2014 critical (release blocker if broken), high (core`,
+    `         behaviour), medium (important but recoverable), or low (polish);`,
+    `       * files \u2014 the repo files implementing the behaviour under test.`,
+    `   - Ground every case in behaviour that is actually in the code: real`,
+    `     commands, flags, routes, screens, and error branches. Never invent`,
+    `     behaviour, and never write "check that it works" \u2014 say exactly what to do`,
+    `     and exactly what should happen.`,
+    `   - Maximum depth ${maxDepth} (root inclusive). Prefer depth where the risk`,
+    `     is, brevity where the behaviour is trivial \u2014 a plan a tester can work`,
+    `     through top-to-bottom, not a combinatorial matrix.`,
+    `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.`,
+    `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 test areas:`,
+    aspectsText
+  ].join("\n");
+}
+function slugify2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "node";
+}
+function prepareTestcases(result, fallback) {
+  const warnings = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const raw of result.nodes) {
+    const node = { ...raw, id: raw.id?.trim() || slugify2(raw.title) };
+    if (!node.title?.trim()) {
+      warnings.push(`dropped a node with no title (id "${node.id}")`);
       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)
+    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",
+      priority: node.priority ?? null,
+      preconditions: node.preconditions ?? [],
+      steps: node.steps ?? [],
+      expected: node.expected?.trim() || null,
+      files: node.files ?? [],
+      children: []
     });
   }
-  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.");
+  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 {
-    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(", ")}`
-      );
+    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",
+      priority: null,
+      preconditions: [],
+      steps: [],
+      expected: null,
+      files: [],
+      children: roots
+    };
+  }
+  const nodeCount = countNodes3(root);
+  const depth = treeDepth2(root);
+  const priorities = { critical: 0, high: 0, medium: 0, low: 0 };
+  let caseCount = 0;
+  const tally = (node) => {
+    if (isCase(node)) {
+      caseCount++;
+      priorities[node.priority ?? "medium"]++;
     }
+    node.children.forEach(tally);
+  };
+  tally(root);
+  if (nodeCount <= 1) log.warn("The agent returned an (almost) empty test plan.");
+  if (caseCount === 0 && nodeCount > 1) {
+    warnings.push("no leaf node carries steps/expected \u2014 the plan has no executable cases");
   }
-  return { profile: result.profile, diagrams: prepared, notes: result.notes ?? null };
+  for (const w of warnings) log.warn(`testcases: ${w}`);
+  return {
+    profile: result.profile,
+    root,
+    nodeCount,
+    caseCount,
+    priorities,
+    depth,
+    warnings,
+    notes: result.notes ?? null
+  };
 }
-function renderDiagramsMarkdown(prepared, meta) {
+function countNodes3(node) {
+  return 1 + node.children.reduce((acc, c) => acc + countNodes3(c), 0);
+}
+function treeDepth2(node) {
+  return 1 + node.children.reduce((acc, c) => Math.max(acc, treeDepth2(c)), 0);
+}
+function renderTestcasesMarkdown(prepared, meta) {
   const lines = [];
-  lines.push(`# Edsger Diagrams`);
+  lines.push(`# Edsger Manual Test Cases`);
   lines.push("");
   lines.push(`> ${prepared.profile.summary}`);
   lines.push("");
@@ -1702,60 +2920,64 @@ function renderDiagramsMarkdown(prepared, meta) {
   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(
+    `| Test cases | ${prepared.caseCount} (${PRIORITY_ORDER.map((p) => `${prepared.priorities[p]} ${p}`).join(", ")}) |`
+  );
+  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("");
-  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(`## ${prepared.root.title}`);
+  if (prepared.root.summary && prepared.root.summary !== prepared.profile.summary) {
     lines.push("");
-    if (d.evidence.length) {
-      lines.push(`<sub>Evidence: ${d.evidence.map((e) => `\`${e}\``).join(", ")}</sub>`);
-      lines.push("");
-    }
+    lines.push(prepared.root.summary);
   }
+  lines.push("");
+  for (const child of prepared.root.children) renderNode2(lines, child, 0);
   if (prepared.notes) {
+    lines.push("");
     lines.push(`## Notes`);
     lines.push("");
     lines.push(prepared.notes);
-    lines.push("");
   }
+  lines.push("");
   lines.push(`---`);
   lines.push(`<sub>Generated by [edsger](https://www.npmjs.com/package/edsger).</sub>`);
   return lines.join("\n");
 }
+function renderNode2(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}` : "";
+  if (isCase(node)) {
+    const prio = node.priority ? ` \`${node.priority}\`` : "";
+    lines.push(`${pad}- [ ] **${node.title}**${prio}${summary}${files}`);
+    const sub = "  ".repeat(indent2 + 1);
+    if (node.preconditions.length) {
+      lines.push(`${sub}- Preconditions: ${node.preconditions.join("; ")}`);
+    }
+    for (const [i, step] of node.steps.entries()) {
+      lines.push(`${sub}- Step ${i + 1}: ${step}`);
+    }
+    if (node.expected) lines.push(`${sub}- Expected: ${node.expected}`);
+  } else {
+    lines.push(`${pad}- **${node.title}**${summary}${files}`);
+  }
+  for (const child of node.children) renderNode2(lines, child, indent2 + 1);
+}
 
-// src/commands/diagram.ts
-async function runDiagramGenerate(opts) {
+// src/commands/testcases.ts
+async function runTestcasesGenerate(opts) {
   const { config, path: configPath } = loadConfig(opts.cwd);
-  const configDir = configPath ? join9(configPath, "..") : opts.cwd;
-  const resolved = resolveStandard("diagrams", opts, config, configDir);
-  const catalog = resolved.standard;
+  const configDir = configPath ? join12(configPath, "..") : opts.cwd;
+  const resolved = resolveStandard("testcases", opts, config, configDir);
+  const standard = resolved.standard;
   log.info(
-    `Diagramming ${pc8.bold(basename2(opts.cwd))} with ${pc8.bold(catalog.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
+    `Deriving manual test cases for ${pc11.bold(basename5(opts.cwd))} with ${pc11.bold(standard.name)} (languages: ${resolved.languages.join(", ") || "generic"})`
   );
-  log.debug(`catalog layers: ${resolved.layers.join(" \u2192 ")}`);
-  const prompt = buildDiagramsPrompt(catalog, opts.cwd, opts.only);
+  log.debug(`standard layers: ${resolved.layers.join(" \u2192 ")}`);
+  const prompt = buildTestcasesPrompt(standard, opts.cwd, opts.focus);
   const { result, costUsd, numTurns } = await runAgent({
     prompt,
     cwd: opts.cwd,
@@ -1764,8 +2986,8 @@ async function runDiagramGenerate(opts) {
     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."
+    resultShape: TestcasesResultSchema.shape,
+    systemPromptAppend: "You are Edsger, a staff-level QA engineer writing a manual test plan for a human tester who has never read the code. You derive every test case strictly from behaviour that exists in the repository you inspect: real commands, flags, routes, screens, and error branches, with exact steps and one verifiable expected result each. Never invent behaviour that is not in the code. Do not modify any files."
   });
   if (!result) {
     log.error(
@@ -1773,33 +2995,36 @@ async function runDiagramGenerate(opts) {
     );
     return 1;
   }
-  const prepared = prepareDiagrams(catalog, result);
+  const prepared = prepareTestcases(result, { repo: basename5(opts.cwd) });
   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: basename2(opts.cwd),
+  const md = renderTestcasesMarkdown(prepared, {
+    repo: basename5(opts.cwd),
     languages: resolved.languages,
     layers: resolved.layers,
     generatedAt,
     model: opts.model
   });
   const jsonReport = {
-    schema: "edsger.diagrams/1",
+    schema: "edsger.testcases/1",
     runId,
     generatedAt,
     model: opts.model,
-    repo: basename2(opts.cwd),
+    repo: basename5(opts.cwd),
     git,
     languages: resolved.languages,
-    catalog: { name: catalog.name, version: catalog.version, layers: resolved.layers },
+    standard: { name: standard.name, version: standard.version, layers: resolved.layers },
     profile: prepared.profile,
-    diagrams: prepared.diagrams,
+    root: prepared.root,
+    nodeCount: prepared.nodeCount,
+    caseCount: prepared.caseCount,
+    priorities: prepared.priorities,
+    depth: prepared.depth,
+    focus: opts.focus ?? null,
     notes: prepared.notes,
     costUsd
   };
-  const groupCounts = {};
-  for (const d of prepared.diagrams) groupCounts[d.groupId] = (groupCounts[d.groupId] ?? 0) + 1;
   const historyRecord = {
     runId,
     generatedAt,
@@ -1807,72 +3032,76 @@ async function runDiagramGenerate(opts) {
     branch: git.branch,
     dirty: git.dirty,
     model: opts.model,
-    catalogVersion: catalog.version,
-    diagramCount: prepared.diagrams.length,
-    groups: groupCounts,
+    standardVersion: standard.version,
+    nodeCount: prepared.nodeCount,
+    caseCount: prepared.caseCount,
+    priorities: prepared.priorities,
+    depth: prepared.depth,
     costUsd
   };
   if (!opts.noWrite && !opts.dryRun) {
-    const baseDir = join9(opts.cwd, opts.out);
+    const baseDir = join12(opts.cwd, opts.out);
     const mdOut = md + "\n";
     const jsonOut = JSON.stringify(jsonReport, null, 2) + "\n";
-    const runDir = join9(baseDir, "runs", runId);
-    mkdirSync3(runDir, { recursive: true });
-    writeFileSync4(join9(runDir, "diagrams.json"), jsonOut, "utf8");
-    writeFileSync4(join9(runDir, "diagrams.md"), mdOut, "utf8");
-    writeFileSync4(join9(baseDir, "diagrams.json"), jsonOut, "utf8");
-    writeFileSync4(join9(baseDir, "diagrams.md"), mdOut, "utf8");
-    appendFileSync2(join9(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
+    const runDir = join12(baseDir, "runs", runId);
+    mkdirSync6(runDir, { recursive: true });
+    writeFileSync7(join12(runDir, "testcases.json"), jsonOut, "utf8");
+    writeFileSync7(join12(runDir, "testcases.md"), mdOut, "utf8");
+    writeFileSync7(join12(baseDir, "testcases.json"), jsonOut, "utf8");
+    writeFileSync7(join12(baseDir, "testcases.md"), mdOut, "utf8");
+    appendFileSync5(join12(baseDir, "history.jsonl"), JSON.stringify(historyRecord) + "\n", "utf8");
     log.success(
-      `Diagrams written to ${pc8.bold(join9(opts.out, "diagrams.md"))} ${pc8.dim(`(run archived at ${join9(opts.out, "runs", runId)})`)}`
+      `Test plan written to ${pc11.bold(join12(opts.out, "testcases.md"))} ${pc11.dim(`(run archived at ${join12(opts.out, "runs", runId)})`)}`
     );
   }
-  printSummary3(prepared, numTurns, costUsd);
+  printSummary6(prepared, numTurns, costUsd);
   if (opts.json) process.stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
   return 0;
 }
-function printSummary3(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(`  ${pc8.bold(currentGroup)}
-`);
-    }
-    const warn = d.warnings.length ? ` ${pc8.yellow("\u26A0")}` : "";
-    process.stderr.write(`    ${pc8.cyan("\u25C6")} ${d.title} ${pc8.dim(`(${d.type})`)}${warn}
+function printSummary6(prepared, numTurns, costUsd) {
+  const tally = PRIORITY_ORDER.filter((p) => prepared.priorities[p] > 0).map((p) => `${prepared.priorities[p]} ${p}`).join(", ");
+  log.heading(
+    `${prepared.root.title} \u2014 ${prepared.caseCount} cases${tally ? ` (${tally})` : ""}, ${prepared.nodeCount} nodes, depth ${prepared.depth}`
+  );
+  const line = (node, indent2) => {
+    const cases = countCases(node);
+    const suffix = cases ? pc11.dim(` (${cases} case${cases === 1 ? "" : "s"})`) : "";
+    process.stderr.write(`${indent2}${pc11.cyan("\u2022")} ${node.title}${suffix}
 `);
-  }
+  };
+  for (const branch of prepared.root.children) line(branch, "  ");
   log.step(`${numTurns} turns \xB7 ~$${costUsd.toFixed(3)}`);
 }
-async function runDiagramServe(opts) {
-  const diagramsDir = join9(opts.cwd, opts.dir);
-  const viewerDir = findDiagramViewerDir();
+function countCases(node) {
+  return (isCase(node) ? 1 : 0) + node.children.reduce((acc, c) => acc + countCases(c), 0);
+}
+async function runTestcasesServe(opts) {
+  const testcasesDir = join12(opts.cwd, opts.dir);
+  const viewerDir = findTestcasesViewerDir();
   return startViewerServer({
     viewerDir,
-    indexFile: "diagrams.html",
-    dataRoute: "/edsger-diagrams.json",
-    getData: () => assembleDiagramData(diagramsDir),
+    indexFile: "testcases.html",
+    dataRoute: "/edsger-testcases.json",
+    getData: () => assembleTestcasesData(testcasesDir),
     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.`
+    emptyHint: hasData(assembleTestcasesData(testcasesDir)) ? void 0 : `No test-case data in ${opts.dir} yet \u2014 run \`edsger testcases\` first.`
   });
 }
-async function runDiagramReport(opts) {
-  const diagramsDir = join9(opts.cwd, opts.dir);
-  const data = assembleDiagramData(diagramsDir);
+async function runTestcasesReport(opts) {
+  const testcasesDir = join12(opts.cwd, opts.dir);
+  const data = assembleTestcasesData(testcasesDir);
   if (!hasData(data)) {
-    log.error(`No diagram data in ${opts.dir}. Run \`edsger diagram\` first.`);
+    log.error(`No test-case data in ${opts.dir}. Run \`edsger testcases\` first.`);
     return 1;
   }
-  const html = renderDiagramsSingleFile(readDiagramViewerSingleTemplate(), data);
-  const out = isAbsolute3(opts.html) ? opts.html : join9(opts.cwd, opts.html);
-  mkdirSync3(dirname3(out), { recursive: true });
-  writeFileSync4(out, html, "utf8");
+  const html = renderTestcasesSingleFile(readTestcasesViewerSingleTemplate(), data);
+  const out = isAbsolute6(opts.html) ? opts.html : join12(opts.cwd, opts.html);
+  mkdirSync6(dirname6(out), { recursive: true });
+  writeFileSync7(out, html, "utf8");
   log.success(
-    `Wrote self-contained diagram viewer to ${pc8.bold(opts.html)} ${pc8.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
+    `Wrote self-contained test-case viewer to ${pc11.bold(opts.html)} ${pc11.dim(`(${Math.round(html.length / 1024)} kB, open in any browser)`)}`
   );
   if (opts.open) openInBrowser(out);
   return 0;
@@ -1882,22 +3111,22 @@ async function runDiagramReport(opts) {
 import {
   cpSync,
   existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync7,
   readFileSync as readFileSync3,
   readdirSync as readdirSync3,
   rmSync as rmSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync8
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join10 } from "path";
-import pc9 from "picocolors";
-var MANAGED = ["benchmark", "pr-review", "pr-resolve"];
+import { join as join13 } from "path";
+import pc12 from "picocolors";
+var MANAGED = ["benchmark", "audit", "pr-review", "pr-resolve"];
 function targetSkillsDir(scope) {
-  return scope.global ? join10(homedir2(), ".claude", "skills") : join10(scope.cwd, ".claude", "skills");
+  return scope.global ? join13(homedir2(), ".claude", "skills") : join13(scope.cwd, ".claude", "skills");
 }
 function sourceSkillsDir() {
-  return join10(findBundledAssetsDir(), "skills");
+  return join13(findBundledAssetsDir(), "skills");
 }
 async function runSkillsInstall(opts) {
   const assetsDir = findBundledAssetsDir();
@@ -1907,20 +3136,20 @@ async function runSkillsInstall(opts) {
     return 1;
   }
   const dest = targetSkillsDir(opts);
-  mkdirSync4(dest, { recursive: true });
-  const available = readdirSync3(src).filter((n) => existsSync5(join10(src, n, "SKILL.md")));
+  mkdirSync7(dest, { recursive: true });
+  const available = readdirSync3(src).filter((n) => existsSync5(join13(src, n, "SKILL.md")));
   let installed = 0;
   for (const name of available) {
-    const outDir = join10(dest, name);
+    const outDir = join13(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(join10(src, name), outDir, { recursive: true });
-    const skillFile = join10(outDir, "SKILL.md");
+    cpSync(join13(src, name), outDir, { recursive: true });
+    const skillFile = join13(outDir, "SKILL.md");
     const rewritten = readFileSync3(skillFile, "utf8").split("${CLAUDE_PLUGIN_ROOT}").join(assetsDir);
-    writeFileSync5(skillFile, rewritten, "utf8");
+    writeFileSync8(skillFile, rewritten, "utf8");
     installed++;
     log.success(`installed /${name}`);
   }
@@ -1928,17 +3157,17 @@ async function runSkillsInstall(opts) {
     log.info("Nothing installed.");
     return 0;
   }
-  log.heading(`Installed ${installed} skill(s) into ${pc9.bold(dest)}`);
+  log.heading(`Installed ${installed} skill(s) into ${pc12.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 = join10(dest, name);
+    const dir = join13(dest, name);
     if (existsSync5(dir)) {
       rmSync2(dir, { recursive: true, force: true });
       removed++;
@@ -1955,13 +3184,13 @@ async function runSkillsList(opts) {
   ]) {
     const dir = targetSkillsDir(scope);
     const present = MANAGED.filter((n) => {
-      const p = join10(dir, n, "SKILL.md");
+      const p = join13(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(`  ${pc9.green("\u2713")} /${n}
+    if (present.length) for (const n of present) process.stderr.write(`  ${pc12.green("\u2713")} /${n}
 `);
-    else process.stderr.write(`  ${pc9.dim("(none installed)")}
+    else process.stderr.write(`  ${pc12.dim("(none installed)")}
 `);
   }
   return 0;
@@ -2003,7 +3232,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")
@@ -2017,6 +3246,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(
@@ -2090,6 +3379,106 @@ diagram.command("report").description("Export a self-contained HTML diagram view
     })
   );
 });
+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)
+    })
+  );
+});
+var testcases = program.command("testcases").alias("test-cases").description(
+  "Derive & browse a manual test-case plan (Workflowy-style outline) for a repo \u2014 how a human should test it, not automated code tests"
+);
+addGlobalOptions(
+  testcases.command("generate", { isDefault: true }).description("Analyze the repository and derive the manual test-case plan").option("--out <dir>", "test-plan output directory (relative to repo)", ".edsger/testcases").option("--no-write", "do not write test-plan files into the repo").option("--focus <text>", "area or feature the plan should concentrate its depth on").option("--serve", "open the test-case viewer after generating")
+).action(
+  async (opts) => {
+    await guard(async () => {
+      const g = toGlobal(opts);
+      const code = await runTestcasesGenerate({
+        ...g,
+        out: opts.out,
+        noWrite: opts.write === false,
+        focus: opts.focus
+      });
+      if (code === 0 && opts.serve) {
+        return runTestcasesServe({
+          cwd: g.cwd,
+          dir: opts.out,
+          port: 4581,
+          host: "127.0.0.1",
+          open: true
+        });
+      }
+      return code;
+    });
+  }
+);
+testcases.command("serve").description("Serve the test-case viewer locally").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "test-plan output directory (relative to repo)", ".edsger/testcases").option("--port <n>", "port to listen on", "4581").option("--host <host>", "host to bind", "127.0.0.1").option("--no-open", "do not open the browser automatically").action(
+  async (opts) => {
+    await guard(
+      () => runTestcasesServe({
+        cwd: resolve2(opts.cwd ?? process.cwd()),
+        dir: opts.dir,
+        port: Number.parseInt(opts.port, 10) || 4581,
+        host: opts.host,
+        open: opts.open !== false
+      })
+    );
+  }
+);
+testcases.command("report").description("Export a self-contained HTML test-case viewer (data inlined) for sharing").option("-C, --cwd <dir>", "repository directory").option("--dir <dir>", "test-plan output directory (relative to repo)", ".edsger/testcases").option("--html <path>", "output HTML file path", "edsger-testcases.html").option("--open", "open the exported file after writing").action(async (opts) => {
+  await guard(
+    () => runTestcasesReport({
+      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) => {
@@ -2113,7 +3502,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({
@@ -2138,14 +3529,20 @@ program.addHelpText(
   "after",
   `
 Examples:
-  ${pc10.dim("$")} edsger benchmark
-  ${pc10.dim("$")} edsger benchmark -C ./my-repo --json
-  ${pc10.dim("$")} edsger diagram              ${pc10.dim("# generate diagrams for the current repo")}
-  ${pc10.dim("$")} edsger diagram --serve      ${pc10.dim("# \u2026and open them in the browser")}
-  ${pc10.dim("$")} edsger diagram report --html diagrams.html
-  ${pc10.dim("$")} edsger pr-review 123 --post
-  ${pc10.dim("$")} edsger pr-resolve 123 --instruction "fix the failing test" --push
-  ${pc10.dim("$")} edsger skills install   ${pc10.dim("# enable /benchmark etc. in Claude Code")}
+  ${pc13.dim("$")} edsger benchmark
+  ${pc13.dim("$")} edsger benchmark -C ./my-repo --json
+  ${pc13.dim("$")} edsger audit                ${pc13.dim("# nitpick the whole repo, report issues")}
+  ${pc13.dim("$")} edsger audit --fail-on high ${pc13.dim("# CI gate: fail on high/critical findings")}
+  ${pc13.dim("$")} edsger diagram              ${pc13.dim("# generate diagrams for the current repo")}
+  ${pc13.dim("$")} edsger diagram --serve      ${pc13.dim("# \u2026and open them in the browser")}
+  ${pc13.dim("$")} edsger diagram report --html diagrams.html
+  ${pc13.dim("$")} edsger mindmap              ${pc13.dim("# implementation mind map of the repo")}
+  ${pc13.dim("$")} edsger mindmap --serve      ${pc13.dim("# \u2026browse it Workflowy-style")}
+  ${pc13.dim("$")} edsger testcases            ${pc13.dim("# manual test-case plan for the repo")}
+  ${pc13.dim("$")} edsger testcases --serve    ${pc13.dim("# \u2026browse the plan Workflowy-style")}
+  ${pc13.dim("$")} edsger pr-review 123 --post
+  ${pc13.dim("$")} edsger pr-resolve 123 --instruction "fix the failing test" --push
+  ${pc13.dim("$")} edsger skills install   ${pc13.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.
 `