@things-factory/board-ai 10.0.1 → 10.0.3

package/server/service/chat-message/llm-history.test.ts

@@ -127,3 +127,68 @@ describe('기타', () => {
     expect(out.map(m => m.content)).toEqual(['A', 'B', 'C'])
   })
 })
+
+describe('이력 상한 — 협의가 길어질 때', () => {
+  const rows = (n: number) =>
+    Array.from({ length: n }, (_, i) => ({ id: `m${i}`, role: i % 2 ? 'assistant' : 'user', content: `말 ${i}` }))
+
+  it('상한 미지정이면 전부 보낸다 — 기존 동작 유지', () => {
+    expect(buildLlmHistory(rows(10))).toHaveLength(10)
+  })
+
+  it('상한을 넘으면 최근 것만 남긴다 — 오래된 말보다 최근 상황이 답을 좌우한다', () => {
+    const out = buildLlmHistory(rows(10), { maxTurns: 4 })
+    /* 생략 알림 1줄 + 최근 4줄 */
+    expect(out).toHaveLength(5)
+    expect(out[out.length - 1].content).toContain('말 9')
+  })
+
+  it('생략은 **반드시 알린다** — 조용히 버리면 모델이 남은 첫 줄을 대화의 시작으로 오해한다', () => {
+    const out = buildLlmHistory(rows(10), { maxTurns: 4 })
+    expect(out[0].content).toContain('6개')
+    expect(out[0].content).toContain('생략')
+  })
+
+  it('상한에 걸리지 않으면 알림을 붙이지 않는다 — 없는 생략을 말하지 않는다', () => {
+    const out = buildLlmHistory(rows(3), { maxTurns: 10 })
+    expect(out).toHaveLength(3)
+    expect(out[0].content).toBe('말 0')
+  })
+
+  it('접은 구간 제거가 먼저, 상한이 나중 — 두 규칙이 겹쳐도 최근 것이 남는다', () => {
+    const out = buildLlmHistory(rows(10), { truncateAfterMessageId: 'm5', maxTurns: 3 })
+    expect(out).toHaveLength(4) // 알림 + 3
+    expect(out[out.length - 1].content).toContain('말 5')
+  })
+})
+
+describe('이력 요약 접기 — 프롬프트 조립', () => {
+  const rows = (n: number) =>
+    Array.from({ length: n }, (_, i) => ({ id: `m${i}`, role: i % 2 ? 'assistant' : 'user', content: `말 ${i}` }))
+
+  it('요약이 있으면 "생략" 대신 요약을 싣는다 — 앞에서 정한 것이 없던 일이 되지 않게', () => {
+    const out = buildLlmHistory(rows(10), {
+      maxTurns: 4,
+      summary: { text: '앞에서 정한 것: 지게차 1대 추가', upToMessageId: 'm5' }
+    })
+    expect(out[0].content).toContain('지게차 1대 추가')
+    expect(out[0].content).not.toContain('생략되었습니다.')
+  })
+
+  it('요약임을 밝힌다 — 모델이 원문처럼 인용하지 않게', () => {
+    const out = buildLlmHistory(rows(10), { maxTurns: 4, summary: { text: '요약본', upToMessageId: 'm5' } })
+    expect(out[0].content).toContain('원문 아님')
+  })
+
+  it('요약이 밀려난 구간을 다 덮지 못하면 남은 개수를 밝힌다 — 최신이 아님을 숨기지 않는다', () => {
+    /* 밀려난 것은 m0..m5(6개), 요약은 m3 까지 → m4·m5 두 개가 미반영. */
+    const out = buildLlmHistory(rows(10), { maxTurns: 4, summary: { text: '요약본', upToMessageId: 'm3' } })
+    expect(out[0].content).toContain('2개')
+  })
+
+  it('상한에 걸리지 않으면 요약을 싣지 않는다 — 필요 없는 문맥을 넣지 않는다', () => {
+    const out = buildLlmHistory(rows(3), { maxTurns: 10, summary: { text: '요약본', upToMessageId: 'm0' } })
+    expect(out).toHaveLength(3)
+    expect(out[0].content).toBe('말 0')
+  })
+})

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

@@ -35,6 +35,7 @@
  * "내 발언만 접기"는 별도 개선으로 다룬다.
  */
 import type { LLMMessage } from '../types.js'
+import { pendingForSummary, type StoredSummary } from './history-summary.js'
 
 /** 이력 한 줄 — 저장된 ChatMessage 에서 필요한 것만(엔티티·typeorm 비의존). */
 export interface HistoryRow {
@@ -55,12 +56,32 @@ export interface BuildLlmHistoryOptions {
   keepMessageIds?: string[]
   /** 발신자 표기 강제 — 미지정이면 사람 발신자가 둘 이상일 때만 표기. 테스트·특수 호출용. */
   labelSenders?: boolean
+  /**
+   * 모델에 넘길 **최근 메시지 수 상한**. 초과분(오래된 앞부분)은 버리고 생략 표시를 남긴다.
+   *
+   * 왜 필요한가: 협의는 며칠에 걸친다. 상한이 없으면 매 턴 전체 이력을 보내 프롬프트가 무한히
+   * 자라고(비용·지연·문맥 한계) 오래된 말이 최근 상황을 덮는다. 미지정이면 전부 보낸다(기존 동작).
+   *
+   * **생략은 반드시 알린다** — 조용히 버리면 모델은 남은 첫 줄을 대화의 시작으로 오해한다.
+   * 이건 상한일 뿐 요약이 아니다. 버린 내용을 요약해 실어 보내는 것은 다음 단계다(ChatSession.lastSummary).
+   */
+  maxTurns?: number
+  /**
+   * 상한으로 밀려난 앞부분을 대신할 **요약**(세션에 저장된 것).
+   *
+   * 있으면 "N개 생략" 대신 요약을 첫 줄로 싣는다 — 며칠 이어지는 협의에서 앞에서 합의한 것이
+   * 없던 일이 되지 않게. 요약이 밀려난 구간을 **전부 덮지 못하면** 덮지 못한 개수도 함께 밝힌다
+   * (요약이 최신이 아닐 수 있다는 사실을 숨기지 않는다).
+   */
+  summary?: StoredSummary
 }
 
 /** 사람이 아닌 기록(캔버스 직접 편집 등)의 표기. */
 const SYSTEM_LABEL = '시스템'
 /** 이름을 모르는 참여자의 표기 — 빈 대괄호를 남기지 않는다. */
 const UNKNOWN_LABEL = '참여자'
+/** 상한으로 잘라낸 앞부분을 알리는 표기 — 모델이 남은 첫 줄을 대화의 시작으로 오해하지 않게. */
+const OMITTED_LABEL = '시스템'
 
 /**
  * 저장된 이력 → LLM 대화.
@@ -70,12 +91,38 @@ const UNKNOWN_LABEL = '참여자'
  */
 export function buildLlmHistory(rows: HistoryRow[], options: BuildLlmHistoryOptions = {}): LLMMessage[] {
   const keep = new Set(options.keepMessageIds ?? [])
-  const kept = truncate(rows, options.truncateAfterMessageId, keep)
+  const truncated = truncate(rows, options.truncateAfterMessageId, keep)
+  /* 상한 — 최근 것부터 남긴다. 오래된 말보다 최근 상황이 답을 좌우한다. */
+  const limit = options.maxTurns && options.maxTurns > 0 ? options.maxTurns : 0
+  const omitted = limit && truncated.length > limit ? truncated.length - limit : 0
+  const kept = omitted ? truncated.slice(-limit) : truncated
 
   const label =
     options.labelSenders ?? new Set(kept.filter(r => isHuman(r)).map(r => r.senderId ?? '')).size > 1
 
   const out: LLMMessage[] = []
+  if (omitted) {
+    const dropped = truncated.slice(0, truncated.length - kept.length)
+    const summaryText = (options.summary?.text ?? '').trim()
+    if (summaryText) {
+      /* 요약이 있으면 그것을 싣는다. **요약임을 밝힌다** — 모델이 원문처럼 인용하지 않게.
+       * 요약이 밀려난 구간을 다 덮지 못하면 남은 개수도 함께 알린다(최신이 아님을 숨기지 않는다). */
+      const uncovered = pendingForSummary(dropped, options.summary).length
+      const tail = uncovered
+        ? ` 그 뒤 ${uncovered}개 메시지는 요약에 아직 반영되지 않았습니다.`
+        : ''
+      out.push({
+        role: 'user',
+        content: `[${OMITTED_LABEL}] 이 대화의 앞부분 ${dropped.length}개 메시지는 길이 제한으로 아래 요약으로 대체되었습니다(원문 아님 — 요약에 없는 사실은 사용자에게 확인하세요).${tail}\n${summaryText}`
+      })
+    } else {
+      /* 요약이 아직 없으면 생략 사실만 알린다 — 개수만 밝히고 내용은 지어내지 않는다. */
+      out.push({
+        role: 'user',
+        content: `[${OMITTED_LABEL}] 이 대화의 앞부분 ${omitted}개 메시지는 길이 제한으로 생략되었습니다. 필요하면 사용자에게 다시 확인하세요.`
+      })
+    }
+  }
   for (const row of kept) {
     const content = (row.content ?? '').trim()
     if (!content) continue // 빈 본문(pending 자리 등)은 모델에 넘길 것이 없다

package/server/service/chat-session/chat-session.ts

@@ -146,6 +146,17 @@ export class ChatSession {
   @Field({ nullable: true, description: 'Compressed summary of older messages (for token saving).' })
   lastSummary?: string
 
+  /**
+   * `lastSummary` 가 **어디까지 덮는지** — 이 메시지까지 요약에 반영됐다.
+   *
+   * 이게 없으면 누적 요약을 할 수 없다: 매 턴 전체를 다시 요약하거나(비용) 이미 요약한 구간을
+   * 또 이어 붙인다(중복). 이력에서 이 id 를 못 찾으면(삭제·편집) 덮은 범위를 알 수 없으므로
+   * 전부 미반영으로 보고 다시 요약한다 — 빠뜨리는 쪽보다 안전하다.
+   */
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Id of the last message folded into lastSummary — enables incremental summarization instead of re-reading the whole history.' })
+  summaryUpToMessageId?: string
+
   /** 사용 모델 식별 — 'anthropic:claude-sonnet-4-6' 등 */
   @Column({ nullable: true })
   @Field({ nullable: true })

package/server/service/chat-session/session-inbox.test.ts

@@ -11,7 +11,7 @@
  *
  * 집계 쿼리를 쓰지 않는 설계라(5개 DB 드라이버) 판정이 전부 값 비교로 끝난다 — 그래서 순수 테스트가 된다.
  */
-import { buildInbox, countUnreadSessions, activityPatch } from './session-inbox'
+import { buildInbox, countUnreadSessions, activityPatch, applyHidden, searchInbox } from './session-inbox'
 
 const t = (iso: string) => new Date(iso)
 
@@ -115,3 +115,71 @@ describe('활동 갱신 값', () => {
     expect(activityPatch('').lastMessagePreview).toBe('')
   })
 })
+
+describe('applyHidden — 내 목록에서만 숨기기', () => {
+  const entry = (id: string, lastMessageAt?: string): any => ({
+    id,
+    lastMessageAt,
+    unread: false,
+    participant: true
+  })
+
+  it('숨긴 대화는 기본 목록에서 빠진다', () => {
+    const out = applyHidden([entry('a', '2026-07-30T01:00:00Z'), entry('b')], new Map([['a', '2026-07-30T02:00:00Z']]))
+    expect(out.map(e => e.id)).toEqual(['b'])
+  })
+
+  it('숨긴 뒤 새 활동이 생기면 다시 보인다 — 참여 중인 대화에서 조용히 잘려 나가지 않게', () => {
+    const out = applyHidden([entry('a', '2026-07-30T03:00:00Z')], new Map([['a', '2026-07-30T02:00:00Z']]))
+    expect(out.map(e => e.id)).toEqual(['a'])
+    expect(out[0].hidden).toBeUndefined()
+  })
+
+  it('필터를 켜면 숨긴 것도 표시와 함께 돌려준다 — 되돌릴 수 있어야 한다', () => {
+    const out = applyHidden(
+      [entry('a', '2026-07-30T01:00:00Z'), entry('b')],
+      new Map([['a', '2026-07-30T02:00:00Z']]),
+      true
+    )
+    expect(out.map(e => e.id)).toEqual(['a', 'b'])
+    expect(out[0].hidden).toBe(true)
+    expect(out[1].hidden).toBeUndefined()
+  })
+
+  it('숨김 기록이 없으면 아무것도 바꾸지 않는다', () => {
+    const entries = [entry('a'), entry('b')]
+    expect(applyHidden(entries, new Map())).toEqual(entries)
+  })
+})
+
+describe('searchInbox — 대량 목록의 풀텍스트 필터', () => {
+  const rows: any[] = [
+    { id: 'a', name: 'A-DC 포화 원인', lastMessagePreview: '점유율이 92% 입니다', unread: false, participant: true },
+    { id: 'b', name: 'Dock 배치 검토', lastMessagePreview: '입고 도크를 늘리면', unread: false, participant: true },
+    { id: 'c', lastMessagePreview: '이름 없는 대화', unread: false, participant: true }
+  ]
+
+  it('이름으로 찾는다', () => {
+    expect(searchInbox(rows, '포화').map(e => e.id)).toEqual(['a'])
+  })
+
+  it('미리보기 본문으로도 찾는다 — 제목만으로는 돌아갈 대화를 못 찾는다', () => {
+    expect(searchInbox(rows, '입고').map(e => e.id)).toEqual(['b'])
+  })
+
+  it('대소문자를 무시한다', () => {
+    expect(searchInbox(rows, 'dock').map(e => e.id)).toEqual(['b'])
+  })
+
+  it('이름이 없는 대화도 미리보기로 걸린다', () => {
+    expect(searchInbox(rows, '이름 없는').map(e => e.id)).toEqual(['c'])
+  })
+
+  it('빈 검색어는 전체를 그대로 돌려준다(필터 없음)', () => {
+    expect(searchInbox(rows, '   ')).toBe(rows)
+  })
+
+  it('맞는 것이 없으면 빈 목록 — 조용히 전체를 보여주지 않는다', () => {
+    expect(searchInbox(rows, 'zzz')).toEqual([])
+  })
+})

package/server/service/chat-session/session-inbox.ts

@@ -31,6 +31,8 @@ export interface InboxSessionRow {
 export interface MyParticipation {
   sessionId?: string
   lastReadAt?: Date | string | null
+  /** 내 목록에서 숨긴 시각 — 이후 새 활동이 생기면 다시 보인다. */
+  hiddenAt?: Date | string | null
 }
 
 export interface InboxEntry extends InboxSessionRow {
@@ -38,6 +40,8 @@ export interface InboxEntry extends InboxSessionRow {
   unread: boolean
   /** 내가 참여자인가 — 아니면 열어볼 수는 있어도 읽음 상태를 갖지 않는다. */
   participant: boolean
+  /** 내가 숨긴 대화인가 — 목록에서 빠지지만 필터로 볼 수 있다(되돌리기 가능). */
+  hidden?: boolean
 }
 
 function time(v: Date | string | null | undefined): number {
@@ -83,6 +87,47 @@ export function buildInbox(sessions: InboxSessionRow[], mine: MyParticipation[])
   )
 }
 
+/**
+ * 숨김 표시·필터.
+ *
+ * 숨김은 **나에게만** 적용되고 되돌릴 수 있다. 숨긴 **뒤에 새 활동이 생기면 다시 보인다** —
+ * 아직 참여 중인 대화에서 조용히 잘려 나가는 것이 목록 한 줄보다 나쁘다.
+ *
+ * `showHidden` 이면 숨긴 것도 함께 돌려주되 표시(hidden)를 남긴다 — 필터를 켠 사용자가 무엇이
+ * 숨겨진 것인지 알아야 되돌릴 수 있다.
+ */
+export function applyHidden(entries: InboxEntry[], hiddenAt: Map<string, Date | string | null | undefined>, showHidden = false): InboxEntry[] {
+  const out: InboxEntry[] = []
+  for (const entry of entries) {
+    const at = hiddenAt.get(entry.id ?? '')
+    /* 숨긴 시각보다 **뒤에** 활동이 있으면 숨김은 풀린 것으로 본다. */
+    const hidden = !!at && time(entry.lastMessageAt) <= time(at)
+    if (hidden && !showHidden) continue
+    out.push(hidden ? { ...entry, hidden: true } : entry)
+  }
+  return out
+}
+
+/**
+ * 검색 — 이름과 마지막 미리보기에 대한 대소문자 무시 부분일치.
+ *
+ * **왜 메모리에서 하는가**: 이 프레임워크는 5개 DB 드라이버를 지원한다. 대소문자 무시 검색은
+ * 드라이버마다 표기가 갈리고(ILIKE=pg 전용, LOWER()+LIKE 는 되지만 정렬·NULL 취급이 또 갈린다),
+ * 목록 경로에 드라이버별 SQL 을 두는 것은 이 프로젝트의 규율에 반한다. 그래서 조회는 앵커로
+ * **상한을 두고** 가져오고(아래 INBOX_SCAN_CAP) 걸러내기·정렬·페이지는 여기서 한다.
+ * 상한을 넘으면 잘렸다는 사실을 그대로 알린다(조용히 일부만 보여주지 않는다).
+ */
+export function searchInbox(entries: InboxEntry[], search?: string): InboxEntry[] {
+  const q = (search ?? '').trim().toLowerCase()
+  if (!q) return entries
+  return entries.filter(e =>
+    `${e.name ?? ''}\n${e.lastMessagePreview ?? ''}`.toLowerCase().includes(q)
+  )
+}
+
+/** 한 번에 훑는 세션 상한 — 이보다 많으면 잘렸다고 알린다(정직). */
+export const INBOX_SCAN_CAP = 500
+
 /** 안 읽은 세션 수 — 도크 버튼 배지(개수가 아니라 **세션 수**). */
 export function countUnreadSessions(entries: InboxEntry[]): number {
   return entries.filter(e => e.unread).length

package/server/service/chat-session-participant/chat-session-participant.ts

@@ -93,6 +93,20 @@ export class ChatSessionParticipant {
   @Field({ nullable: true, description: 'Point up to which this participant has read the session. Distinct from lastSeenAt (presence): a window can be open without being read, and the read point survives disconnection. Null means nothing read yet.' })
   lastReadAt?: Date
 
+  /**
+   * 이 사용자가 **자기 목록에서 숨긴 시각**. 숨김은 **나에게만** 적용된다 — 남의 목록·대화 내용은 그대로다.
+   *
+   * 왜 삭제와 나누는가: 협의는 여럿의 기록이므로 지우는 것은 **만든 사람**만 할 수 있다(되돌릴 수 없다).
+   * 그 권한이 없는 사람에게도 "내 목록을 정리할" 방법은 있어야 하고, 그것이 숨김이다.
+   *
+   * 숨긴 **뒤에 새 활동이 생기면 다시 나타난다** — 아직 참여자인 대화에서 조용히 잘려 나가는 것이
+   * 목록이 한 줄 늘어나는 것보다 나쁘다. 완전히 빠지려면 대화에서 나가야 한다(별개 기능).
+   * nullable — 값이 없으면 숨기지 않은 상태.
+   */
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When this user hid the session from their own list. Per-user only; the session and other participants are unaffected. Activity newer than this timestamp makes it reappear.' })
+  hiddenAt?: Date
+
   @ManyToOne(type => User)
   @Field(type => User, { nullable: true, description: 'User who created this participant record (typically session owner who invited).' })
   creator?: User