@things-factory/board-ai 10.0.10 → 10.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/board-ai",
-  "version": "10.0.10",
+  "version": "10.0.13",
   "main": "dist-server/index.js",
   "browser": "dist-client/client/index.js",
   "things-factory": true,
@@ -18,6 +18,7 @@
   },
   "scripts": {
     "build": "npm run build:server && npm run build:client",
+    "test": "node --test --test-force-exit test/*.test.ts",
     "build:server": "npm run clean:server && npx tsc --p ./tsconfig.json",
     "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
     "build:client": "npm run clean:client && npm run copy:files && npx tsc --p ./client/tsconfig.json",
@@ -31,10 +32,10 @@
     "@operato/i18n": "^10.0.0",
     "@operato/styles": "^10.0.0",
     "@things-factory/ai-client-base": "^10.0.8",
-    "@things-factory/auth-base": "^10.0.10",
-    "@things-factory/board-import": "^10.0.10",
+    "@things-factory/auth-base": "^10.0.13",
+    "@things-factory/board-import": "^10.0.13",
     "@things-factory/env": "^10.0.8",
-    "@things-factory/shell": "^10.0.10",
+    "@things-factory/shell": "^10.0.13",
     "dompurify": "^3.0.0",
     "graphql-tag": "^2.12.6",
     "lit": "^3.1.2",
@@ -44,5 +45,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "afb7bf76bb16e946c8e62d9e79199c3fa5e34174"
+  "gitHead": "808b3b9e3bf15c058316ec4c73455108df7722aa"
 }

package/server/service/board-ai-resolver.ts

@@ -6,6 +6,7 @@
  */
 import { Resolver, Mutation, Arg, Ctx, Directive, Field, InputType, Int, ObjectType } from 'type-graphql'
 import { GraphQLJSON } from 'graphql-scalars'
+import { MoreThan } from 'typeorm'
 import '@things-factory/auth-base'
 
 import { config } from '@things-factory/env'
@@ -525,11 +526,12 @@ export class BoardAIChatResolver {
       const sessionRepo = getRepository(ChatSession)
       const session = await sessionRepo.findOneBy({ id: sessionId, domain: { id: domainId } as any })
       if (!session) return
-      const rows = await getRepository(ChatMessage).find({
-        where: { session: { id: sessionId } as any },
-        relations: { creator: true },
-        order: { createdAt: 'ASC', id: 'ASC' }
-      })
+
+      const stored = {
+        text: (session as any).lastSummary,
+        upToMessageId: (session as any).summaryUpToMessageId
+      }
+      const { rows, startsAfterSummary } = await this._historyForFold(sessionId, stored)
       const history = rows.map(row => ({
         id: row.id,
         role: row.role,
@@ -539,10 +541,8 @@ export class BoardAIChatResolver {
       }))
       const { patch } = await foldHistorySummary({
         rows: history,
-        stored: {
-          text: (session as any).lastSummary,
-          upToMessageId: (session as any).summaryUpToMessageId
-        },
+        rowsStartAfterSummary: startsAfterSummary,
+        stored,
         maxTurns: LLM_HISTORY_MAX_TURNS,
         threshold: LLM_SUMMARY_THRESHOLD,
         summarize: content =>
@@ -559,6 +559,54 @@ export class BoardAIChatResolver {
     }
   }
 
+  /**
+   * 요약에 필요한 만큼만 읽는다 — **요약이 덮은 지점 뒤부터.**
+   *
+   * ── 왜 (2026-08-20) ─────────────────────────────────────────────────────────
+   * 이 함수를 부르는 자리는 **메시지를 보낼 때마다**다. 예전에는 세션의 대화를 처음부터 끝까지 읽었고
+   * (`creator` 조인까지), 정작 쓰는 것은 두 조각뿐이었다: 마지막 `maxTurns`개와, 요약 워터마크 뒤부터의
+   * 미반영분. 대화가 2,000개면 매 메시지마다 2,000행을 읽어 수십 행을 쓴 셈이다.
+   *
+   * 워터마크 뒤부터 읽으면 그 구간이 곧 `미반영분 + 최근 유지분`이라, 읽는 행 수가 **대화 길이와
+   * 무관**해진다(정상 상태에서 대략 `threshold + maxTurns`).
+   *
+   * ── 안전 규율을 지킨다 ──────────────────────────────────────────────────────
+   * 워터마크 행이 지워졌거나(삭제·편집) 요약이 아직 없으면 **전체를 읽는다.** 그때는 요약이 어디까지
+   * 덮는지 알 수 없고, 「빠뜨리는 쪽보다 다시 요약하는 쪽이 안전하다」는 것이 이 기능의 규율이다
+   * (`pendingForSummary` 주석). 그 경우는 드물다.
+   *
+   * 순서는 `(createdAt, id)` — 읽는 순서와 자르는 기준이 같아야 한다. 같은 시각의 메시지가 있으면
+   * id 로 가른다(원래 정렬이 이미 그 규약이다).
+   */
+  private async _historyForFold(
+    sessionId: string,
+    stored: { text?: string | null; upToMessageId?: string | null }
+  ): Promise<{ rows: ChatMessage[]; startsAfterSummary: boolean }> {
+    const repo = getRepository(ChatMessage)
+    const session = { id: sessionId } as any
+    const order = { createdAt: 'ASC', id: 'ASC' } as any
+    const relations = { creator: true } as any
+
+    if (stored.text && stored.upToMessageId) {
+      const mark = await repo.findOne({ where: { session, id: stored.upToMessageId } })
+      if (mark?.createdAt) {
+        const rows = await repo.find({
+          /* 배열 = OR. 같은 시각 안에서는 id 로 이어 자른다(정렬 규약과 같은 축). */
+          where: [
+            { session, createdAt: MoreThan(mark.createdAt) },
+            { session, createdAt: mark.createdAt, id: MoreThan(mark.id) }
+          ],
+          relations,
+          order
+        })
+        return { rows, startsAfterSummary: true }
+      }
+    }
+
+    /* 워터마크가 없거나 그 행이 사라졌다 — 덮은 범위를 모르므로 전부 다시 본다. */
+    return { rows: await repo.find({ where: { session }, relations, order }), startsAfterSummary: false }
+  }
+
   /**
    * C4: 메시지에 @멘션된 사용자를 세션 참여자(member)로 자동 등록 — 초대.
    * enriched content 의 {userId:UUID} 마커에서 추출 → 기존 참여자·자기 제외한 신규만 등록.

package/server/service/chat-message/fold-history.ts

@@ -16,10 +16,23 @@ import {
 } from './history-summary.js'
 
 export interface FoldHistoryInput {
-  /** 시간 오름차순 이력 전체. */
+  /** 시간 오름차순 이력. 기본은 **전체**이고, `rowsStartAfterSummary` 면 요약 뒤부터의 구간이다. */
   rows: HistoryRow[]
   /** 세션에 저장된 요약 상태. */
   stored?: StoredSummary
+  /**
+   * `rows` 가 **이미 요약 뒤부터** 잘려 온 구간인가.
+   *
+   * ── 왜 이 플래그가 필요한가 ─────────────────────────────────────────────────
+   * 호출부가 DB 에서 워터마크(`stored.upToMessageId`) 뒤부터만 읽으면(대화가 길어져도 상수 시간),
+   * 여기서 `pendingForSummary` 로 **또 자를 것이 없다.** 그런데 그 함수는 「id 를 못 찾으면 전부
+   * 미반영으로 본다」는 안전 규칙을 갖고 있어서, 창으로 읽은 경우에도 우연히 맞는 답을 낸다.
+   *
+   * 우연에 기대지 않는다. 그 규칙은 **행이 지워졌을 때의 안전망**이고, 여기서 필요한 것은 「이미
+   * 잘랐다」는 사실이다. 둘을 같은 분기로 두면, 나중에 그 안전망을 고치는 사람이 이 경로를 조용히
+   * 망가뜨린다(요약이 앞부분을 두 번 담거나 빠뜨린다).
+   */
+  rowsStartAfterSummary?: boolean
   /** 프롬프트 상한(이 밖으로 밀려난 것이 요약 대상). */
   maxTurns: number
   /** 새로 밀려난 것이 이 수 이상일 때만 요약을 만든다(매 턴 호출 방지). */
@@ -45,7 +58,11 @@ export async function foldHistorySummary(input: FoldHistoryInput): Promise<FoldH
   const { dropped } = splitByCap(input.rows, input.maxTurns)
   if (dropped.length === 0) return { patch: null, skipped: 'nothing-dropped' }
 
-  const pending = pendingForSummary(dropped, input.stored)
+  /*
+   * 창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 요약이 덮은 앞부분은 애초에 실려 오지 않았다.
+   * 전체를 읽어 왔을 때만 워터마크로 자른다.
+   */
+  const pending = input.rowsStartAfterSummary ? dropped : pendingForSummary(dropped, input.stored)
   if (!shouldResummarize(pending, input.threshold)) return { patch: null, skipped: 'below-threshold' }
 
   let text: string | undefined | null

package/test/fold-history-window.test.ts

@@ -0,0 +1,158 @@
+/*
+ * ★ 요약 접기는 **필요한 만큼만 읽는다** — 그러면서 앞부분을 잃지 않는다.
+ *
+ * ── 무엇을 겪었나 (2026-08-20) ──────────────────────────────────────────────
+ * `_foldHistorySummary` 는 **메시지를 보낼 때마다** 그 세션의 대화를 처음부터 끝까지 읽었다
+ * (`creator` 조인까지). 정작 쓰는 것은 두 조각뿐이다: 마지막 `maxTurns`개와, 요약 워터마크
+ * 뒤부터의 미반영분. 대화가 2,000개면 매 메시지마다 2,000행을 읽어 수십 행을 쓴 셈이다.
+ *
+ * 같은 종류의 결함을 트윈 쪽에서 먼저 잡았다(`timeRange` — min/max 두 수를 구하려고 저널 27만
+ * 행을 4초마다 읽었다). 사람 리뷰가 그것을 못 잡은 이유는 **코드가 맞았기 때문**이다. 여기도 같다:
+ * 답은 맞고 비용만 틀렸다. 그래서 이 시험은 답과 함께 **어디까지 읽어야 하는가**를 못 박는다.
+ *
+ * ── 지키는 것 ───────────────────────────────────────────────────────────────
+ * ① 창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 워터마크로 또 자르지 않는다.
+ * ② 전체를 읽어 왔으면 워터마크로 자른다 — 이미 요약에 담은 것을 두 번 담지 않는다.
+ * ③ 두 경로가 **같은 답**을 낸다. 읽는 범위를 바꾼 것이 요약 내용을 바꾸면 안 된다.
+ * ④ 워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리는 쪽보다 다시 요약하는 쪽이 안전하다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createRequire } from 'node:module'
+
+/*
+ * 컴파일 산출물에서 불러온다 — 소스는 `./history-summary.js` 형태로 상대 임포트를 하고, 시험 로더는
+ * 그 `.js` 를 `.ts` 로 되돌려 주지 않는다(이 저장소의 다른 엔진 시험도 같은 이유로 dist 를 쓴다).
+ */
+const req = createRequire(import.meta.url)
+const { foldHistorySummary } = req('../dist-server/service/chat-message/fold-history.js')
+const { splitByCap, pendingForSummary } = req('../dist-server/service/chat-message/history-summary.js')
+
+const MAX_TURNS = 5
+const THRESHOLD = 3
+
+/** 메시지 n개 — id 는 `m1`.. 로 두어 어디까지 담겼는지 눈으로 읽을 수 있게 한다. */
+const rows = (n: number, from = 1) =>
+  Array.from({ length: n }, (_, i) => ({
+    id: `m${from + i}`,
+    role: (from + i) % 2 ? 'user' : 'assistant',
+    content: `말 ${from + i}`
+  }))
+
+/** 요약기를 가로채 **무엇이 요약 대상이 됐는지** 본다. 이것이 이 시험의 핵심 관측점이다. */
+function capturing() {
+  const seen: string[] = []
+  return {
+    seen,
+    summarize: async (content: string) => {
+      seen.push(content)
+      return '요약'
+    }
+  }
+}
+
+test('창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 워터마크로 또 자르지 않는다', async () => {
+  /* m1..m9 가 창(요약 뒤부터)이다. 마지막 5개는 원문 유지, 앞 4개가 새로 밀려났다. */
+  const cap = capturing()
+  const r = await foldHistorySummary({
+    rows: rows(9),
+    rowsStartAfterSummary: true,
+    stored: { text: '앞선 요약', upToMessageId: 'm0-요약에-담긴-것' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: cap.summarize
+  })
+
+  assert.ok(r.patch, '4개가 밀려났고 임계치 3 이상이므로 접는다')
+  assert.equal(r.patch!.summaryUpToMessageId, 'm4', '밀려난 마지막까지 담았다고 기록한다')
+  assert.match(cap.seen[0], /말 1/, '창의 첫 메시지가 요약에 들어간다')
+  assert.match(cap.seen[0], /말 4/)
+  assert.doesNotMatch(cap.seen[0], /말 5/, '유지분은 원문으로 남으므로 요약에 넣지 않는다')
+  assert.match(cap.seen[0], /앞선 요약/, '앞선 요약에 이어 붙인다 — 앞부분을 잃지 않는다')
+})
+
+test('전체를 읽어 왔으면 워터마크로 자른다 — 이미 담은 것을 두 번 담지 않는다', async () => {
+  /* m1..m14 전체. m5 까지 요약에 담겼다 → 미반영분은 m6..m9(마지막 5개는 유지분). */
+  const cap = capturing()
+  const r = await foldHistorySummary({
+    rows: rows(14),
+    stored: { text: '앞선 요약', upToMessageId: 'm5' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: cap.summarize
+  })
+
+  assert.ok(r.patch)
+  assert.equal(r.patch!.summaryUpToMessageId, 'm9')
+  assert.doesNotMatch(cap.seen[0], /말 5(?!\d)/, 'm5 는 이미 요약에 담겼다')
+  assert.match(cap.seen[0], /말 6/)
+  assert.match(cap.seen[0], /말 9/)
+})
+
+test('읽는 범위를 바꿔도 요약 대상은 같다 — 성능을 바꾼 것이 내용을 바꾸지 않는다', async () => {
+  /*
+   * 같은 상황을 두 방식으로 읽는다. 전체는 m1..m14 이고 m5 까지 요약됨. 창은 그 뒤인 m6..m14.
+   * 둘의 요약 대상이 다르면, 이 최적화가 사실을 옮긴 것이다.
+   */
+  const whole = capturing()
+  const windowed = capturing()
+
+  const a = await foldHistorySummary({
+    rows: rows(14),
+    stored: { text: '앞선 요약', upToMessageId: 'm5' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: whole.summarize
+  })
+  const b = await foldHistorySummary({
+    rows: rows(9, 6),
+    rowsStartAfterSummary: true,
+    stored: { text: '앞선 요약', upToMessageId: 'm5' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: windowed.summarize
+  })
+
+  assert.equal(whole.seen[0], windowed.seen[0], '요약에 들어가는 글이 글자까지 같다')
+  assert.deepEqual(a.patch, b.patch, '기록하는 워터마크도 같다')
+})
+
+test('워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리지 않는다', () => {
+  /* 삭제·편집으로 그 id 가 이력에 없을 수 있다. 그때 덮은 범위를 알 수 없으므로 전부 다시 본다. */
+  const { dropped } = splitByCap(rows(14), MAX_TURNS)
+  const pending = pendingForSummary(dropped, { text: '앞선 요약', upToMessageId: '지워진-id' })
+
+  assert.equal(pending.length, dropped.length, '전부 미반영')
+  assert.equal(pending[0].id, 'm1')
+})
+
+test('창이 유지분보다 짧으면 접지 않는다 — 새로 밀려난 것이 없다', async () => {
+  const cap = capturing()
+  const r = await foldHistorySummary({
+    rows: rows(MAX_TURNS),
+    rowsStartAfterSummary: true,
+    stored: { text: '앞선 요약', upToMessageId: 'm0' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: cap.summarize
+  })
+
+  assert.equal(r.patch, null)
+  assert.equal(r.skipped, 'nothing-dropped')
+  assert.equal(cap.seen.length, 0, 'LLM 을 부르지 않는다')
+})
+
+test('밀려난 것이 임계치 미만이면 접지 않는다 — 매 턴 요약하지 않는다', async () => {
+  const cap = capturing()
+  const r = await foldHistorySummary({
+    rows: rows(MAX_TURNS + THRESHOLD - 1),
+    rowsStartAfterSummary: true,
+    stored: { text: '앞선 요약', upToMessageId: 'm0' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: cap.summarize
+  })
+
+  assert.equal(r.skipped, 'below-threshold')
+  assert.equal(cap.seen.length, 0)
+})