@gswangg/duncan-cc 0.1.0

package/tests/parity.test.ts

@@ -0,0 +1,226 @@
+/**
+ * Parity tests: OHY post-processing, attachment conversion, content replacements, subagents.
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { parseSession } from "../src/parser.js";
+import { buildRawChain } from "../src/tree.js";
+import { normalizeMessages } from "../src/normalize.js";
+import { applyContentReplacements } from "../src/content-replacements.js";
+import { processSessionFile } from "../src/pipeline.js";
+import { listSubagentFiles } from "../src/discovery.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+let passed = 0, failed = 0;
+function assert(c: boolean, m: string) { if (c) passed++; else { failed++; console.error(`  ✗ ${m}`); } }
+function ok(m: string) { passed++; console.log(`  ✓ ${m}`); }
+
+function buildSession(entries: any[]): string {
+  return entries.map(e => JSON.stringify(e)).join("\n");
+}
+let uid = 100;
+function id() { return `parity-${++uid}`; }
+
+// ============================================================================
+console.log("\n--- OHY: Split assistant messages (same message.id) ---");
+{
+  const u1 = id(), a1 = id(), a1b = id(), u2 = id();
+  const content = buildSession([
+    { type: "user", uuid: u1, parentUuid: null, timestamp: "2026-01-01T00:00:00Z",
+      message: { role: "user", content: "hello" } },
+    // Split assistant: two entries with same message.id
+    { type: "assistant", uuid: a1, parentUuid: u1, timestamp: "2026-01-01T00:00:01Z",
+      message: { role: "assistant", id: "msg_001", content: [{ type: "text", text: "part 1" }], model: "claude-sonnet-4" } },
+    { type: "assistant", uuid: a1b, parentUuid: a1, timestamp: "2026-01-01T00:00:02Z",
+      message: { role: "assistant", id: "msg_001", content: [{ type: "tool_use", id: "tu1", name: "Bash", input: {} }], model: "claude-sonnet-4" } },
+    { type: "user", uuid: u2, parentUuid: a1b, timestamp: "2026-01-01T00:00:03Z",
+      message: { role: "user", content: [{ type: "tool_result", tool_use_id: "tu1", content: "ok" }] } },
+  ]);
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+
+  // Should merge the two assistant messages into one
+  const assistants = normalized.filter(m => m.type === "assistant");
+  assert(assistants.length === 1, `1 merged assistant (got ${assistants.length})`);
+
+  const merged = assistants[0];
+  const contentArr = merged.message.content as any[];
+  assert(contentArr.length === 2, `merged has 2 blocks (got ${contentArr.length})`);
+  assert(contentArr[0].type === "text", "block 0 is text");
+  assert(contentArr[1].type === "tool_use", "block 1 is tool_use");
+  ok("split assistant messages merged correctly");
+}
+
+// ============================================================================
+console.log("\n--- OHY: Orphaned tool_use gets synthetic tool_result ---");
+{
+  const u1 = id(), a1 = id();
+  const content = buildSession([
+    { type: "user", uuid: u1, parentUuid: null, timestamp: "2026-01-01T00:00:00Z",
+      message: { role: "user", content: "run something" } },
+    { type: "assistant", uuid: a1, parentUuid: u1, timestamp: "2026-01-01T00:00:01Z",
+      message: { role: "assistant", content: [
+        { type: "text", text: "running" },
+        { type: "tool_use", id: "orphan_tu", name: "Bash", input: { command: "ls" } },
+      ], model: "claude-sonnet-4" } },
+    // No tool_result follows — session was interrupted
+  ]);
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+
+  // Should have user, assistant, user (with synthetic tool_result)
+  assert(normalized.length === 3, `3 messages (got ${normalized.length})`);
+  assert(normalized[2].type === "user", "synthetic user message added");
+  const synthContent = normalized[2].message.content as any[];
+  const toolResult = synthContent.find((c: any) => c.type === "tool_result" && c.tool_use_id === "orphan_tu");
+  assert(!!toolResult, "synthetic tool_result for orphan");
+  assert(toolResult.is_error === true, "marked as error");
+  ok("orphaned tool_use gets synthetic tool_result");
+}
+
+// ============================================================================
+console.log("\n--- Attachment conversion: file ---");
+{
+  const u1 = id(), att = id(), a1 = id();
+  const content = buildSession([
+    { type: "user", uuid: u1, parentUuid: null, timestamp: "2026-01-01T00:00:00Z",
+      message: { role: "user", content: "read this file" } },
+    { type: "attachment", uuid: att, parentUuid: u1, timestamp: "2026-01-01T00:00:01Z",
+      message: { role: "user", content: "" },
+      attachment: { type: "file", filename: "test.txt", content: { type: "text", text: "file contents here" } } },
+    { type: "assistant", uuid: a1, parentUuid: att, timestamp: "2026-01-01T00:00:02Z",
+      message: { role: "assistant", content: [{ type: "text", text: "I see the file" }], model: "claude-sonnet-4" } },
+  ]);
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+
+  // Attachment should be converted to user message and merged
+  assert(normalized.every(m => m.type === "user" || m.type === "assistant"), "no attachment type in output");
+  const userMsgs = normalized.filter(m => m.type === "user");
+  assert(userMsgs.length === 1, `1 user message (attachment merged) (got ${userMsgs.length})`);
+  ok("file attachment converted and merged");
+}
+
+// ============================================================================
+console.log("\n--- Attachment conversion: directory ---");
+{
+  const att = id(), a1 = id();
+  const content = buildSession([
+    { type: "attachment", uuid: att, parentUuid: null, timestamp: "2026-01-01T00:00:00Z",
+      message: { role: "user", content: "" },
+      attachment: { type: "directory", path: "/home/user/project", content: "file1.ts\nfile2.ts\nREADME.md" } },
+    { type: "assistant", uuid: a1, parentUuid: att, timestamp: "2026-01-01T00:00:01Z",
+      message: { role: "assistant", content: [{ type: "text", text: "I see the directory" }], model: "claude-sonnet-4" } },
+  ]);
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+
+  assert(normalized[0].type === "user", "directory converted to user");
+  const text = JSON.stringify(normalized[0].message.content);
+  assert(text.includes("file1.ts"), "directory listing included");
+  ok("directory attachment converted");
+}
+
+// ============================================================================
+console.log("\n--- Attachment conversion: plan_file_reference ---");
+{
+  const att = id(), a1 = id();
+  const content = buildSession([
+    { type: "attachment", uuid: att, parentUuid: null, timestamp: "2026-01-01T00:00:00Z",
+      message: { role: "user", content: "" },
+      attachment: { type: "plan_file_reference", planFilePath: "/tmp/plan.md", planContent: "## Step 1\nDo the thing" } },
+    { type: "assistant", uuid: a1, parentUuid: att, timestamp: "2026-01-01T00:00:01Z",
+      message: { role: "assistant", content: [{ type: "text", text: "following plan" }], model: "claude-sonnet-4" } },
+  ]);
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+
+  const text = JSON.stringify(normalized[0].message.content);
+  assert(text.includes("plan.md"), "plan path included");
+  assert(text.includes("Do the thing"), "plan content included");
+  ok("plan_file_reference attachment converted");
+}
+
+// ============================================================================
+console.log("\n--- Content replacements: metadata entries ---");
+{
+  const u1 = id(), a1 = id(), u2 = id();
+  const content = buildSession([
+    { type: "user", uuid: u1, parentUuid: null, timestamp: "2026-01-01T00:00:00Z",
+      message: { role: "user", content: "hello" } },
+    { type: "assistant", uuid: a1, parentUuid: u1, timestamp: "2026-01-01T00:00:01Z",
+      message: { role: "assistant", content: [
+        { type: "text", text: "running tool" },
+        { type: "tool_use", id: "tu_replace", name: "Bash", input: {} },
+      ], model: "claude-sonnet-4" } },
+    { type: "user", uuid: u2, parentUuid: a1, timestamp: "2026-01-01T00:00:02Z",
+      message: { role: "user", content: [
+        { type: "tool_result", tool_use_id: "tu_replace", content: "very long original output that should be replaced" },
+      ] } },
+    // Content replacement metadata entry
+    { type: "content-replacement", sessionId: "test-session",
+      replacements: [{ kind: "tool-result", toolUseId: "tu_replace", replacement: "<persisted-output>replaced</persisted-output>" }] },
+  ]);
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+  const replaced = applyContentReplacements(normalized, parsed);
+
+  // Find the tool_result and check it was replaced
+  const userWithResult = replaced.find(m => {
+    if (m.type !== "user" || !Array.isArray(m.message.content)) return false;
+    return m.message.content.some((c: any) => c.type === "tool_result" && c.tool_use_id === "tu_replace");
+  });
+  assert(!!userWithResult, "found user with tool_result");
+  const tr = (userWithResult!.message.content as any[]).find((c: any) => c.tool_use_id === "tu_replace");
+  assert(tr.content.includes("replaced"), "content was replaced");
+  ok("content replacement from metadata entry applied");
+}
+
+// ============================================================================
+console.log("\n--- Subagent processing ---");
+{
+  const codexSession = join(TESTDATA,
+    "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex",
+    "630fd2b9-d94d-4287-8c24-e225fbedfc5c.jsonl");
+  
+  const subagents = listSubagentFiles(codexSession);
+  assert(subagents.length > 0, `found ${subagents.length} subagent files`);
+
+  let processable = 0;
+  for (const sa of subagents) {
+    try {
+      const result = processSessionFile(sa.path);
+      if (result.messages.length > 0) processable++;
+    } catch {}
+  }
+  assert(processable > 0, `${processable}/${subagents.length} subagents processable`);
+
+  // Verify alternation on processable subagents
+  for (const sa of subagents) {
+    try {
+      const result = processSessionFile(sa.path);
+      if (result.messages.length < 2) continue;
+      for (let i = 1; i < result.messages.length; i++) {
+        assert(
+          result.messages[i].role !== result.messages[i-1].role,
+          `subagent ${sa.sessionId.slice(0,15)}: alternation at ${i}`,
+        );
+      }
+    } catch {}
+  }
+  ok("subagent sessions process through full pipeline");
+}
+
+// ============================================================================
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) { console.log("❌ Some tests failed"); process.exit(1); }
+else console.log("✅ All tests passed");

package/tests/parser-tree.test.ts

@@ -0,0 +1,268 @@
+/**
+ * Tests for CC session parsing and tree operations.
+ * Uses real CC session files from testdata/.
+ */
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { parseSession, parseJsonl, isTranscriptMessage, isCompactBoundary, isLocalCommand } from "../src/parser.js";
+import { findLeaves, findBestLeaf, walkChain, stripInternalFields, sliceFromBoundary, getCompactionWindows, buildRawChain } from "../src/tree.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+// Find all main session files (not subagent)
+function findSessionFiles(): string[] {
+  const files: string[] = [];
+  function walk(dir: string) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "subagents") {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && !dir.includes("subagents")) {
+        files.push(full);
+      }
+    }
+  }
+  walk(TESTDATA);
+  return files;
+}
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  ✗ ${msg}`);
+  }
+}
+
+function ok(msg: string) {
+  passed++;
+  console.log(`  ✓ ${msg}`);
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+console.log("\n--- JSONL Parsing ---");
+{
+  const files = findSessionFiles();
+  assert(files.length > 0, "found session files");
+  ok(`found ${files.length} session files`);
+
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const entries = parseJsonl(content);
+    const name = basename(file, ".jsonl").slice(0, 12);
+    assert(entries.length > 0, `${name}: parsed ${entries.length} entries`);
+  }
+  ok("all files parsed without error");
+}
+
+console.log("\n--- Transcript/Metadata Separation ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const name = basename(file, ".jsonl").slice(0, 12);
+    
+    // Every message in the map should pass isTranscriptMessage
+    for (const [uuid, msg] of parsed.messages) {
+      assert(isTranscriptMessage(msg), `${name}: message ${uuid.slice(0, 8)} is transcript`);
+    }
+
+    // Count types
+    const types = new Map<string, number>();
+    for (const msg of parsed.messages.values()) {
+      types.set(msg.type, (types.get(msg.type) ?? 0) + 1);
+    }
+    
+    const parts = [];
+    for (const [t, n] of types) parts.push(`${t}:${n}`);
+    ok(`${name}: ${parsed.messages.size} messages (${parts.join(", ")})`);
+  }
+}
+
+console.log("\n--- Tree Structure ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (parsed.messages.size === 0) {
+      ok(`${name}: empty session, skip`);
+      continue;
+    }
+
+    // Check parentUuid references are valid
+    let brokenRefs = 0;
+    for (const msg of parsed.messages.values()) {
+      if (msg.parentUuid && !parsed.messages.has(msg.parentUuid)) {
+        brokenRefs++;
+      }
+    }
+    // Some broken refs are expected (progress messages may reference non-transcript entries)
+    
+    // Find leaves
+    const leaves = findLeaves(parsed.messages);
+    assert(leaves.length > 0, `${name}: has ${leaves.length} leaves`);
+
+    // Find best leaf
+    const bestLeaf = findBestLeaf(parsed.messages);
+    const hasUserOrAssistant = [...parsed.messages.values()].some(
+      (m) => m.type === "user" || m.type === "assistant"
+    );
+    if (!hasUserOrAssistant) {
+      assert(bestLeaf === undefined, `${name}: no user/assistant → no leaf`);
+      ok(`${name}: empty conversation (only progress/system)`);
+      continue;
+    }
+    assert(bestLeaf !== undefined, `${name}: found best leaf`);
+
+    if (bestLeaf) {
+      // Walk chain
+      const chain = walkChain(parsed.messages, bestLeaf);
+      assert(chain.length > 0, `${name}: chain has ${chain.length} messages`);
+
+      // First message should have no parent (or parent not in messages)
+      const first = chain[0];
+      assert(
+        first.parentUuid === null || !parsed.messages.has(first.parentUuid),
+        `${name}: chain starts at root`,
+      );
+
+      // Last message should be the leaf or reachable from it
+      const last = chain[chain.length - 1];
+      assert(last.uuid === bestLeaf.uuid, `${name}: chain ends at leaf`);
+
+      // Chain should have user and assistant messages
+      const hasUser = chain.some((m) => m.type === "user");
+      const hasAssistant = chain.some((m) => m.type === "assistant");
+      if (hasUser) ok(`${name}: chain has user messages`);
+      if (hasAssistant) ok(`${name}: chain has assistant messages`);
+
+      // Check alternation: should roughly alternate user/assistant
+      // (with system/progress interspersed)
+      const roles = chain
+        .filter((m) => m.type === "user" || m.type === "assistant")
+        .map((m) => m.type);
+      
+      // No two consecutive same roles (loose check — tool results break this)
+      let consecutiveSame = 0;
+      for (let i = 1; i < roles.length; i++) {
+        if (roles[i] === roles[i - 1]) consecutiveSame++;
+      }
+      ok(`${name}: chain ${chain.length} msgs, ${roles.length} user/assistant, ${consecutiveSame} consecutive-same`);
+    }
+  }
+}
+
+console.log("\n--- Field Stripping ---");
+{
+  const files = findSessionFiles();
+  const file = files.find((f) => statSync(f).size > 10000) ?? files[0];
+  const content = readFileSync(file, "utf-8");
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages);
+  
+  if (leaf) {
+    const chain = walkChain(parsed.messages, leaf);
+    const stripped = stripInternalFields(chain);
+    
+    for (const msg of stripped) {
+      assert(!("isSidechain" in msg), "no isSidechain field");
+      assert(!("parentUuid" in msg), "no parentUuid field");
+    }
+    ok(`stripped ${stripped.length} messages`);
+  }
+}
+
+console.log("\n--- Boundary Slicing ---");
+{
+  // No boundaries in our test data, so sliceFromBoundary should return all messages
+  const files = findSessionFiles();
+  const file = files.find((f) => statSync(f).size > 10000) ?? files[0];
+  const content = readFileSync(file, "utf-8");
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages);
+  
+  if (leaf) {
+    const chain = walkChain(parsed.messages, leaf);
+    const sliced = sliceFromBoundary(chain);
+    assert(sliced.length === chain.length, "no boundary: sliced === chain");
+    ok(`no boundary: ${sliced.length} messages preserved`);
+  }
+}
+
+console.log("\n--- Compaction Windows ---");
+{
+  const files = findSessionFiles();
+  const file = files.find((f) => statSync(f).size > 10000) ?? files[0];
+  const content = readFileSync(file, "utf-8");
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages);
+  
+  if (leaf) {
+    const chain = walkChain(parsed.messages, leaf);
+    const windows = getCompactionWindows(chain);
+    assert(windows.length === 1, "no boundaries: single window");
+    assert(windows[0].messages.length === chain.length, "window contains all messages");
+    
+    if (windows[0].modelInfo) {
+      ok(`model: ${windows[0].modelInfo.provider}/${windows[0].modelInfo.modelId}`);
+    }
+  }
+}
+
+console.log("\n--- buildRawChain ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const name = basename(file, ".jsonl").slice(0, 12);
+    
+    const chain = buildRawChain(parsed);
+    const hasConversation = [...parsed.messages.values()].some(
+      (m) => m.type === "user" || m.type === "assistant"
+    );
+    if (chain.length === 0 && !hasConversation) {
+      ok(`${name}: no conversation`);
+    } else {
+      assert(chain.length > 0, `${name}: buildRawChain produced ${chain.length} messages`);
+      
+      // Verify it's a valid chain (each message's parentUuid points to previous)
+      for (let i = 1; i < chain.length; i++) {
+        const msg = chain[i];
+        const prev = chain[i - 1];
+        // parentUuid should reference something earlier in chain (not necessarily i-1 due to branches)
+        const parentInChain = chain.some((m) => m.uuid === msg.parentUuid);
+        if (!parentInChain && msg.parentUuid !== null) {
+          // Parent might be outside the transcript (e.g., references a non-transcript entry)
+          // This is OK — CC sessions have progress messages etc. that break strict chaining
+        }
+      }
+      ok(`${name}: valid chain of ${chain.length}`);
+    }
+  }
+}
+
+// ============================================================================
+// Summary
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.log("❌ Some tests failed");
+  process.exit(1);
+} else {
+  console.log("✅ All tests passed");
+}

package/tests/pipeline.test.ts

@@ -0,0 +1,174 @@
+/**
+ * End-to-end pipeline tests.
+ * Verifies the full path: session file → API-ready messages.
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { processSessionFile, processSessionWindows, toApiMessages } from "../src/pipeline.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+function findSessionFiles(): string[] {
+  const files: string[] = [];
+  function walk(dir: string) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "subagents") walk(full);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl") && !dir.includes("subagents")) files.push(full);
+    }
+  }
+  walk(TESTDATA);
+  return files;
+}
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { passed++; }
+  else { failed++; console.error(`  ✗ ${msg}`); }
+}
+
+function ok(msg: string) { passed++; console.log(`  ✓ ${msg}`); }
+
+// ============================================================================
+
+console.log("\n--- Full Pipeline: all sessions ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const name = basename(file, ".jsonl").slice(0, 12);
+    try {
+      const result = processSessionFile(file);
+
+      if (result.messages.length === 0) {
+        ok(`${name}: empty session`);
+        continue;
+      }
+
+      // All messages should have role + content
+      for (const msg of result.messages) {
+        assert(
+          msg.role === "user" || msg.role === "assistant",
+          `${name}: valid role (${msg.role})`,
+        );
+        assert(
+          msg.content !== undefined && msg.content !== null,
+          `${name}: has content`,
+        );
+      }
+
+      // First message should be user (system-reminder from context injection)
+      assert(
+        result.messages[0].role === "user",
+        `${name}: starts with user`,
+      );
+
+      // Role alternation (user/assistant must alternate)
+      for (let i = 1; i < result.messages.length; i++) {
+        assert(
+          result.messages[i].role !== result.messages[i - 1].role,
+          `${name}: alternation at ${i} (${result.messages[i - 1].role} → ${result.messages[i].role})`,
+        );
+      }
+
+      // System prompt should be non-empty
+      assert(result.systemPrompt.length > 0, `${name}: has system prompt`);
+
+      // Should have extracted cwd
+      assert(result.sessionCwd.length > 0, `${name}: has cwd`);
+
+      ok(`${name}: ${result.rawMessageCount} raw → ${result.messages.length} API msgs, model: ${result.modelInfo?.modelId ?? "none"}, cwd: ${result.sessionCwd.slice(-30)}`);
+    } catch (err: any) {
+      failed++;
+      console.error(`  ✗ ${name}: pipeline error: ${err.message}`);
+    }
+  }
+}
+
+console.log("\n--- Full Pipeline: window processing ---");
+{
+  const files = findSessionFiles();
+  // Pick a session with content
+  const file = files.find((f) => readFileSync(f, "utf-8").length > 100000) ?? files[0];
+  const name = basename(file, ".jsonl").slice(0, 12);
+
+  const windows = processSessionWindows(file);
+
+  // No compaction boundaries in test data → single window
+  assert(windows.length === 1, `${name}: 1 window (no boundaries)`);
+
+  if (windows.length > 0) {
+    const w = windows[0];
+    assert(w.windowIndex === 0, "window index 0");
+    assert(w.messages.length > 0, "window has messages");
+    assert(w.systemPrompt.length > 0, "window has system prompt");
+    ok(`${name}: window 0: ${w.messages.length} msgs`);
+  }
+}
+
+console.log("\n--- Full Pipeline: options ---");
+{
+  const file = findSessionFiles().find((f) => readFileSync(f, "utf-8").length > 10000) ?? findSessionFiles()[0];
+  const name = basename(file, ".jsonl").slice(0, 12);
+
+  // With all options disabled
+  const minimal = processSessionFile(file, {
+    applyReplacements: false,
+    applyMicrocompact: false,
+    injectContext: false,
+    skipSystemPrompt: true,
+  });
+
+  // With all options enabled
+  const full = processSessionFile(file);
+
+  // Minimal should have fewer messages (no context injection)
+  assert(
+    full.messages.length >= minimal.messages.length,
+    `${name}: full (${full.messages.length}) >= minimal (${minimal.messages.length})`,
+  );
+
+  // Minimal should have empty system prompt
+  assert(minimal.systemPrompt === "", `${name}: no system prompt when skipped`);
+
+  // Full should have system prompt
+  assert(full.systemPrompt.length > 0, `${name}: has system prompt when enabled`);
+
+  ok(`${name}: options work correctly`);
+}
+
+console.log("\n--- Full Pipeline: API message format ---");
+{
+  const file = findSessionFiles().find((f) => readFileSync(f, "utf-8").length > 50000) ?? findSessionFiles()[0];
+  const result = processSessionFile(file);
+  const name = basename(file, ".jsonl").slice(0, 12);
+
+  for (const msg of result.messages) {
+    // Should only have role and content
+    const keys = Object.keys(msg);
+    assert(
+      keys.length === 2 && keys.includes("role") && keys.includes("content"),
+      `${name}: API message has only role+content (got: ${keys.join(", ")})`,
+    );
+
+    // Content should be string or array
+    assert(
+      typeof msg.content === "string" || Array.isArray(msg.content),
+      `${name}: content is string or array`,
+    );
+  }
+  ok(`${name}: all API messages have correct format`);
+}
+
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.log("❌ Some tests failed");
+  process.exit(1);
+} else {
+  console.log("✅ All tests passed");
+}