压缩与分支总结

interface CompactionEntry<T = unknown> {
  type: 'compaction'
  id: string
  parentId: string
  timestamp: number
  summary: string
  firstKeptEntryId: string
  tokensBefore: number
  fromHook?: boolean // true if provided by extension (legacy field name)
  details?: T // implementation-specific data
}

// Default compaction uses this for details (from compaction.ts):
interface CompactionDetails {
  readFiles: string[]
  modifiedFiles: string[]
}

interface BranchSummaryEntry<T = unknown> {
  type: 'branch_summary'
  id: string
  parentId: string
  timestamp: number
  summary: string
  fromId: string // Entry we navigated from
  fromHook?: boolean // true if provided by extension (legacy field name)
  details?: T // implementation-specific data
}

// Default branch summarization uses this for details (from branch-summarization.ts):
interface BranchSummaryDetails {
  readFiles: string[]
  modifiedFiles: string[]
}

pi.on('session_before_compact', async (event, ctx) => {
  const { preparation, branchEntries, customInstructions, reason, willRetry, signal } = event

  // preparation.messagesToSummarize - messages to summarize
  // preparation.turnPrefixMessages - split turn prefix (if isSplitTurn)
  // preparation.previousSummary - previous compaction summary
  // preparation.fileOps - extracted file operations
  // preparation.tokensBefore - context tokens before compaction
  // preparation.firstKeptEntryId - where kept messages start
  // preparation.settings - compaction settings

  // branchEntries - all entries on current branch (for custom state)
  // reason - "manual" (/compact), "threshold", or "overflow"
  // willRetry - whether the aborted turn is retried after compaction (overflow recovery)
  // signal - AbortSignal (pass to LLM calls)

  // Cancel:
  return { cancel: true }

  // Custom summary:
  return {
    compaction: {
      summary: 'Your summary...',
      firstKeptEntryId: preparation.firstKeptEntryId,
      tokensBefore: preparation.tokensBefore,
      details: {/* custom data */},
    },
  }
})

import { convertToLlm, serializeConversation } from '@earendil-works/pi-coding-agent'

pi.on('session_before_compact', async (event, ctx) => {
  const { preparation } = event

  // Convert AgentMessage[] to Message[], then serialize to text
  const conversationText = serializeConversation(convertToLlm(preparation.messagesToSummarize))
  // Returns:
  // [User]: message text
  // [Assistant thinking]: thinking content
  // [Assistant]: response text
  // [Assistant tool calls]: read(path="..."); bash(command="...")
  // [Tool result]: output text

  // Now send to your model for summarization
  const summary = await myModel.summarize(conversationText)

  return {
    compaction: {
      summary,
      firstKeptEntryId: preparation.firstKeptEntryId,
      tokensBefore: preparation.tokensBefore,
    },
  }
})

pi.on('session_before_tree', async (event, ctx) => {
  const { preparation, signal } = event

  // preparation.targetId - where we're navigating to
  // preparation.oldLeafId - current position (being abandoned)
  // preparation.commonAncestorId - shared ancestor
  // preparation.entriesToSummarize - entries that would be summarized
  // preparation.userWantsSummary - whether user chose to summarize

  // Cancel navigation entirely:
  return { cancel: true }

  // Provide custom summary (only used if userWantsSummary is true):
  if (preparation.userWantsSummary) {
    return {
      summary: {
        summary: 'Your summary...',
        details: {/* custom data */},
      },
    }
  }
})