test: close coverage gaps; ci: typecheck + coverage + real-gateway e2e

- serialize: every ToolResultOutput variant; applied: compact + unknown
  edit fallbacks; ephemeral: empty contents + approval-part tails
- store: class-field initializer → constructor (bun counted the
  initializer as an uninvokable function; now 100/100)
- CI on push/PR: unit job runs bun test src/ --coverage, then the e2e
  job hits the real gateway (AI_GATEWAY_API_KEY repo secret, set
  beforehand; forks skip — the tests self-skip without a key)

100% function / 99.78% line coverage across src/.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ctjlewis

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: oven-sh/setup-bun@v2
       - run: bun install --frozen-lockfile
       - run: bun run typecheck
-      - run: bun test src/
+      - run: bun test src/ --coverage
 
   e2e:
     name: E2E (real gateway)

.gitignore

@@ -32,3 +32,4 @@ report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
 
 # Finder (MacOS) folder config
 .DS_Store
+coverage

src/breakpoints/ephemeral.test.ts

@@ -172,3 +172,32 @@ describe("withEphemeralCacheControl", () => {
     })
   })
 })
+
+describe("edge contents", () => {
+  test("empty content arrays pass through untouched", () => {
+    const user = withEphemeralCacheControl({ role: "user", content: [] })
+    expect(user.content).toEqual([])
+    const assistant = withEphemeralCacheControl({ role: "assistant", content: [] })
+    expect(assistant.content).toEqual([])
+    const tool = withEphemeralCacheControl({ role: "tool", content: [] })
+    expect(tool.content).toEqual([])
+  })
+
+  test("approval-part tails are left untagged (no providerOptions field)", () => {
+    const assistant = withEphemeralCacheControl({
+      role: "assistant",
+      content: [
+        { type: "tool-approval-request", approvalId: "ap-1", toolCallId: "tc-1" },
+      ],
+    } as never)
+    expect(JSON.stringify(assistant)).not.toContain("cacheControl")
+
+    const tool = withEphemeralCacheControl({
+      role: "tool",
+      content: [
+        { type: "tool-approval-response", approvalId: "ap-1", approved: true },
+      ],
+    } as never)
+    expect(JSON.stringify(tool)).not.toContain("cacheControl")
+  })
+})

src/edits/applied.test.ts

@@ -52,5 +52,14 @@ describe("describeEdit", () => {
     expect(describeEdit(CLEAR_THINKING)).toBe(
       "cleared 2 thinking turn(s); freed 800 tokens",
     )
+    expect(describeEdit({ type: "compact_20260112" } as AppliedEdit)).toBe(
+      "compaction applied",
+    )
+  })
+
+  test("unknown future edit types fall back to a generic line", () => {
+    expect(describeEdit({ type: "frobnicate_20991231" } as never)).toBe(
+      "edit applied: frobnicate_20991231",
+    )
   })
 })

src/truncation/serialize.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test"
+
+import { toolOutputText } from "./serialize"
+
+describe("toolOutputText", () => {
+  test("text + error-text pass through", () => {
+    expect(toolOutputText({ type: "text", value: "plain" })).toBe("plain")
+    expect(toolOutputText({ type: "error-text", value: "boom" })).toBe("boom")
+  })
+
+  test("json + error-json stringify", () => {
+    expect(toolOutputText({ type: "json", value: { a: 1 } })).toBe('{"a":1}')
+    expect(toolOutputText({ type: "error-json", value: { err: true } })).toBe(
+      '{"err":true}',
+    )
+  })
+
+  test("execution-denied uses the reason, with a fallback", () => {
+    expect(toolOutputText({ type: "execution-denied", reason: "nope" })).toBe("nope")
+    expect(toolOutputText({ type: "execution-denied" })).toBe("(execution denied)")
+  })
+
+  test("content arrays join text items and label non-text ones", () => {
+    expect(
+      toolOutputText({
+        type: "content",
+        value: [
+          { type: "text", text: "first" },
+          { type: "media", data: "AAAA", mediaType: "image/png" },
+          { type: "text", text: "last" },
+        ],
+      }),
+    ).toBe("first\n[media]\nlast")
+  })
+})

src/truncation/store.ts

@@ -21,7 +21,11 @@ export interface FullOutputStore {
 
 /** Simple in-memory store; also usable as a per-request cache. */
 export class MemoryFullOutputStore implements FullOutputStore {
-  private readonly outputs = new Map<string, string>()
+  private readonly outputs: Map<string, string>
+
+  constructor() {
+    this.outputs = new Map()
+  }
 
   set(id: string, body: string): void {
     this.outputs.set(id, body)