cli(doctor --issue): cap body at GitHub's 64KB limit + dedicated errors section

GitHub issue bodies have a hard ~64KB limit. The pre-fix bundlers
dumped the full 400-line log tail unconditionally, so long-running
sessions produced reports that exceeded the limit. Worse, when an
issue body was over budget the GitHub API rejected the whole payload
— the bundler completed, but the issue couldn't be opened.

Two changes:

1. New "## Recent errors (last 20, sanitized)" section above the
   main log tail. The body cap (point 2 below) only shrinks the main
   log block, so promoting recent errors into their own section
   guarantees they survive truncation. We scan the last 4000 log
   lines for ERROR-shaped patterns:

   - `failed:` (Magic Context's sessionLog convention)
   - `Error:` / `TypeError:` / typed-error rendering
   - `EMERGENCY` (95% abort marker)
   - `exception` (generic throw text)
   - V8/JSC stack-trace frames (`    at SomeFn (file:line:col)`)

   The `failed:` colon suffix is deliberate — it avoids the common
   false positive where a sessionLog message includes "failed" as
   past-tense status (e.g. `historian: 12 published; 0 failed` is
   telemetry, not an error). Stack frames are kept so the agent
   reading the issue sees enough context to identify the call site.

2. New `capBodyToGithubLimit(body, maxBytes = 60_000)` helper that
   enforces the byte budget. Budget is 60KB (4KB headroom below
   GH's 64KB cap for URL encoding via `gh issue create --web` and
   future minor section growth).

   When the body exceeds budget, the helper rewrites the main
   `## Log (last N lines, sanitized)` fenced block — drops oldest
   lines first (keeps newest) until the body fits, prefixes a
   visible `[truncated for GitHub 64KB limit — older log lines
   dropped]` marker. Diagnostics, configuration, historian failure
   signals, and recent-errors sections are preserved intact.

   UTF-8 byte length is the budget. The fallback path (no log
   heading found) uses a code-point-aware byte truncator so cutting
   mid-character doesn't produce U+FFFD replacement bytes that push
   the output back over budget.

Both helpers live in a new shared `issue-body.ts` so OpenCode and
Pi share the same budget, same truncation marker, and same
precision/false-positive tradeoff on what counts as an error line.

Tests: 14 new in `issue-body.test.ts` covering:
- Documented sessionLog shapes + "0 failed" false-positive
- V8 stack-trace frame matching
- Chronological-order output / newest-first selection
- Limit cap behavior
- Pass-through under budget
- Truncation when over budget (correct marker, oldest dropped first)
- Recent errors section survives truncation
- Description/Environment sections preserved
- Default MAX_GITHUB_BODY_BYTES applied
- UTF-8-safe fallback truncation

CLI suite: 138 pass / 2 skip / 0 fail (+14 from 124 baseline).
Typecheck, lint, format, build all clean across all 3 packages.

Author: ualtinok

packages/cli/src/lib/issue-body.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it } from "bun:test";
+import { capBodyToGithubLimit, extractRecentErrors, MAX_GITHUB_BODY_BYTES } from "./issue-body";
+
+describe("extractRecentErrors", () => {
+    it("matches the documented sessionLog error shapes", () => {
+        const log = [
+            "2026-05-20 12:00:00 [INFO] transform completed in 42ms",
+            "2026-05-20 12:00:01 [INFO] historian: 12 compartments published; 0 failed", // telemetry, NOT an error
+            "2026-05-20 12:00:02 transform failed: SQLITE_BUSY",
+            "2026-05-20 12:00:03 historian prompt failed: connection refused",
+            "2026-05-20 12:00:04 Error: Connection reset",
+            "2026-05-20 12:00:05 TypeError: cannot read property 'foo' of undefined",
+            "2026-05-20 12:00:06 EMERGENCY: aborting session ses_abc",
+            "2026-05-20 12:00:07 some other info line",
+            "2026-05-20 12:00:08 caught exception during cleanup",
+        ].join("\n");
+
+        const matches = extractRecentErrors(log, 20);
+
+        // Should include real errors but NOT the past-tense "0 failed" telemetry.
+        expect(matches).toContain("2026-05-20 12:00:02 transform failed: SQLITE_BUSY");
+        expect(matches).toContain(
+            "2026-05-20 12:00:03 historian prompt failed: connection refused",
+        );
+        expect(matches).toContain("2026-05-20 12:00:04 Error: Connection reset");
+        expect(matches).toContain(
+            "2026-05-20 12:00:05 TypeError: cannot read property 'foo' of undefined",
+        );
+        expect(matches).toContain("2026-05-20 12:00:06 EMERGENCY: aborting session ses_abc");
+        expect(matches).toContain("2026-05-20 12:00:08 caught exception during cleanup");
+        expect(matches).not.toContain(
+            "2026-05-20 12:00:01 [INFO] historian: 12 compartments published; 0 failed",
+        );
+        expect(matches).not.toContain("2026-05-20 12:00:07 some other info line");
+    });
+
+    it("matches V8 stack-trace frames", () => {
+        const log = [
+            "Error: thing broke",
+            "    at SomeFn (file:///foo.ts:42:5)",
+            "    at processTransform (file:///bar.ts:13:9)",
+            "    at file:///baz.ts:7:1",
+        ].join("\n");
+
+        const matches = extractRecentErrors(log, 20);
+        // All four lines qualify — the Error and three stack frames.
+        expect(matches.length).toBe(4);
+    });
+
+    it("returns matches in chronological order", () => {
+        const log = [
+            "transform failed: first error",
+            "info noise",
+            "transform failed: second error",
+            "info noise",
+            "transform failed: third error",
+        ].join("\n");
+
+        const matches = extractRecentErrors(log, 10);
+        expect(matches).toEqual([
+            "transform failed: first error",
+            "transform failed: second error",
+            "transform failed: third error",
+        ]);
+    });
+
+    it("caps at the requested limit (newest-first selection, oldest-first output)", () => {
+        const lines: string[] = [];
+        for (let i = 0; i < 50; i += 1) {
+            lines.push(`transform failed: error ${i}`);
+        }
+        const matches = extractRecentErrors(lines.join("\n"), 5);
+        // We asked for 5; the 5 NEWEST errors should be returned, in
+        // chronological (oldest-first) order: 45, 46, 47, 48, 49.
+        expect(matches.length).toBe(5);
+        expect(matches[0]).toBe("transform failed: error 45");
+        expect(matches[4]).toBe("transform failed: error 49");
+    });
+
+    it("returns empty array when no errors found", () => {
+        const log = ["info line 1", "info line 2", "transform completed in 42ms"].join("\n");
+        expect(extractRecentErrors(log, 20)).toEqual([]);
+    });
+
+    it("handles empty input gracefully", () => {
+        expect(extractRecentErrors("", 20)).toEqual([]);
+    });
+});
+
+describe("capBodyToGithubLimit", () => {
+    /**
+     * Build a synthetic issue body shaped like the real bundlers produce —
+     * a few small sections followed by a giant `## Log (last N lines,
+     * sanitized)` fenced block. We make the log section large enough to
+     * exceed the requested budget.
+     */
+    function makeBody(opts: { logLineCount: number; lineSize?: number }): string {
+        const lineSize = opts.lineSize ?? 80;
+        const logLines: string[] = [];
+        for (let i = 0; i < opts.logLineCount; i += 1) {
+            // Each line is prefixed with its index so we can verify which
+            // ones get dropped vs kept after truncation.
+            const prefix = `LINE${String(i).padStart(6, "0")}: `;
+            const padding = "x".repeat(Math.max(0, lineSize - prefix.length));
+            logLines.push(prefix + padding);
+        }
+
+        return [
+            "## Description",
+            "Test description for the cap helper.",
+            "",
+            "## Environment",
+            "- Plugin: v0.21.5",
+            "",
+            "## Recent errors (last 20, sanitized)",
+            "```",
+            "transform failed: critical error 1",
+            "transform failed: critical error 2",
+            "```",
+            "",
+            "## Log (last 400 lines, sanitized)",
+            "```",
+            logLines.join("\n"),
+            "```",
+        ].join("\n");
+    }
+
+    it("returns body unchanged when already within budget", () => {
+        const body = makeBody({ logLineCount: 20 });
+        const capped = capBodyToGithubLimit(body, 100_000);
+        expect(capped).toBe(body);
+    });
+
+    it("truncates the main log section when body exceeds budget", () => {
+        const body = makeBody({ logLineCount: 5000, lineSize: 200 });
+        const originalBytes = Buffer.byteLength(body, "utf8");
+
+        const capped = capBodyToGithubLimit(body, 60_000);
+        const cappedBytes = Buffer.byteLength(capped, "utf8");
+
+        // The body must now fit the budget.
+        expect(cappedBytes).toBeLessThanOrEqual(60_000);
+        // And it must actually be smaller than the input (proving truncation
+        // happened, not just trivially passed-through).
+        expect(cappedBytes).toBeLessThan(originalBytes);
+    });
+
+    it("preserves the Recent errors section after truncation", () => {
+        const body = makeBody({ logLineCount: 5000, lineSize: 200 });
+        const capped = capBodyToGithubLimit(body, 60_000);
+
+        // The errors section MUST survive truncation — that's the whole
+        // point of separating it from the main log block.
+        expect(capped).toContain("## Recent errors (last 20, sanitized)");
+        expect(capped).toContain("transform failed: critical error 1");
+        expect(capped).toContain("transform failed: critical error 2");
+    });
+
+    it("inserts the truncation marker when log lines are dropped", () => {
+        const body = makeBody({ logLineCount: 5000, lineSize: 200 });
+        const capped = capBodyToGithubLimit(body, 60_000);
+
+        expect(capped).toContain("[truncated for GitHub 64KB limit");
+    });
+
+    it("drops oldest log lines first (keeps newest)", () => {
+        const body = makeBody({ logLineCount: 5000, lineSize: 200 });
+        const capped = capBodyToGithubLimit(body, 60_000);
+
+        // The last log line (LINE004999) should be preserved — it's the
+        // newest and the most relevant.
+        expect(capped).toContain("LINE004999:");
+
+        // The first log line (LINE000000) should be gone — it's the oldest.
+        expect(capped).not.toContain("LINE000000:");
+    });
+
+    it("preserves the Description and Environment sections", () => {
+        const body = makeBody({ logLineCount: 5000, lineSize: 200 });
+        const capped = capBodyToGithubLimit(body, 60_000);
+
+        expect(capped).toContain("## Description");
+        expect(capped).toContain("Test description for the cap helper.");
+        expect(capped).toContain("## Environment");
+        expect(capped).toContain("- Plugin: v0.21.5");
+    });
+
+    it("uses MAX_GITHUB_BODY_BYTES as the default budget", () => {
+        // Building a body well past 60KB to force the default-budget path
+        // to engage. 80 chars * 5000 lines = ~400KB just for the log block.
+        const body = makeBody({ logLineCount: 5000, lineSize: 80 });
+        const capped = capBodyToGithubLimit(body);
+        expect(Buffer.byteLength(capped, "utf8")).toBeLessThanOrEqual(MAX_GITHUB_BODY_BYTES);
+    });
+
+    it("falls back to raw byte truncation when log heading is missing", () => {
+        // Synthetic input with no `## Log (last` heading — exercises the
+        // defensive fallback path. We pad with non-ASCII to ensure UTF-8
+        // boundary handling doesn't corrupt the slice.
+        const body = `## Other\n${"ü".repeat(50_000)}\n## End`;
+        const capped = capBodyToGithubLimit(body, 10_000);
+        expect(Buffer.byteLength(capped, "utf8")).toBeLessThanOrEqual(10_000);
+        expect(capped).toContain("[truncated for GitHub 64KB limit]");
+    });
+});