@things-factory/ai-assistant 10.1.26 → 10.1.28

package/server/service/chat-message/carried-turns.test.ts

@@ -0,0 +1,69 @@
+/*
+ * What this guards: a client cannot make the assistant say something (ADR-0070 A15 decision ③).
+ *
+ * `appendSessionTurns` used to store whatever role it was handed. A carried conversation could
+ * therefore put words in the assistant's mouth — every participant reads them as the assistant's,
+ * and the model reads them back as its own earlier turn and builds on them.
+ */
+import { CARRIED_TURN_LIMIT, carriedOriginalWhere, planCarriedTurns, quoteCarriedAnswer } from './carried-turns'
+
+it("★ a person's carried words are theirs, and they were said to the room", () => {
+  const rows = planCarriedTurns([{ role: 'user', content: '3 라인이 멈춘 것 같아요' }])
+
+  expect(rows).toEqual([{ role: 'user', content: '3 라인이 멈춘 것 같아요', addressee: 'room' }])
+})
+
+it('★ an assistant turn with no original is a quotation on a system row', () => {
+  const rows = planCarriedTurns([{ role: 'assistant', content: '제가 이미 처리했습니다' }])
+
+  expect(rows[0].role).toBe('system')
+  expect(rows[0].content).toBe(quoteCarriedAnswer('제가 이미 처리했습니다'))
+  expect(rows[0].content).toContain('제가 이미 처리했습니다')
+})
+
+it('★ an assistant turn that names its original is copied from storage, not trusted', () => {
+  const rows = planCarriedTurns([
+    { role: 'assistant', content: 'whatever the caller typed', sourceSessionId: 's-1', sourceMessageId: 'm-9' }
+  ])
+
+  expect(rows[0].role).toBe('assistant')
+  expect(rows[0].copyOf).toEqual({ sessionId: 's-1', messageId: 'm-9' })
+})
+
+it("'ai' is the same as 'assistant' — the same rule applies to both spellings", () => {
+  expect(planCarriedTurns([{ role: 'ai', content: '답' }])[0].role).toBe('system')
+})
+
+it('an unknown role is a system row, and empty content is dropped', () => {
+  expect(planCarriedTurns([{ role: 'note', content: '메모' }])[0]).toEqual({ role: 'system', content: '메모' })
+  expect(planCarriedTurns([{ role: 'user', content: '   ' }])).toEqual([])
+})
+
+it('only the last turns are carried — this is context, not an archive', () => {
+  const many = Array.from({ length: CARRIED_TURN_LIMIT + 5 }, (_, i) => ({ role: 'user', content: `줄 ${i}` }))
+
+  const rows = planCarriedTurns(many)
+
+  expect(rows).toHaveLength(CARRIED_TURN_LIMIT)
+  expect(rows[rows.length - 1].content).toBe(`줄 ${CARRIED_TURN_LIMIT + 4}`)
+})
+
+/*
+ * 원본을 찾는 조건 — 문의 설명과 조회가 같은 것을 말해야 한다.
+ *
+ * 설명은 「대화와 메시지로 원본을 댄다」인데 조회가 메시지만 보면, 어긋난 두 인자가 와도 통과한다.
+ * 그때 옮겨 오는 것은 부른 사람이 가리킨 대화의 답이 아니다.
+ */
+describe('carriedOriginalWhere', () => {
+  it('★ 대화를 대면 그 대화 안에서만 찾는다', () => {
+    const where = carriedOriginalWhere('dom-1', { sessionId: 's-1', messageId: 'm-9' })
+
+    expect(where).toEqual({ id: 'm-9', session: { id: 's-1', domain: { id: 'dom-1' } } })
+  })
+
+  it('★ 대화를 대지 않아도 테넌트는 언제나 건다', () => {
+    const where = carriedOriginalWhere('dom-1', { messageId: 'm-9' })
+
+    expect(where).toEqual({ id: 'm-9', session: { domain: { id: 'dom-1' } } })
+  })
+})

package/server/service/chat-message/carried-turns.ts

@@ -0,0 +1,99 @@
+/*
+ * A conversation carried in from somewhere else, turned into rows this session can hold.
+ *
+ * ── Why the assistant's turns are not simply written (ADR-0070 A15 decision ③) ──
+ * `appendSessionTurns` took whatever roles the caller sent, so a client could write a row that
+ * reads as the assistant speaking. Every participant then sees a sentence the assistant never
+ * said, and the model reads it back as its own earlier turn. Roles are the server's to write.
+ *
+ * So a carried assistant turn is kept only when its original can be found — the caller names it
+ * (`sourceSessionId` · `sourceMessageId`) and the server copies the stored text. Without an
+ * original it is kept as a quotation on a `system` row: the content is preserved, and nobody is
+ * told the assistant said it here.
+ */
+
+/** One turn as the caller carried it over. */
+export interface CarriedTurn {
+  role?: string
+  content?: string
+  /** Where an assistant turn came from, so the server can read the original instead of trusting it. */
+  sourceSessionId?: string
+  sourceMessageId?: string
+}
+
+export interface PlannedRow {
+  role: 'user' | 'assistant' | 'system'
+  content: string
+  /** People's words are addressed to the room — this door is not the one that asks the assistant. */
+  addressee?: 'room'
+  /** Set when the row must be filled from a stored message before it is written. */
+  copyOf?: { sessionId?: string; messageId: string }
+}
+
+/** How much of a carried conversation is kept — context, not an archive. */
+export const CARRIED_TURN_LIMIT = 40
+export const CARRIED_CONTENT_LIMIT = 4000
+
+/**
+ * What to write, before anything is looked up.
+ *
+ * Pure: the caller resolves `copyOf` against storage and decides what a missing original becomes.
+ */
+export function planCarriedTurns(turns: CarriedTurn[]): PlannedRow[] {
+  const planned: PlannedRow[] = []
+
+  for (const turn of Array.isArray(turns) ? turns : []) {
+    const content = (turn?.content ?? '').trim().slice(0, CARRIED_CONTENT_LIMIT)
+    if (!content) continue
+
+    const role = turn?.role === 'ai' || turn?.role === 'assistant' ? 'assistant' : turn?.role === 'user' ? 'user' : 'system'
+
+    if (role === 'user') {
+      planned.push({ role: 'user', content, addressee: 'room' })
+      continue
+    }
+
+    if (role === 'assistant') {
+      if (turn?.sourceMessageId) {
+        planned.push({
+          role: 'assistant',
+          content,
+          copyOf: { sessionId: turn.sourceSessionId, messageId: turn.sourceMessageId }
+        })
+      } else {
+        planned.push({ role: 'system', content: quoteCarriedAnswer(content) })
+      }
+      continue
+    }
+
+    planned.push({ role: 'system', content })
+  }
+
+  return planned.slice(-CARRIED_TURN_LIMIT)
+}
+
+/**
+ * An answer with no original, kept as a quotation.
+ *
+ * English, like the other lines the model reads (`[system]`, the omission notices): this row is
+ * context for the model first, and a person reading it sees the quoted text either way.
+ */
+export function quoteCarriedAnswer(content: string): string {
+  return `carried from another conversation, quoted — the assistant did not say this here: "${content}"`
+}
+
+/**
+ * 원본을 찾는 조건.
+ *
+ * 문의 설명은 「`sourceSessionId` 와 `sourceMessageId` 로 원본을 댄다」고 말한다. 조회가 메시지 id 와
+ * 테넌트만 보면, 서로 어긋난 두 인자가 와도 설명과 다르게 통과한다 — 설명과 코드가 갈리는 자리다
+ * [수석 아키텍트가 ADR-0070 구현 검토에서 찾음, 2026-09-18].
+ *
+ * 테넌트는 언제나 건다. 대화를 대면 그것도 건다.
+ */
+export function carriedOriginalWhere(domainId: string, copyOf: { sessionId?: string; messageId: string }): any {
+  return {
+    id: copyOf.messageId,
+    session: copyOf.sessionId ? { id: copyOf.sessionId, domain: { id: domainId } } : { domain: { id: domainId } }
+  }
+}

package/server/service/chat-message/chat-message-subscription.ts

@@ -13,12 +13,13 @@
  * 차이: 필터 키가 board 가 아닌 sessionId (채팅은 ChatSession 단위).
  * 순수 로직(토픽/필터)은 chat-message-broadcast.ts (테스트 가능). 여기엔 pubsub 의존만.
  */
-import { Resolver, Subscription, Root, Arg } from 'type-graphql'
+import { Resolver, Subscription, Root, Arg, Ctx } from 'type-graphql'
 import { filter, pipe } from 'graphql-yoga'
 import { pubsub } from '@things-factory/shell'
 import { ChatMessage } from './chat-message.js'
 import { CHAT_MESSAGE_TOPIC, chatMessageFilter, type ChatMessagePayload } from './chat-message-broadcast.js'
 import { assertDomainSubscribeAllowed } from '../subscribe-auth.js'
+import { readerGate } from './reader-gate.js'
 
 // publishChatMessage 는 데코레이터 없는 chat-message-publish.ts 에 분리 (테스트 import 가능).
 export { publishChatMessage } from './chat-message-publish.js'
@@ -27,7 +28,13 @@ export type { ChatMessagePayload } from './chat-message-broadcast.js'
 
 @Resolver(ChatMessage)
 export class ChatMessageSubscription {
-  @Subscription({
+  @Subscription(() => ChatMessage, {
+    /*
+     * 돌려주는 형을 **명시한다**. 이 핸들러가 async 가 되면서(받는 사람마다 가리기 — ADR-0073 판정 1)
+     * 반환형이 `Promise<ChatMessage>` 가 되었고, type-graphql 의 reflection 은 Promise 안을 못 본다.
+     * 빠지면 스키마를 세울 때 NoExplicitTypeError 로 **패키지 적재 자체가 실패한다** — 시험이 아니라
+     * 부팅이 죽는다. plant 레인이 설치본에서 이 오류를 잡아 알려 주었다(2026-09-18).
+     */
     description:
       'Subscribes to chat messages (user / assistant / system) of a session for real-time group chat.',
     subscribe: async ({ args, context }) => {
@@ -39,7 +46,16 @@ export class ChatMessageSubscription {
       return pipe(pubsub.subscribe(CHAT_MESSAGE_TOPIC), filter(chatMessageFilter(domain.id, sessionId)))
     }
   })
-  chatMessageActivity(@Root() payload: ChatMessagePayload, @Arg('sessionId') sessionId: string): ChatMessage {
-    return payload.message
+  /*
+   * 방송도 **받는 사람 기준으로** 가린다 — ADR-0073 판정 1. 저장해 놓고 읽을 때만 가리면, 그 자리에
+   * 앉아 있던 사람은 방송으로 원문을 받는다. 같은 값이 두 길로 나가고 한쪽만 문을 본다.
+   */
+  async chatMessageActivity(
+    @Root() payload: ChatMessagePayload,
+    @Arg('sessionId') sessionId: string,
+    @Ctx() context: any
+  ): Promise<ChatMessage> {
+    const [message] = await readerGate(context)([payload.message])
+    return message as ChatMessage
   }
 }

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

@@ -60,6 +60,50 @@ export class ChatMessage {
   @Field({ description: 'Message content' })
   content!: string
 
+  /**
+   * 이 말이 누구에게 한 말인가 — `'assistant'` · `'room'`(ADR-0070 A15 결정 ①).
+   *
+   * **값은 그 행을 쓴 문이 찍는다.** 어시스턴트에게 묻는 문(`assistantChat`)이 저장한 사람의 행은
+   * `assistant` 이고, 사람끼리의 문(`appendSessionTurns`)이 저장한 행은 `room` 이다. 클라이언트가
+   * 인자로 보내지 않는다 — 인자로 받으면 「어느 문을 불렀나」와 「무엇을 적어 보냈나」 두 사실이
+   * 생기고, 둘은 어긋날 수 있다.
+   *
+   * 사람의 행에만 뜻이 있다. 어시스턴트의 답은 `parentMessage` 로 자기를 부른 턴에 귀속되고,
+   * `system` 행은 누구에게 한 말이 아니다.
+   */
+  @Column({ type: 'varchar', length: 16, nullable: true })
+  @Field({ nullable: true, description: "Who this turn was for: 'assistant' | 'room'. Written by the door that stored it, never sent by the client." })
+  addressee?: string
+
+  /**
+   * 이 행의 값이 지나온 문들 — ADR-0073 판정 1.
+   *
+   * 어시스턴트의 답과 제안 행에만 채워진다. 사람의 말은 빈 목록이다 — 사람이 자기 입으로 한 말에는
+   * 문이 없다. 답을 저장할 때 그 턴에 부른 도구들의 `doors`(ADR-0072)를 합쳐 옮겨 적는다.
+   *
+   * 읽을 때마다 **읽는 사람**이 이 문을 전부 지나는지 보고, 못 지나면 본문 대신 한 줄이 나간다. 그래서
+   * 이 칸은 "누가 볼 수 있나"를 적은 것이고, 저장된 값 자체는 누구에게도 달라지지 않는다.
+   *
+   * 목록이 비면 누구나 읽는다. 등록기가 모르는 도구가 답에 끼면 `unresolved:<도구>` 가 적히고 아무도
+   * 못 지난다 — 모르는 값은 가려지는 쪽으로 넘어뜨린다.
+   */
+  @Column({ type: 'simple-array', nullable: true })
+  @Field(() => [String], {
+    nullable: true,
+    description:
+      'GraphQL doors the tools behind this answer went through. Empty for what people typed. A reader who does not pass all of them gets a one-line notice in place of the content.'
+  })
+  doors?: string[]
+
+  /**
+   * 이 행이 **이 사람에게** 가려져 나갔는가 — 저장하지 않는다.
+   *
+   * 같은 행이 사람마다 다르게 나가므로 칸에 적을 값이 없다. 읽어 나갈 때 채운다. 화면은 이것으로
+   * 자물쇠를 그리고, 본문에 온 한 줄을 어시스턴트의 말로 오해하지 않는다.
+   */
+  @Field({ nullable: true, description: 'True when the content was replaced because this reader does not pass the row doors.' })
+  redacted?: boolean
+
   @Column({ nullable: true })
   @Field({ nullable: true, description: 'PatchEntry.id this message triggered (if any).' })
   relatedPatchId?: string

package/server/service/chat-message/door-access.ts

@@ -0,0 +1,45 @@
+/*
+ * 문 → 그 문을 지키는 권한 — ADR-0073 판정 1 의 관문을 세우는 자리.
+ *
+ * ── 왜 도구 등록기에서 찾나 ───────────────────────────────────────────────
+ * 행에 적힌 것은 문 이름(`Query.jobOrders`)이고, 사람이 가진 것은 권한(`job-order:query`)이다. 둘을
+ * 잇는 정본은 AUTH 의 필드→권한 표이고, 그 표는 아직 없다(ADR-0072 결정 2 (b) — 수석 아키텍트가 청하기로
+ * 되어 있다). 그때까지는 도구 명세가 이미 들고 있는 짝을 쓴다: 그 문에 닿는다고 선언한 도구가 자기
+ * 권한도 함께 적어 두었다.
+ *
+ * **이것은 사본이다.** 표가 서면 `doorPrivilege` 하나만 그 표를 보게 바꾸고 나머지는 그대로 둔다.
+ *
+ * ── 모르는 문은 닫는다 ────────────────────────────────────────────────────
+ * 어느 도구도 그 문을 선언하지 않았으면 무엇이 그 문을 지키는지 알 수 없다. 모를 때 열면, 도구가 사라진
+ * 뒤에 남은 옛 답이 전부 공개된다 — 지우는 일이 여는 일이 된다. 닫는 쪽으로 넘어뜨린다.
+ */
+import type { ToolPrivilege, ToolSpec } from '@things-factory/ai-client-base'
+
+/** 이 문을 지키는 권한 — 그 문에 닿는다고 선언한 도구에서 가져온다. */
+export function doorPrivilege(door: string, specs: readonly ToolSpec[]): ToolPrivilege | undefined {
+  for (const spec of specs) {
+    if (((spec as any).doors ?? []).includes(door)) return (spec as any).privilege
+  }
+  return undefined
+}
+
+export interface DoorCheckDeps {
+  /** 등록된 도구 명세 전부 — 문→권한을 찾는 표 노릇. */
+  specs: readonly ToolSpec[]
+  /** AUTH 조회. `User.hasPrivilege` 를 그대로 싸서 넘긴다. */
+  hasPrivilege(privilege: ToolPrivilege): Promise<boolean>
+}
+
+/**
+ * 문 하나를 이 사람이 지나는가 — `doorGate` 에 넣을 검사.
+ *
+ * 되풀이 조회를 줄이는 기억은 `doorGate` 가 한다. 여기는 한 번의 판정만 한다.
+ */
+export function doorCheck(deps: DoorCheckDeps): (door: string) => Promise<boolean> {
+  return async (door: string) => {
+    const privilege = doorPrivilege(door, deps.specs)
+    if (!privilege) return false
+
+    return await deps.hasPrivilege(privilege)
+  }
+}

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

@@ -0,0 +1,98 @@
+/*
+ * What this guards: a long conversation on the neutral door gets its earlier turns summarised.
+ *
+ * Every piece existed — the cap, the "N left out" notice, `ChatSession.lastSummary`, and the pure
+ * rules for when to summarise again. Only the board product called them, so twin, plant and figure
+ * conversations announced the omission every turn and never folded anything. A twin deliberation
+ * runs for days, and the first hour is exactly what falls off the front.
+ */
+import { foldSessionHistory, rowsAfterWatermark } from './fold-session-history'
+
+const rows = (count: number, from = 1) =>
+  Array.from({ length: count }, (_, i) => ({
+    id: `m${from + i}`,
+    role: i % 2 ? 'assistant' : 'user',
+    content: `말 ${from + i}`,
+    createdAt: new Date(2026, 8, 18, 9, 0, from + i),
+    creator: { id: 'u1', name: 'alice' }
+  }))
+
+function repos(session: any, messages: any[]) {
+  const updates: any[] = []
+  return {
+    updates,
+    repos: {
+      sessions: {
+        findOneBy: async () => session,
+        update: async (id: string, patch: any) => updates.push({ id, patch })
+      },
+      messages: {
+        findOne: async ({ where }: any) => messages.find(m => m.id === where.id),
+        find: async () => messages
+      }
+    }
+  }
+}
+
+it('★ a conversation past the cap is summarised, and the summary is stored', async () => {
+  const summarize = jest.fn().mockResolvedValue('앞부분 요약')
+  const { repos: r, updates } = repos({ id: 's1' }, rows(60))
+
+  await foldSessionHistory({
+    sessionId: 's1',
+    domainId: 'dom-1',
+    client: { chat: summarize } as any,
+    maxTurns: 40,
+    repos: r
+  })
+
+  expect(summarize).toHaveBeenCalled()
+  expect(updates).toHaveLength(1)
+  expect(updates[0].patch.lastSummary).toBe('앞부분 요약')
+  expect(updates[0].patch.summaryUpToMessageId).toBeDefined()
+})
+
+it('★ a short conversation is left alone — nothing has fallen off yet', async () => {
+  const summarize = jest.fn()
+  const { repos: r, updates } = repos({ id: 's1' }, rows(5))
+
+  await foldSessionHistory({ sessionId: 's1', domainId: 'dom-1', client: { chat: summarize } as any, maxTurns: 40, repos: r })
+
+  expect(summarize).not.toHaveBeenCalled()
+  expect(updates).toEqual([])
+})
+
+it('★ a failed summary does not throw — the next turn says "left out" instead', async () => {
+  const summarize = jest.fn().mockRejectedValue(new Error('provider down'))
+  const { repos: r, updates } = repos({ id: 's1' }, rows(60))
+
+  await expect(
+    foldSessionHistory({ sessionId: 's1', domainId: 'dom-1', client: { chat: summarize } as any, maxTurns: 40, repos: r })
+  ).resolves.toBeUndefined()
+  expect(updates).toEqual([])
+})
+
+it('a session that is not this tenant\'s is not touched', async () => {
+  const summarize = jest.fn()
+  const { repos: r, updates } = repos(undefined, rows(60))
+
+  await foldSessionHistory({ sessionId: 's1', domainId: 'dom-1', client: { chat: summarize } as any, maxTurns: 40, repos: r })
+
+  expect(summarize).not.toHaveBeenCalled()
+  expect(updates).toEqual([])
+})
+
+describe('rowsAfterWatermark', () => {
+  it('reads the whole conversation when nothing is summarised yet', () => {
+    expect(rowsAfterWatermark('s1', undefined)).toEqual({ session: { id: 's1' } })
+  })
+
+  it('★ continues within one timestamp by id — messages in the same millisecond are not skipped', () => {
+    const at = new Date(2026, 8, 18, 9, 0, 1)
+
+    const where = rowsAfterWatermark('s1', { id: 'm7', createdAt: at })
+
+    expect(Array.isArray(where)).toBe(true)
+    expect(where[1]).toMatchObject({ session: { id: 's1' }, createdAt: at })
+  })
+})

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

@@ -0,0 +1,115 @@
+/*
+ * Folding a long conversation's earlier turns into a summary — for every surface, not only boards.
+ *
+ * ── The gap this closes (2026-09-18) ───────────────────────────────────────────
+ * The pieces were all here: a cap on how many turns reach the model, a notice when turns are left
+ * out, `ChatSession.lastSummary` to carry what was dropped, and pure rules for when to re-summarise
+ * (`history-summary`, `fold-history`). Only the board product ever called them. The neutral door —
+ * the one the twin, plant and figure conversations run through — never did, so those sessions kept
+ * announcing "the first N messages were left out" and never summarised them.
+ *
+ * That is worst exactly where it was designed to help: a twin deliberation runs for days, and what
+ * the room agreed on in the first hour is what falls off the front.
+ *
+ * ── What is here and what is not ───────────────────────────────────────────────
+ * The rules stay pure and tested elsewhere. This is the reading and the writing: find what the
+ * stored summary does not cover yet, ask the model for a new one, store it. It is called after the
+ * reply has gone out, and it never throws — a conversation must not fail because a summary did not
+ * get written, and the next turn says "N left out" honestly if it did not.
+ */
+import { MoreThan } from 'typeorm'
+
+import type { AIClient } from '@things-factory/ai-client-base'
+
+import { foldHistorySummary } from './fold-history.js'
+import { summaryInstruction } from './history-summary.js'
+
+/*
+ * 엔티티는 **늦게 가져온다.** 위에서 import 하면 이 파일을 읽는 순간 TypeGraphQL 데코레이터가 돌고,
+ * 데코레이터 메타데이터가 없는 자리(시험 러너)에서 모듈 적재가 깨진다. 규칙 자체는 데이터베이스가
+ * 없어도 검사할 수 있어야 한다.
+ */
+async function defaultRepos() {
+  const { getRepository } = await import('@things-factory/shell')
+  const { ChatSession } = await import('../chat-session/chat-session.js')
+  const { ChatMessage } = await import('./chat-message.js')
+  return { sessions: getRepository(ChatSession as any), messages: getRepository(ChatMessage as any) }
+}
+
+/** How many newly-dropped turns are worth another summarisation call. */
+export const DEFAULT_SUMMARY_THRESHOLD = 10
+
+export interface FoldSessionHistoryInput {
+  sessionId: string
+  domainId: string
+  /** The same client that answered — a summary is written by whatever this deployment has. */
+  client: Pick<AIClient, 'chat'>
+  /** The cap the door uses when it builds the history, so both sides agree on what fell off. */
+  maxTurns: number
+  threshold?: number
+  locale?: string
+  /** Test seam: the two repositories this reads and writes. */
+  repos?: { sessions: any; messages: any }
+}
+
+/**
+ * Where the rows after the summary's watermark are.
+ *
+ * Kept separate so the window can be read without a database: the array is an OR, and the second
+ * branch continues within one timestamp by id — the same axis the ordering uses, or a burst of
+ * messages in the same millisecond would be summarised twice or not at all.
+ */
+export function rowsAfterWatermark(sessionId: string, mark: { id?: string; createdAt?: Date } | undefined): any {
+  const session = { id: sessionId } as any
+  if (!mark?.createdAt) return { session }
+  return [
+    { session, createdAt: MoreThan(mark.createdAt) },
+    { session, createdAt: mark.createdAt, id: MoreThan(mark.id) }
+  ]
+}
+
+export async function foldSessionHistory(input: FoldSessionHistoryInput): Promise<void> {
+  try {
+    const { sessions, messages } = input.repos ?? (await defaultRepos())
+    const session = await sessions.findOneBy({ id: input.sessionId, domain: { id: input.domainId } as any })
+    if (!session) return
+
+    const stored = { text: (session as any).lastSummary, upToMessageId: (session as any).summaryUpToMessageId }
+    const order = { createdAt: 'ASC', id: 'ASC' } as any
+    const relations = { creator: true } as any
+
+    /* 요약이 덮은 지점을 알면 그 뒤만 읽는다 — 매 턴 전체 대화를 읽지 않는다. */
+    let mark: { id?: string; createdAt?: Date } | undefined
+    if (stored.text && stored.upToMessageId) {
+      mark = await messages.findOne({ where: { session: { id: input.sessionId } as any, id: stored.upToMessageId } })
+    }
+    /* 워터마크 행이 사라졌으면 덮은 범위를 모른다 — 전부 다시 본다. */
+    const startsAfterSummary = Boolean(stored.text && mark?.createdAt)
+    const rows = await messages.find({ where: rowsAfterWatermark(input.sessionId, startsAfterSummary ? mark : undefined), relations, order })
+
+    const { patch } = await foldHistorySummary({
+      rows: rows.map((row: any) => ({
+        id: row.id,
+        role: row.role,
+        content: row.content ?? '',
+        senderId: row.creator?.id,
+        senderName: row.creator?.name || row.creator?.username
+      })),
+      rowsStartAfterSummary: startsAfterSummary,
+      stored,
+      maxTurns: input.maxTurns,
+      threshold: input.threshold ?? DEFAULT_SUMMARY_THRESHOLD,
+      summarize: content =>
+        input.client.chat!([{ role: 'user', content }], {
+          systemPrompt: summaryInstruction(input.locale),
+          maxTokens: 700,
+          /* 요약은 창작이 아니다 — 흔들림을 줄인다. */
+          temperature: 0
+        })
+    })
+
+    if (patch) await sessions.update(input.sessionId, patch as any)
+  } catch {
+    /* 요약 실패는 대화를 막지 않는다 — 다음 턴이 「N 개 생략」으로 정직하게 알린다. */
+  }
+}

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

@@ -48,7 +48,7 @@ describe('발신자 표기', () => {
 
   it('이름이 없으면 빈 대괄호를 남기지 않고 참여자로 표기한다', () => {
     const out = buildLlmHistory([u('1', 'a', 'U1', '김철수'), u('2', 'b', 'U2', undefined)])
-    expect(out[1].content).toBe('[참여자] b')
+    expect(out[1].content).toBe('[participant] b')
   })
 
   it('assistant 발언에는 표기하지 않는다 — role 로 이미 구별된다', () => {
@@ -75,7 +75,7 @@ describe('발신자 표기', () => {
 describe('system 기록', () => {
   it('시스템 기록은 표기를 붙인 user 메시지로 전달된다 — 사장되지 않는다', () => {
     const out = buildLlmHistory([sys('1', 'User directly edited the board: 3 op(s)')])
-    expect(out).toEqual([{ role: 'user', content: '[시스템] User directly edited the board: 3 op(s)' }])
+    expect(out).toEqual([{ role: 'user', content: '[system] User directly edited the board: 3 op(s)' }])
   })
 
   it('시스템 기록은 발신자 수 계산에 넣지 않는다 — 사람 한 명이면 표기 없음 유지', () => {
@@ -145,8 +145,9 @@ describe('이력 상한 — 협의가 길어질 때', () => {
 
   it('생략은 **반드시 알린다** — 조용히 버리면 모델이 남은 첫 줄을 대화의 시작으로 오해한다', () => {
     const out = buildLlmHistory(rows(10), { maxTurns: 4 })
-    expect(out[0].content).toContain('6개')
-    expect(out[0].content).toContain('생략')
+    /* The notice is read by the model, so it is English. */
+    expect(out[0].content).toContain('6 message(s)')
+    expect(out[0].content).toContain('left out')
   })
 
   it('상한에 걸리지 않으면 알림을 붙이지 않는다 — 없는 생략을 말하지 않는다', () => {
@@ -172,18 +173,18 @@ describe('이력 요약 접기 — 프롬프트 조립', () => {
       summary: { text: '앞에서 정한 것: 지게차 1대 추가', upToMessageId: 'm5' }
     })
     expect(out[0].content).toContain('지게차 1대 추가')
-    expect(out[0].content).not.toContain('생략되었습니다.')
+    expect(out[0].content).not.toContain('left out')
   })
 
   it('요약임을 밝힌다 — 모델이 원문처럼 인용하지 않게', () => {
     const out = buildLlmHistory(rows(10), { maxTurns: 4, summary: { text: '요약본', upToMessageId: 'm5' } })
-    expect(out[0].content).toContain('원문 아님')
+    expect(out[0].content).toContain('not the original')
   })
 
   it('요약이 밀려난 구간을 다 덮지 못하면 남은 개수를 밝힌다 — 최신이 아님을 숨기지 않는다', () => {
     /* 밀려난 것은 m0..m5(6개), 요약은 m3 까지 → m4·m5 두 개가 미반영. */
     const out = buildLlmHistory(rows(10), { maxTurns: 4, summary: { text: '요약본', upToMessageId: 'm3' } })
-    expect(out[0].content).toContain('2개')
+    expect(out[0].content).toContain('2 message(s) after it are not in the summary yet')
   })
 
   it('상한에 걸리지 않으면 요약을 싣지 않는다 — 필요 없는 문맥을 넣지 않는다', () => {
@@ -192,3 +193,53 @@ describe('이력 요약 접기 — 프롬프트 조립', () => {
     expect(out[0].content).toBe('말 0')
   })
 })
+
+/*
+ * 누구에게 한 말인가 — ADR-0070 A15 결정 ②.
+ *
+ * 여럿이 있는 방에서는 옆 사람에게 한 말과 어시스턴트를 부른 말이 같은 모양으로 저장된다. 대상을
+ * 적지 않으면 모델은 그 둘을 가르지 못하고, 방에 한 말을 자기에게 온 지시로 읽는다.
+ */
+describe('대상 표기', () => {
+  const rows = [
+    { id: 'm1', role: 'user', content: '3 라인이 멈춘 것 같아요', senderId: 'u1', senderName: 'alice', addressee: 'room' },
+    { id: 'm2', role: 'user', content: '아까부터 그랬어', senderId: 'u2', senderName: 'bob', addressee: 'room' },
+    { id: 'm3', role: 'user', content: '왜 멈췄는지 확인해줘', senderId: 'u1', senderName: 'alice', addressee: 'assistant' }
+  ]
+
+  it('★ 사람의 말마다 발신자와 대상을 함께 적는다', () => {
+    const out = buildLlmHistory(rows as any)
+
+    expect(out.map(m => m.content)).toEqual([
+      '[alice → room] 3 라인이 멈춘 것 같아요',
+      '[bob → room] 아까부터 그랬어',
+      '[alice → assistant] 왜 멈췄는지 확인해줘'
+    ])
+  })
+
+  it('★ 혼자 하는 대화에서도 적는다 — 한 모양이어야 모델이 빈 자리에서 추론하지 않는다', () => {
+    const out = buildLlmHistory([rows[2]] as any)
+
+    expect(out[0].content).toBe('[alice → assistant] 왜 멈췄는지 확인해줘')
+  })
+
+  it('★ 대상을 모르는 옛 행은 대상을 지어내지 않는다', () => {
+    const out = buildLlmHistory([
+      { id: 'm1', role: 'user', content: '예전 말', senderId: 'u1', senderName: 'alice' },
+      { id: 'm2', role: 'user', content: '예전 말 둘', senderId: 'u2', senderName: 'bob' }
+    ] as any)
+
+    expect(out.map(m => m.content)).toEqual(['[alice] 예전 말', '[bob] 예전 말 둘'])
+  })
+
+  it('어시스턴트의 답과 시스템 행은 대상을 적지 않는다', () => {
+    const out = buildLlmHistory([
+      { id: 'm1', role: 'user', content: '물었다', senderId: 'u1', senderName: 'alice', addressee: 'assistant' },
+      { id: 'm2', role: 'assistant', content: '답했다' },
+      { id: 'm3', role: 'system', content: 'proposal k: refused (no-target)' }
+    ] as any)
+
+    expect(out[1]).toEqual({ role: 'assistant', content: '답했다' })
+    expect(out[2].content).toBe('[system] proposal k: refused (no-target)')
+  })
+})