test(formatters): add coverage for text-table, markdown blocks/inline, colors, table plain mode

New test files:
- text-table.test.ts: 27 tests covering renderTextTable (border styles,
  alignment, column fitting proportional/balanced, cell wrapping,
  ANSI-aware width, header separator, multi-column structure)
- colors.test.ts: 15 tests for statusColor, levelColor, fixabilityColor,
  terminalLink

Expanded existing files:
- markdown.test.ts: +33 tests for colorTag, escapeMarkdownInline,
  safeCodeSpan, divider, renderMarkdown blocks (headings, code, blockquote,
  lists, hr, tables), renderInlineMarkdown tokens (italic, links,
  strikethrough, color tags, unknown tags)
- table.test.ts: +2 tests for plain-mode markdown table output

Fix: renderInline now handles paired color tags that marked emits as
separate html tokens (<red>, text, </red>) by buffering inner tokens
until the close tag and applying the color function.

Author: BYK

src/lib/formatters/markdown.ts

@@ -273,51 +273,101 @@ function flattenInline(token: Token): Token[] {
   return [token];
 }
 
+/**
+ * Render a single inline token to an ANSI string.
+ */
+function renderOneInline(token: Token): string {
+  switch (token.type) {
+    case "strong":
+      return chalk.bold(renderInline((token as Tokens.Strong).tokens));
+    case "em":
+      return chalk.italic(renderInline((token as Tokens.Em).tokens));
+    case "codespan":
+      return chalk.hex(COLORS.yellow)((token as Tokens.Codespan).text);
+    case "link": {
+      const link = token as Tokens.Link;
+      const linkText = renderInline(link.tokens);
+      const styled = chalk.hex(COLORS.blue)(linkText);
+      return link.href ? terminalLink(styled, link.href) : styled;
+    }
+    case "del":
+      return chalk.dim.gray.strikethrough(
+        renderInline((token as Tokens.Del).tokens)
+      );
+    case "br":
+      return "\n";
+    case "escape":
+      return (token as Tokens.Escape).text;
+    case "text":
+      if ("tokens" in token && (token as Tokens.Text).tokens) {
+        return renderInline((token as Tokens.Text).tokens ?? []);
+      }
+      return (token as Tokens.Text).text;
+    case "html": {
+      const raw = (token as Tokens.HTML).raw ?? (token as Tokens.HTML).text;
+      return renderHtmlToken(raw);
+    }
+    default:
+      return (token as { raw?: string }).raw ?? "";
+  }
+}
+
 /**
  * Render an array of inline tokens into an ANSI-styled string.
  *
- * Handles: strong, em, codespan, link, text, br, del, escape, html.
+ * Handles paired color tags (`<red>\u2026</red>`) that `marked` emits as
+ * separate `html` tokens (open, inner tokens, close). Buffers inner
+ * tokens until the matching close tag, then applies the color function.
+ *
+ * Also handles: strong, em, codespan, link, text, br, del, escape.
  */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: paired color tag buffering
 function renderInline(tokens: Token[]): string {
-  return tokens
-    .map((token) => {
-      switch (token.type) {
-        case "strong":
-          return chalk.bold(renderInline((token as Tokens.Strong).tokens));
-        case "em":
-          return chalk.italic(renderInline((token as Tokens.Em).tokens));
-        case "codespan":
-          return chalk.hex(COLORS.yellow)((token as Tokens.Codespan).text);
-        case "link": {
-          const link = token as Tokens.Link;
-          const linkText = renderInline(link.tokens);
-          const styled = chalk.hex(COLORS.blue)(linkText);
-          return link.href ? terminalLink(styled, link.href) : styled;
-        }
-        case "del":
-          return chalk.dim.gray.strikethrough(
-            renderInline((token as Tokens.Del).tokens)
-          );
-        case "br":
-          return "\n";
-        case "escape":
-          return (token as Tokens.Escape).text;
-        case "text":
-          // Text tokens may themselves contain sub-tokens (e.g. from
-          // autolinked URLs or inline markup inside list items)
-          if ("tokens" in token && (token as Tokens.Text).tokens) {
-            return renderInline((token as Tokens.Text).tokens ?? []);
+  const parts: string[] = [];
+  let i = 0;
+
+  while (i < tokens.length) {
+    const token = tokens[i] as Token;
+
+    // Check for color tag open: <red>, <green>, etc.
+    if (token.type === "html") {
+      const raw = (
+        (token as Tokens.HTML).raw ?? (token as Tokens.HTML).text
+      ).trim();
+      const openMatch = RE_OPEN_TAG.exec(raw);
+      if (openMatch) {
+        const tagName = (openMatch[1] ?? "").toLowerCase();
+        const colorFn = COLOR_TAGS[tagName];
+        if (colorFn) {
+          // Collect inner tokens until matching </tag>
+          const closeTag = `</${openMatch[1]}>`;
+          const inner: Token[] = [];
+          i += 1;
+          while (i < tokens.length) {
+            const t = tokens[i] as Token;
+            if (
+              t.type === "html" &&
+              ((t as Tokens.HTML).raw ?? (t as Tokens.HTML).text)
+                .trim()
+                .toLowerCase() === closeTag.toLowerCase()
+            ) {
+              i += 1; // consume close tag
+              break;
+            }
+            inner.push(t);
+            i += 1;
           }
-          return (token as Tokens.Text).text;
-        case "html": {
-          const raw = (token as Tokens.HTML).raw ?? (token as Tokens.HTML).text;
-          return renderHtmlToken(raw);
+          parts.push(colorFn(renderInline(inner)));
+          continue;
         }
-        default:
-          return (token as { raw?: string }).raw ?? "";
       }
-    })
-    .join("");
+    }
+
+    parts.push(renderOneInline(token));
+    i += 1;
+  }
+
+  return parts.join("");
 }
 
 // ──────────────────────── Block token rendering ──────────────────────

test/lib/formatters/colors.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Tests for terminal color utilities.
+ *
+ * Covers: statusColor, levelColor, fixabilityColor, terminalLink,
+ * and the base color functions.
+ */
+
+import { describe, expect, test } from "bun:test";
+import chalk from "chalk";
+import {
+  fixabilityColor,
+  levelColor,
+  statusColor,
+  terminalLink,
+} from "../../../src/lib/formatters/colors.js";
+
+// Force chalk colors even in test environment
+chalk.level = 3;
+
+/** Strip ANSI escape codes for content assertions */
+function stripAnsi(str: string): string {
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI codes use control chars
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+describe("statusColor", () => {
+  test("resolved → green-styled text", () => {
+    const result = statusColor("text", "resolved");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("unresolved → yellow-styled text", () => {
+    const result = statusColor("text", "unresolved");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("ignored → muted-styled text", () => {
+    const result = statusColor("text", "ignored");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("undefined defaults to unresolved styling", () => {
+    const result = statusColor("text", undefined);
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("RESOLVED works case-insensitively", () => {
+    const result = statusColor("text", "RESOLVED");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+});
+
+describe("levelColor", () => {
+  test("fatal → colored text", () => {
+    const result = levelColor("text", "fatal");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("error → colored text", () => {
+    const result = levelColor("text", "error");
+    expect(result).toContain("\x1b[");
+  });
+
+  test("warning → colored text", () => {
+    const result = levelColor("text", "warning");
+    expect(result).toContain("\x1b[");
+  });
+
+  test("info → colored text", () => {
+    const result = levelColor("text", "info");
+    expect(result).toContain("\x1b[");
+  });
+
+  test("debug → colored text", () => {
+    const result = levelColor("text", "debug");
+    expect(result).toContain("\x1b[");
+  });
+
+  test("unknown level returns uncolored text", () => {
+    const result = levelColor("text", "unknown");
+    expect(result).toBe("text");
+  });
+
+  test("undefined returns uncolored text", () => {
+    const result = levelColor("text", undefined);
+    expect(result).toBe("text");
+  });
+});
+
+describe("fixabilityColor", () => {
+  test("high → green-styled text", () => {
+    const result = fixabilityColor("text", "high");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("med → yellow-styled text", () => {
+    const result = fixabilityColor("text", "med");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+
+  test("low → red-styled text", () => {
+    const result = fixabilityColor("text", "low");
+    expect(result).toContain("\x1b[");
+    expect(stripAnsi(result)).toBe("text");
+  });
+});
+
+describe("terminalLink", () => {
+  test("wraps text in OSC 8 escape sequences", () => {
+    const result = terminalLink("click me", "https://example.com");
+    expect(result).toContain("]8;;https://example.com");
+    expect(result).toContain("click me");
+    expect(result).toContain("]8;;");
+  });
+
+  test("preserves display text", () => {
+    const result = terminalLink("display", "https://url.com");
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: OSC 8 uses control chars
+    const stripped = result.replace(/\x1b\]8;;[^\x07]*\x07/g, "");
+    expect(stripped).toBe("display");
+  });
+});