6장: 메모리 압축과 통합

interface CompressedMemory {
  original: string;
  compressed: string;
  compressionRatio: number;
  preservedFacts: string[];
  droppedFacts: string[];
}
 
async function extractiveCompress(
  conversation: Message[],
  llm: LLMClient,
  targetRatio: number = 0.3 // 원본의 30%로 압축
): Promise<CompressedMemory> {
  const originalText = conversation
    .map((m) => `[${m.role}]: ${m.content}`)
    .join("\n");
 
  const originalTokens = countTokens(originalText);
  const targetTokens = Math.floor(originalTokens * targetRatio);
 
  const response = await llm.complete({
    messages: [{
      role: "system",
      content: `다음 대화에서 가장 중요한 정보를 추출하세요.
 
규칙:
1. 결정사항, 사실, 수치를 우선 보존
2. 인사, 감사, 확인 등 의례적 발화는 제거
3. ${targetTokens} 토큰 이내로 압축
4. 원문의 핵심 표현을 최대한 유지
5. 제거된 정보의 목록도 함께 제공`,
    }, {
      role: "user",
      content: originalText,
    }],
  });
 
  return parseCompressionResult(response.content, originalText);
}

const ABSTRACTIVE_PROMPT = `
다음 대화를 구조화된 요약으로 변환하세요.
 
출력 형식:
[목표] 사용자가 달성하려는 것
[결정] 합의된 사항 목록
[사실] 확인된 사실 정보
[미해결] 아직 결정되지 않은 사항
[행동] 다음에 수행할 작업
 
각 항목은 한 줄로 간결하게 작성합니다.
`;

원본 대화: 8,500 토큰
 
추출적 압축: 2,800 토큰 (3.0배 압축)
- 정보 보존율: 약 95%
- 원문 표현 유지
 
생성적 압축: 1,400 토큰 (6.0배 압축)
- 정보 보존율: 약 85-90%
- 구조화된 요약

도구 호출 시퀀스 (원본: 15,000 토큰)
1. file_search("*.ts") -> 50개 파일 목록 반환       (2,000 토큰)
2. file_read("src/index.ts") -> 파일 전체 내용        (3,000 토큰)
3. file_read("src/utils.ts") -> 파일 전체 내용         (2,500 토큰)
4. file_edit("src/index.ts") -> 수정된 전체 내용       (3,200 토큰)
5. build_check() -> 빌드 로그 전체                     (4,300 토큰)
 
압축 후 (750 토큰, 20배 압축):
- src/index.ts: import 경로 수정 (line 15, 23)
- src/utils.ts: 참조만 확인, 수정 없음
- 빌드 결과: 성공

interface ToolCall {
  tool: string;
  input: Record<string, unknown>;
  output: string;
  tokenCount: number;
}
 
interface CompressedToolSequence {
  summary: string;
  filesModified: string[];
  filesRead: string[];
  finalOutcome: string;
  originalTokens: number;
  compressedTokens: number;
}
 
function compressToolCalls(calls: ToolCall[]): CompressedToolSequence {
  const filesModified: string[] = [];
  const filesRead: string[] = [];
  let finalOutcome = "";
 
  for (const call of calls) {
    switch (call.tool) {
      case "file_read":
        filesRead.push(call.input.path as string);
        break;
      case "file_edit":
      case "file_write":
        filesModified.push(call.input.path as string);
        break;
      case "build_check":
      case "test_run":
        // 최종 결과만 보존
        finalOutcome = extractOutcome(call.output);
        break;
    }
  }
 
  const summary = generateToolSummary(calls);
  const originalTokens = calls.reduce((s, c) => s + c.tokenCount, 0);
  const compressedTokens = countTokens(summary);
 
  return {
    summary,
    filesModified,
    filesRead,
    finalOutcome,
    originalTokens,
    compressedTokens,
  };
}

async function runConsolidationPipeline(
  userId: string,
  memoryStore: MemoryStore,
  llm: LLMClient
): Promise<void> {
  // L0 -> L1: 24시간 이상 된 원본을 세션 단위로 요약
  const staleRawMemories = await memoryStore.getLevel0({
    userId,
    olderThan: Date.now() - 24 * 60 * 60 * 1000,
  });
 
  if (staleRawMemories.length > 0) {
    const sessionGroups = groupBySession(staleRawMemories);
    for (const [sessionId, memories] of sessionGroups) {
      const summary = await summarizeSession(memories, llm);
      await memoryStore.storeLevel1({ userId, sessionId, summary });
      await memoryStore.archiveLevel0(memories.map((m) => m.id));
    }
  }
 
  // L1 -> L2: 7일 이상 된 세션 요약을 주간 통합
  const staleSessionSummaries = await memoryStore.getLevel1({
    userId,
    olderThan: Date.now() - 7 * 24 * 60 * 60 * 1000,
  });
 
  if (staleSessionSummaries.length >= 3) {
    const weeklyDigest = await consolidateWeekly(staleSessionSummaries, llm);
    await memoryStore.storeLevel2({ userId, digest: weeklyDigest });
    await memoryStore.archiveLevel1(staleSessionSummaries.map((s) => s.id));
  }
 
  // L2 -> L3: 월간 통합으로 사용자 프로필 갱신
  const monthlyDigests = await memoryStore.getLevel2({
    userId,
    count: 4, // 최근 4주
  });
 
  if (monthlyDigests.length >= 4) {
    const profileUpdate = await updateUserProfile(monthlyDigests, llm);
    await memoryStore.updateLevel3({ userId, profile: profileUpdate });
  }
}

interface TaggedFact {
  content: string;
  importance: "critical" | "high" | "medium" | "low";
  category: "decision" | "fact" | "preference" | "context";
}
 
async function tagAndCompress(
  memories: string[],
  llm: LLMClient
): Promise<string> {
  // 1단계: 사실 추출 및 중요도 태깅
  const taggedFacts = await extractAndTagFacts(memories, llm);
 
  // 2단계: 중요도별 처리
  const critical = taggedFacts.filter((f) => f.importance === "critical");
  const high = taggedFacts.filter((f) => f.importance === "high");
  const medium = taggedFacts.filter((f) => f.importance === "medium");
  // low는 통합 요약에만 반영
 
  // 3단계: critical과 high는 원문 보존, medium은 요약
  const preserved = [...critical, ...high].map((f) => f.content);
  const summarized = await summarizeFacts(medium, llm);
 
  return [
    "[보존된 핵심 정보]",
    ...preserved,
    "",
    "[요약된 부가 정보]",
    summarized,
  ].join("\n");
}

async function validateCompression(
  original: string,
  compressed: string,
  llm: LLMClient
): Promise<{
  score: number;       // 0-1 사이의 정보 보존 점수
  missingFacts: string[];
  distortedFacts: string[];
}> {
  const response = await llm.complete({
    messages: [{
      role: "system",
      content: `원본 텍스트와 압축된 텍스트를 비교하세요.
 
평가 항목:
1. 누락된 중요 사실
2. 왜곡된 정보
3. 전체적인 정보 보존율 (0-1)
 
원본:
${original}
 
압축본:
${compressed}`,
    }],
  });
 
  return parseValidationResult(response.content);
}

interface ConsolidationSchedule {
  l0ToL1: {
    trigger: "age";        // 시간 기반
    threshold: number;      // 24시간
    minBatchSize: number;   // 최소 5개 메모리
  };
  l1ToL2: {
    trigger: "count";      // 개수 기반
    threshold: number;      // 세션 요약 7개 이상
    maxAge: number;         // 최대 30일
  };
  l2ToL3: {
    trigger: "periodic";   // 주기적
    interval: number;       // 30일마다
  };
}
 
const defaultSchedule: ConsolidationSchedule = {
  l0ToL1: { trigger: "age", threshold: 24 * 60 * 60 * 1000, minBatchSize: 5 },
  l1ToL2: { trigger: "count", threshold: 7, maxAge: 30 * 24 * 60 * 60 * 1000 },
  l2ToL3: { trigger: "periodic", interval: 30 * 24 * 60 * 60 * 1000 },
};