OpenCode compaction detection not implemented in reader

[willwashburn]

Summary

Burn's OpenCode session reader (packages/reader/src/opencode.ts) does not detect context compaction events, while Claude Code and Codex readers already support this. This means burn waste --kind compaction cannot report compaction losses for OpenCode sessions.

Background

OpenCode emits compaction events as message parts with type: "compaction" (see OpenCode compaction.ts) and fires a session.compacted bus event. The CompactionEvent type (packages/reader/src/types.ts:307-318) is already defined and used by other readers.

Existing implementations

• Claude Code: Detects compact_boundary system markers (claude.ts:330)
• Codex: Detects type: "compacted" session records (codex.ts:471)

Implementation Steps

1. Detect compaction parts in parseOpenCodeSession and parseOpenCodeSessionIncremental:

   • Parse OpenCode session JSONL for message parts with type: "compaction"
   • Extract sessionID, messageID, auto flag from the compaction part

2. Anchor to preceding turn:

   • Match each compaction event to the immediately preceding assistant turn (store precedingMessageId)
   • Capture tokensBeforeCompact from the preceding turn's cache read tokens (same pattern as Claude/Codex)

3. Emit CompactionEvent:

   • Push CompactionEvent objects to the events array returned by the parser
   • Follow the existing CompactionEvent schema (types.ts:307-318)

4. Wire through ledger pipeline:

   • Existing appendCompactions → CompactionLine → queryCompactions → burn waste --kind compaction will automatically pick up OpenCode compaction events once emitted by the reader

References

• OpenCode CompactionPart type: SDK types
• Burn CompactionEvent interface: packages/reader/src/types.ts:307-318
• Claude compaction detection: packages/reader/src/claude.ts:330
• Codex compaction detection: packages/reader/src/codex.ts:471
• Ledger compaction writer: packages/ledger/src/writer.ts:83

[willwashburn]

Implementation plan

I dug into the codebase to validate the steps in the issue. Two corrections, then a concrete plan that mirrors the in-flight Codex work (PR #147).

Corrections to the issue body

• Codex reference (codex.ts:471) isn't on main yet — that line currently parses task_started, not compaction. Codex compaction is the open PR Add Codex compaction events #147 (feat/codex-codex-compaction-events). The OpenCode implementation should mirror PR Add Codex compaction events #147's pattern, not whatever lands at codex.ts:471 today.
• No events field is plumbed through OpenCode yet. ParseOpencodeResult / ParseOpencodeIncrementalResult (packages/reader/src/opencode.ts:112-132) need a new events: CompactionEvent[] field, and packages/cli/src/ingest.ts:480-525 needs to destructure & call appendCompactions(events). (Same shape additions PR Add Codex compaction events #147 makes for Codex.)

Reference pattern from PR #147 (Codex)

PR #147 establishes the canonical pattern that the OpenCode reader should follow:

1. Track a small cursor — lastCompletedTurn: { messageId, cacheRead } — updated each time a turn finalizes.
2. On compaction marker, build the event via a buildXCompactionEvent(sessionId, ts, lastCompletedTurn) helper that stamps precedingMessageId and tokensBeforeCompact from that cursor.
3. Add events: CompactionEvent[] to both result types and have the full-parse wrapper forward it.
4. In ingest, destructure events and call appendCompactions(events) after appendTurns.
5. Test mirrors it('emits a CompactionEvent anchored to the preceding committed turn', ...) plus an incremental/resume case.

Files to change

File	Change
packages/reader/src/opencode.ts	Add compaction part detection, events field, lastCompletedTurn tracking, buildOpencodeCompactionEvent helper
packages/reader/src/opencode.test.ts	Add full-parse + incremental-dedup tests
packages/cli/src/ingest.ts (≈480–525)	Destructure events from parseOpencodeSessionIncremental, call appendCompactions(events)
tests/fixtures/opencode/with-compaction/	New fixture: session/global/<id>.json, message/<sid>/<mid>.json, part/<mid>/*.json including a type: \"compaction\" part

packages/reader/src/types.ts (CompactionEvent), packages/ledger/src/writer.ts (appendCompactions), and packages/ledger/src/reader.ts (queryCompactions source filter) are already in place — no changes needed there.

Implementation sketch (opencode.ts)

// Add to result types:
export interface ParseOpencodeIncrementalResult {
  turns: TurnRecord[];
  content: ContentRecord[];
  events: CompactionEvent[];      // new
  userTurns: UserTurnRecord[];
  relationships: SessionRelationshipRecord[];
  toolResultEvents: ToolResultEventRecord[];
  seenMessageIds: Set<string>;
}

// In parseOpencodeSessionIncremental, alongside other accumulators:
const events: CompactionEvent[] = [];
let lastCompletedTurn: { messageId: string; cacheRead: number } | undefined;

// In the assistant-message loop, detect a compaction part BEFORE finalizing
// the turn (compaction is logically attached to the preceding committed turn,
// per the issue's anchoring requirement):
for (const p of parts) {
  if (p.type === 'compaction' && lastCompletedTurn) {
    const ev: CompactionEvent = {
      v: 1,
      source: 'opencode',
      sessionId: session.id,
      ts: new Date(m.time.created).toISOString(),
      precedingMessageId: lastCompletedTurn.messageId,
      tokensBeforeCompact: lastCompletedTurn.cacheRead,
    };
    events.push(ev);
  }
}

// After pushing each turn:
lastCompletedTurn = { messageId: turn.messageId, cacheRead: turn.usage.cacheRead };

Resume / dedup: OpenCode's incremental cursor is seenMessageIds, not byte offsets. Skip emission for any message whose id is already in seen (matches how turns/content are skipped). The ledger writer hashes (source, sessionId, ts, precedingMessageId) so re-emission would also be safe — but skipping is cleaner and avoids redundant writes.

Open questions before coding

1. Compaction part shape — issue cites the OpenCode SDK's CompactionPart with sessionID, messageID, auto. Confirm whether OpenCode stores the compaction part on a new synthetic message or appends it to the assistant message that triggered the compaction. The fixture must reflect what real OpenCode storage looks like (storage/message/<sessionId>/<messageId>.json + storage/part/<messageId>/*.json).
2. auto flag — CompactionEvent has no auto field today. Should we add one (manual vs. auto compaction is a meaningful waste signal), or drop the data? Suggest deferring: keep CompactionEvent schema-stable in this PR, file a follow-up if signal is wanted.
3. Sequencing relative to PR Add Codex compaction events #147 — recommend landing Add Codex compaction events #147 first so lastCompletedTurn / event-cursor patterns are reviewed once and reused. This PR can rebase on top.

Test plan

• opencode.test.ts: full-parse case asserting events.length === 1, precedingMessageId matches the committed turn, tokensBeforeCompact === preceding.usage.cacheRead.
• Incremental case: parse with seenMessageIds containing the compaction message; assert events.length === 0 on the second pass.
• Manual: run burn ingest against an OpenCode session with a real compaction, then burn waste --kind compaction --source opencode to confirm end-to-end.

Out of scope

• Adding an auto/manual field to CompactionEvent (separate issue if wanted).
• Project-scoping queryCompactions (existing comment in ledger/src/reader.ts:122-143 documents this is intentional).