@arcreflex/agent-transcripts 0.1.1

package/.prettierignore

@@ -0,0 +1,6 @@
+# Test fixtures should match exact tool output
+test/fixtures/
+
+# Symlinks (prettier doesn't handle them)
+CLAUDE.md
+AGENTS.md

package/README.md

@@ -0,0 +1,58 @@
+# agent-transcripts
+
+CLI tool that transforms AI coding agent session files into readable transcripts.
+
+## Stack
+
+- Runtime: Bun
+- CLI: cmd-ts
+- TypeScript with strict mode
+
+## Structure
+
+```
+src/
+  cli.ts          # CLI entry point, subcommand routing
+  parse.ts        # Source → intermediate JSON
+  render.ts       # Intermediate JSON → markdown
+  types.ts        # Core types (Transcript, Message, Adapter)
+  adapters/       # Source format adapters (currently: claude-code)
+  utils/          # Helpers (summary extraction)
+test/
+  fixtures/       # Snapshot test inputs/outputs
+  snapshots.test.ts
+```
+
+## Commands
+
+```bash
+bun run check        # typecheck + prettier
+bun run test         # snapshot tests
+bun run format       # auto-format
+```
+
+## Architecture
+
+Two-stage pipeline: Parse (source → JSON) → Render (JSON → markdown).
+
+- Adapters handle source formats (see `src/adapters/index.ts` for registry)
+- Auto-detection: paths containing `.claude/` → claude-code adapter
+- Branching conversations preserved via `parentMessageRef` on messages
+
+## Key Types
+
+- `Transcript`: source info, warnings, messages array
+- `Message`: union of UserMessage | AssistantMessage | SystemMessage | ToolCallGroup | ErrorMessage
+- `Adapter`: `{ name: string, parse(content, sourcePath): Transcript[] }`
+
+## Adding an Adapter
+
+1. Create `src/adapters/<name>.ts` implementing `Adapter`
+2. Register in `src/adapters/index.ts` (adapters map + detection rules)
+3. Add test fixtures in `test/fixtures/<name>/`
+
+## Tests
+
+Snapshot-based: `*.input.jsonl` → parse → render → compare against `*.output.md`
+
+To update snapshots: manually edit the expected `.output.md` files.

package/bin/agent-transcripts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/cli.ts";

package/bun.lock

@@ -0,0 +1,54 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "agent-transcripts",
+      "dependencies": {
+        "cmd-ts": "^0.13.0",
+      },
+      "devDependencies": {
+        "@types/bun": "^1.1.14",
+        "prettier": "^3.8.0",
+        "typescript": "^5.7.2",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
+
+    "@types/node": ["@types/node@25.0.9", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-/rpCXHlCWeqClNBwUhDcusJxXYDjZTyE8v5oTO7WbL8eij2nKhUeU89/6xgjU7N4/Vh3He0BtyhJdQbDyhiXAw=="],
+
+    "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
+
+    "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "cmd-ts": ["cmd-ts@0.13.0", "", { "dependencies": { "chalk": "^4.0.0", "debug": "^4.3.4", "didyoumean": "^1.2.2", "strip-ansi": "^6.0.0" } }, "sha512-nsnxf6wNIM/JAS7T/x/1JmbEsjH0a8tezXqqpaL0O6+eV0/aDEnRxwjxpu0VzDdRcaC1ixGSbRlUuf/IU59I4g=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "didyoumean": ["didyoumean@1.2.2", "", {}, "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "prettier": ["prettier@3.8.0", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-yEPsovQfpxYfgWNhCfECjG5AQaO+K3dp6XERmOepyPDVqcJm+bjyCVO3pmU+nAPe0N5dDvekfGezt/EIiRe1TA=="],
+
+    "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+  }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@arcreflex/agent-transcripts",
+  "version": "0.1.1",
+  "description": "Transform AI coding agent session files into readable transcripts",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arcreflex/agent-transcripts.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "agent-transcripts": "./bin/agent-transcripts"
+  },
+  "scripts": {
+    "check": "bun run typecheck && bun run prettier:check",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prettier:check": "prettier --check .",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "cmd-ts": "^0.13.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.14",
+    "prettier": "^3.8.0",
+    "typescript": "^5.7.2"
+  }
+}

package/spec.md

@@ -0,0 +1,239 @@
+# agent-transcripts
+
+A CLI tool that transforms AI coding agent session files into human-readable and LLM-readable transcripts.
+
+## Overview
+
+The tool converts session logs from various AI coding agents (starting with Claude Code, with planned support for Codex and others) into a standardized intermediate JSON format, then renders that to markdown. The primary audience is ~70% LLM consumption, ~30% human reading.
+
+## Architecture
+
+### Two-Stage Pipeline
+
+1. **Parse stage**: Source format (e.g., Claude Code JSONL) → Intermediate JSON
+2. **Render stage**: Intermediate JSON → Markdown
+
+Both stages are exposed as separate commands, plus a default command that pipelines them.
+
+### Adapter Pattern
+
+Different source formats are handled by adapters. Adapter selection:
+
+- **Auto-detection by file path**: e.g., `.claude/` in path → Claude Code adapter
+- **Explicit flag required**: for stdin input or ambiguous paths
+- **Override available**: explicit adapter flag always takes precedence
+
+## CLI Interface
+
+Built with `cmd-ts`. Supports both file arguments and stdin piping.
+
+### Commands
+
+```
+agent-transcripts [file]              # Full pipeline: source → JSON → markdown
+agent-transcripts parse [file]        # Source → intermediate JSON only
+agent-transcripts render [file]       # Intermediate JSON → markdown only
+```
+
+### Options
+
+- `-o, --output <path>` - Output file path (default: current working directory)
+- `--adapter <name>` - Explicitly specify source adapter (required for stdin if not auto-detectable)
+- `--head <id>` - Render branch ending at this message ID (default: latest leaf)
+
+### Examples
+
+```bash
+# File argument, auto-detect adapter
+agent-transcripts ~/.claude/projects/foo/sessions/abc123.jsonl
+
+# Piped input with explicit adapter
+cat session.jsonl | agent-transcripts --adapter claude-code
+
+# Just parse to intermediate format
+agent-transcripts parse session.jsonl -o transcript.json
+
+# Just render existing intermediate format
+agent-transcripts render transcript.json -o transcript.md
+```
+
+## Intermediate JSON Format
+
+TypeScript-typed JSON format. Each item includes provenance (source file + UUID) for traceability.
+
+### Structure
+
+Flat sequence of messages, each tagged with role/type. Parallel tool calls are grouped together.
+
+```typescript
+interface Transcript {
+  source: {
+    file: string; // Original source file path
+    adapter: string; // Adapter used (e.g., "claude-code")
+  };
+  metadata: {
+    warnings: Warning[]; // Parse warnings (malformed lines, etc.)
+  };
+  messages: Message[];
+}
+
+interface Warning {
+  type: string;
+  detail: string;
+  sourceRef?: string; // UUID or line reference if available
+}
+
+type Message =
+  | UserMessage
+  | AssistantMessage
+  | SystemMessage
+  | ToolCallGroup
+  | ErrorMessage;
+
+interface BaseMessage {
+  sourceRef: string; // UUID from source for provenance
+  timestamp: string; // ISO 8601
+  parentMessageRef?: string; // Parent message UUID (for tree reconstruction)
+}
+
+interface UserMessage extends BaseMessage {
+  type: "user";
+  content: string;
+}
+
+interface AssistantMessage extends BaseMessage {
+  type: "assistant";
+  content: string;
+  thinking?: string; // Full thinking trace if present
+}
+
+interface SystemMessage extends BaseMessage {
+  type: "system";
+  content: string;
+}
+
+interface ToolCallGroup extends BaseMessage {
+  type: "tool_calls";
+  calls: ToolCall[]; // Grouped if parallel, single-element if sequential
+}
+
+interface ToolCall {
+  name: string;
+  summary: string; // One-line summary extracted from result
+  error?: string; // If tool call failed, verbatim error
+}
+
+interface ErrorMessage extends BaseMessage {
+  type: "error";
+  content: string; // Verbatim error message
+}
+```
+
+### Design Decisions
+
+- **Timestamps**: Always preserved
+- **Thinking traces**: Included in full
+- **Tool call details**: Name + one-line summary only (extract from result, don't generate)
+- **Tool call results**: Discarded (recoverable via provenance if needed)
+- **Cache markers**: Stripped (API optimization detail, not relevant to transcript)
+- **System messages/metadata**: Included inline with type markers
+- **Conversation boundaries**: Split into separate output files with indexed suffixes (e.g., `transcript_1.json`, `transcript_2.json`)
+
+### Branching Conversations
+
+When a conversation has multiple branches (same parent with multiple children), the structure is preserved via `parentMessageRef` fields. During rendering:
+
+- **Default**: Render the "primary" branch (path to the latest leaf by timestamp), with references to other branches at branch points
+- **`--head <id>`**: Render from root to the specified message ID (for viewing non-primary branches)
+
+Branch references appear as blockquotes showing the message ID and first line of each alternate branch.
+
+## Markdown Output
+
+Optimized for both GitHub rendering and LLM consumption.
+
+### Formatting
+
+- **Thinking blocks**: Collapsible `<details>` sections
+- **Tool calls**: Inline, showing name and summary
+- **Parallel tool calls**: Visually grouped
+- **System messages**: Clearly marked inline
+- **Errors**: Preserved verbatim with clear markers
+
+### Example Output
+
+```markdown
+# Transcript
+
+**Source**: `~/.claude/projects/foo/sessions/abc123.jsonl`
+**Adapter**: claude-code
+
+---
+
+## User
+
+Can you help me fix the type error in auth.ts?
+
+## Assistant
+
+<details>
+<summary>Thinking...</summary>
+
+Let me look at the auth.ts file to understand the type error...
+
+</details>
+
+I'll take a look at that file.
+
+**Tools**: Read `/src/auth.ts`
+
+The issue is on line 42 where...
+
+---
+
+## User
+
+...
+```
+
+## Error Handling
+
+- **Malformed input**: Best effort processing
+  - Warn about skipped/malformed lines
+  - Record warnings in output metadata
+  - Continue processing valid content
+- **Truncated files**: Process what's available, warn in output
+- **Missing fields**: Use sensible defaults, warn if significant
+
+## Adapters
+
+### Claude Code (initial)
+
+Parses `.jsonl` session files from `~/.claude/projects/*/sessions/`.
+
+Detection: File path contains `.claude/`
+
+Key mappings:
+
+- Extract message UUIDs for provenance
+- Parse `content` arrays for text, thinking, tool_use, tool_result blocks
+- Extract one-line summaries from tool results (look for existing summary fields or first meaningful line)
+- Handle conversation boundaries (e.g., `/clear` commands)
+
+### Future: Codex
+
+TBD - investigate format when adding support.
+
+## Non-Goals
+
+- **Filtering**: No time-range or content filtering (full transcript only)
+- **Annotations**: Out of scope (separate tooling concern)
+- **Schema versioning**: Keep simple; handle breaking changes ad-hoc
+- **Full tool results**: Not preserved (use provenance to recover from source if needed)
+
+## Implementation Notes
+
+- Runtime: Bun (script, not compiled)
+- CLI framework: cmd-ts
+- Files small enough (without tool results) to handle in-memory; no streaming needed
+- Provenance uses source UUIDs (stable across file edits)

package/src/adapters/claude-code.ts

@@ -0,0 +1,310 @@
+/**
+ * Claude Code JSONL adapter.
+ *
+ * Parses session files from ~/.claude/projects/{project}/sessions/{session}.jsonl
+ */
+
+import type {
+  Adapter,
+  Transcript,
+  Message,
+  Warning,
+  ToolCall,
+} from "../types.ts";
+import { extractToolSummary } from "../utils/summary.ts";
+
+// Claude Code JSONL record types
+interface ClaudeRecord {
+  type: string;
+  uuid?: string;
+  parentUuid?: string | null;
+  timestamp?: string;
+  message?: {
+    role: string;
+    content: string | ContentBlock[];
+  };
+  content?: string;
+  subtype?: string;
+}
+
+interface ContentBlock {
+  type: string;
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: string;
+}
+
+/**
+ * Parse JSONL content with best-effort error recovery.
+ */
+function parseJsonl(content: string): {
+  records: ClaudeRecord[];
+  warnings: Warning[];
+} {
+  const records: ClaudeRecord[] = [];
+  const warnings: Warning[] = [];
+  const lines = content.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    try {
+      const record = JSON.parse(line) as ClaudeRecord;
+      records.push(record);
+    } catch (e) {
+      warnings.push({
+        type: "parse_error",
+        detail: `Line ${i + 1}: ${e instanceof Error ? e.message : "Invalid JSON"}`,
+      });
+    }
+  }
+
+  return { records, warnings };
+}
+
+/**
+ * Build message graph and find conversation boundaries.
+ * Returns array of conversation groups (each is array of records in order).
+ */
+function splitConversations(records: ClaudeRecord[]): ClaudeRecord[][] {
+  // Filter to only message records (user, assistant, system with uuid)
+  const messageRecords = records.filter(
+    (r) =>
+      r.uuid &&
+      (r.type === "user" || r.type === "assistant" || r.type === "system"),
+  );
+
+  if (messageRecords.length === 0) return [];
+
+  // Build parent → children map
+  const byUuid = new Map<string, ClaudeRecord>();
+  const children = new Map<string, string[]>();
+
+  for (const rec of messageRecords) {
+    if (rec.uuid) {
+      byUuid.set(rec.uuid, rec);
+      const parent = rec.parentUuid;
+      if (parent) {
+        const existing = children.get(parent) || [];
+        existing.push(rec.uuid);
+        children.set(parent, existing);
+      }
+    }
+  }
+
+  // Find roots (no parent or parent not in our set)
+  const roots: string[] = [];
+  for (const rec of messageRecords) {
+    if (!rec.parentUuid || !byUuid.has(rec.parentUuid)) {
+      if (rec.uuid) roots.push(rec.uuid);
+    }
+  }
+
+  // BFS from each root to collect conversation
+  const visited = new Set<string>();
+  const conversations: ClaudeRecord[][] = [];
+
+  for (const root of roots) {
+    if (visited.has(root)) continue;
+
+    const conversation: ClaudeRecord[] = [];
+    const queue = [root];
+
+    while (queue.length > 0) {
+      const uuid = queue.shift();
+      if (!uuid || visited.has(uuid)) continue;
+      visited.add(uuid);
+
+      const rec = byUuid.get(uuid);
+      if (rec) conversation.push(rec);
+
+      // Add children to queue
+      const childUuids = children.get(uuid) || [];
+      queue.push(...childUuids);
+    }
+
+    // Note: we don't sort here - renderer handles ordering via tree traversal
+    if (conversation.length > 0) {
+      conversations.push(conversation);
+    }
+  }
+
+  // Sort conversations by their first message timestamp
+  conversations.sort((a, b) => {
+    const ta = a[0]?.timestamp ? new Date(a[0].timestamp).getTime() : 0;
+    const tb = b[0]?.timestamp ? new Date(b[0].timestamp).getTime() : 0;
+    return ta - tb;
+  });
+
+  return conversations;
+}
+
+/**
+ * Extract text content from message content blocks.
+ */
+function extractText(content: string | ContentBlock[]): string {
+  if (typeof content === "string") return content;
+
+  return content
+    .flatMap((b) => (b.type === "text" && b.text ? [b.text] : []))
+    .join("\n");
+}
+
+/**
+ * Extract thinking from content blocks.
+ */
+function extractThinking(content: string | ContentBlock[]): string | undefined {
+  if (typeof content === "string") return undefined;
+
+  const thinking = content
+    .flatMap((b) => (b.type === "thinking" && b.thinking ? [b.thinking] : []))
+    .join("\n\n");
+
+  return thinking || undefined;
+}
+
+/**
+ * Extract tool calls from content blocks.
+ */
+function extractToolCalls(content: string | ContentBlock[]): ToolCall[] {
+  if (typeof content === "string") return [];
+
+  return content.flatMap((b) => {
+    if (b.type === "tool_use" && b.name) {
+      return [
+        {
+          name: b.name,
+          summary: extractToolSummary(b.name, b.input || {}),
+        },
+      ];
+    }
+    return [];
+  });
+}
+
+/**
+ * Check if a user message contains only tool results (no actual user text).
+ */
+function isToolResultOnly(content: string | ContentBlock[]): boolean {
+  if (typeof content === "string") return false;
+
+  const hasToolResult = content.some((b) => b.type === "tool_result");
+  const hasText = content.some((b) => b.type === "text" && b.text?.trim());
+
+  return hasToolResult && !hasText;
+}
+
+/**
+ * Transform a conversation into our intermediate format.
+ */
+function transformConversation(
+  records: ClaudeRecord[],
+  sourcePath: string,
+  warnings: Warning[],
+): Transcript {
+  const messages: Message[] = [];
+
+  for (const rec of records) {
+    const sourceRef = rec.uuid || "";
+    const timestamp = rec.timestamp || new Date().toISOString();
+    const parentMessageRef = rec.parentUuid || undefined;
+
+    if (rec.type === "user" && rec.message) {
+      // Skip tool-result-only user messages (they're just tool responses)
+      if (isToolResultOnly(rec.message.content)) continue;
+
+      const text = extractText(rec.message.content);
+      if (text.trim()) {
+        messages.push({
+          type: "user",
+          sourceRef,
+          timestamp,
+          parentMessageRef,
+          content: text,
+        });
+      }
+    } else if (rec.type === "assistant" && rec.message) {
+      const text = extractText(rec.message.content);
+      const thinking = extractThinking(rec.message.content);
+      const toolCalls = extractToolCalls(rec.message.content);
+
+      // Add assistant message if there's text or thinking
+      if (text.trim() || thinking) {
+        messages.push({
+          type: "assistant",
+          sourceRef,
+          timestamp,
+          parentMessageRef,
+          content: text,
+          thinking,
+        });
+      }
+
+      // Add tool calls as separate group
+      if (toolCalls.length > 0) {
+        messages.push({
+          type: "tool_calls",
+          sourceRef,
+          timestamp,
+          parentMessageRef,
+          calls: toolCalls,
+        });
+      }
+    } else if (rec.type === "system") {
+      const text = rec.content || "";
+      if (text.trim()) {
+        messages.push({
+          type: "system",
+          sourceRef,
+          timestamp,
+          parentMessageRef,
+          content: text,
+        });
+      }
+    }
+  }
+
+  return {
+    source: {
+      file: sourcePath,
+      adapter: "claude-code",
+    },
+    metadata: { warnings },
+    messages,
+  };
+}
+
+export const claudeCodeAdapter: Adapter = {
+  name: "claude-code",
+
+  parse(content: string, sourcePath: string): Transcript[] {
+    const { records, warnings } = parseJsonl(content);
+    const conversations = splitConversations(records);
+
+    if (conversations.length === 0) {
+      // Return single empty transcript with warnings
+      return [
+        {
+          source: { file: sourcePath, adapter: "claude-code" },
+          metadata: { warnings },
+          messages: [],
+        },
+      ];
+    }
+
+    // For single conversation, include all warnings
+    if (conversations.length === 1) {
+      return [transformConversation(conversations[0], sourcePath, warnings)];
+    }
+
+    // For multiple conversations, only first gets warnings
+    return conversations.map((conv, i) =>
+      transformConversation(conv, sourcePath, i === 0 ? warnings : []),
+    );
+  },
+};