@things-factory/ai-assistant 10.1.27 → 10.1.29

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

@@ -0,0 +1,184 @@
+/*
+ * ★ 요약 접기는 **필요한 만큼만 읽는다** — 그러면서 앞부분을 잃지 않는다.
+ *
+ * ── 무엇을 겪었나 (2026-08-20) ──────────────────────────────────────────────
+ * `_foldHistorySummary` 는 **메시지를 보낼 때마다** 그 세션의 대화를 처음부터 끝까지 읽었다
+ * (`creator` 조인까지). 정작 쓰는 것은 두 조각뿐이다: 마지막 `maxTurns`개와, 요약 워터마크
+ * 뒤부터의 미반영분. 대화가 2,000개면 매 메시지마다 2,000행을 읽어 수십 행을 쓴 셈이다.
+ *
+ * 같은 종류의 결함을 트윈 쪽에서 먼저 잡았다(`timeRange` — min/max 두 수를 구하려고 저널 27만
+ * 행을 4초마다 읽었다). 사람 리뷰가 그것을 못 잡은 이유는 **코드가 맞았기 때문**이다. 여기도 같다:
+ * 답은 맞고 비용만 틀렸다. 그래서 이 시험은 답과 함께 **어디까지 읽어야 하는가**를 못 박는다.
+ *
+ * ── 지키는 것 ───────────────────────────────────────────────────────────────
+ * ① 창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 워터마크로 또 자르지 않는다.
+ * ② 전체를 읽어 왔으면 워터마크로 자른다 — 이미 요약에 담은 것을 두 번 담지 않는다.
+ * ③ 두 경로가 **같은 답**을 낸다. 읽는 범위를 바꾼 것이 요약 내용을 바꾸면 안 된다.
+ * ④ 워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리는 쪽보다 다시 요약하는 쪽이 안전하다.
+ *
+ * ── 왜 여기로 왔나 (2026-09-18) ────────────────────────────────────────────
+ * 요약 접기를 `board-ai` 에서 이 꾸러미로 옮기면서(`4257583d1b`) 이 시험만 board-ai 에 남았다. 읽는
+ * 파일이 사라졌으니 board-ai 의 `npm test` 가 그날부터 실패했다 — 옮긴 사람이 시험을 두고 온 것이다.
+ * 여기 오면서 `dist-server` 를 거치지 않고 소스를 바로 읽는다.
+ */
+
+import { foldHistorySummary } from './fold-history'
+import { pendingForSummary, splitByCap } from './history-summary'
+
+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 '요약'
+    }
+  }
+}
+
+it('창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 워터마크로 또 자르지 않는다', 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
+  })
+
+  expect(r.patch).toBeTruthy() // '4개가 밀려났고 임계치 3 이상이므로 접는다'
+  expect(r.patch!.summaryUpToMessageId).toBe('m4') // '밀려난 마지막까지 담았다고 기록한다'
+  expect(cap.seen[0]).toMatch(/말 1/) // '창의 첫 메시지가 요약에 들어간다'
+  expect(cap.seen[0]).toMatch(/말 4/)
+  expect(cap.seen[0]).not.toMatch(/말 5/) // '유지분은 원문으로 남으므로 요약에 넣지 않는다'
+  expect(cap.seen[0]).toMatch(/앞선 요약/) // '앞선 요약에 이어 붙인다 — 앞부분을 잃지 않는다'
+})
+
+it('전체를 읽어 왔으면 워터마크로 자른다 — 이미 담은 것을 두 번 담지 않는다', 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
+  })
+
+  expect(r.patch).toBeTruthy()
+  expect(r.patch!.summaryUpToMessageId).toBe('m9')
+  /* m5 는 이미 요약에 담겼다 — 두 번 담지 않는다. */
+  expect(cap.seen[0]).not.toMatch(/말 5(?!\d)/)
+  expect(cap.seen[0]).toMatch(/말 6/)
+  expect(cap.seen[0]).toMatch(/말 9/)
+})
+
+it('읽는 범위를 바꿔도 요약 대상은 같다 — 성능을 바꾼 것이 내용을 바꾸지 않는다', 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
+  })
+
+  expect(whole.seen[0]).toBe(windowed.seen[0]) // '요약에 들어가는 글이 글자까지 같다'
+  expect(a.patch).toEqual(b.patch) // '기록하는 워터마크도 같다'
+})
+
+it('워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리지 않는다', () => {
+  /* 삭제·편집으로 그 id 가 이력에 없을 수 있다. 그때 덮은 범위를 알 수 없으므로 전부 다시 본다. */
+  const { dropped } = splitByCap(rows(14), MAX_TURNS)
+  const pending = pendingForSummary(dropped, { text: '앞선 요약', upToMessageId: '지워진-id' })
+
+  expect(pending.length).toBe(dropped.length) // '전부 미반영'
+  expect(pending[0].id).toBe('m1')
+})
+
+it('창이 유지분보다 짧으면 접지 않는다 — 새로 밀려난 것이 없다', 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
+  })
+
+  expect(r.patch).toBe(null)
+  expect(r.skipped).toBe('nothing-dropped')
+  expect(cap.seen.length).toBe(0) // 'LLM 을 부르지 않는다'
+})
+
+it('밀려난 것이 임계치 미만이면 접지 않는다 — 매 턴 요약하지 않는다', 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
+  })
+
+  expect(r.skipped).toBe('below-threshold')
+  expect(cap.seen.length).toBe(0)
+})
+
+/*
+ * ★ 위 ① 을 **가르는** 자리.
+ *
+ * 앞의 「창으로 읽어 왔으면…」 시험은 워터마크 id 가 창에 없는 값이라(`m0-요약에-담긴-것`), 두 갈래가
+ * 같은 답을 낸다 — 워터마크가 안 보이면 전부 미반영으로 보는 규칙 ④ 때문이다. 그래서 창 갈래를 통째로
+ * 지워도 그 시험은 초록이었다(2026-09-18, 옮겨 온 뒤 결함을 심어 보고 알았다).
+ *
+ * 둘이 갈리는 것은 **워터마크 id 가 창 안에 보일 때**다. 그때 맞는 답은 창 쪽이다 — 창은 이미 요약
+ * 뒤부터이므로, 그 안에 같은 id 가 보여도 그것은 아직 요약에 안 담긴 말이다.
+ */
+it('★ 워터마크 id 가 창 안에 보여도 창은 워터마크로 자르지 않는다 — 여기서 두 갈래가 갈린다', async () => {
+  const cap = capturing()
+
+  const r = await foldHistorySummary({
+    rows: rows(9),
+    rowsStartAfterSummary: true,
+    stored: { text: '앞선 요약', upToMessageId: 'm2' },
+    maxTurns: MAX_TURNS,
+    threshold: THRESHOLD,
+    summarize: cap.summarize
+  })
+
+  expect(r.patch).toBeTruthy()
+  /* 창 갈래: m1..m4 가 전부 미반영이다. 전체 갈래였다면 m3..m4 만 담고 m1 · m2 를 잃는다. */
+  expect(cap.seen[0]).toMatch(/말 1/)
+  expect(cap.seen[0]).toMatch(/말 2/)
+})

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)')
+  })
+})

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

@@ -47,6 +47,13 @@ export interface HistoryRow {
   senderId?: string
   /** 프롬프트에 노출할 표시 이름. 이메일 같은 개인정보는 넣지 않는다. */
   senderName?: string
+  /**
+   * 누구에게 한 말인가 — `'assistant'` · `'room'`(ADR-0070 A15). 문이 저장한 값 그대로.
+   *
+   * 없는 행(이 칸이 생기기 전에 저장된 것)은 **모른다.** 모르는 것을 `room` 으로 적으면 그것이
+   * 지어낸 사실이다 — 그때는 대상 없이 발신자만 적는다.
+   */
+  addressee?: string
 }
 
 export interface BuildLlmHistoryOptions {
@@ -76,12 +83,17 @@ export interface BuildLlmHistoryOptions {
   summary?: StoredSummary
 }
 
-/** 사람이 아닌 기록(캔버스 직접 편집 등)의 표기. */
-const SYSTEM_LABEL = '시스템'
-/** 이름을 모르는 참여자의 표기 — 빈 대괄호를 남기지 않는다. */
-const UNKNOWN_LABEL = '참여자'
-/** 상한으로 잘라낸 앞부분을 알리는 표기 — 모델이 남은 첫 줄을 대화의 시작으로 오해하지 않게. */
-const OMITTED_LABEL = '시스템'
+/*
+ * These labels and notices are read by the model, so they are English. The reply the model writes is in the
+ * language the person used; that is the model's doing, not this file's. They were Korean, which made every
+ * conversation in this house speak Korean to the model whatever the reader's language was.
+ */
+/** Marks a record no person wrote (a direct canvas edit, for one). */
+const SYSTEM_LABEL = 'system'
+/** Marks a participant whose name we do not have — better than empty brackets. */
+const UNKNOWN_LABEL = 'participant'
+/** Marks the notice about messages the turn limit dropped, so the model does not read the first kept line as the start. */
+const OMITTED_LABEL = 'system'
 
 /**
  * 저장된 이력 → LLM 대화.
@@ -108,18 +120,16 @@ export function buildLlmHistory(rows: HistoryRow[], options: BuildLlmHistoryOpti
       /* 요약이 있으면 그것을 싣는다. **요약임을 밝힌다** — 모델이 원문처럼 인용하지 않게.
        * 요약이 밀려난 구간을 다 덮지 못하면 남은 개수도 함께 알린다(최신이 아님을 숨기지 않는다). */
       const uncovered = pendingForSummary(dropped, options.summary).length
-      const tail = uncovered
-        ? ` 그 뒤 ${uncovered}개 메시지는 요약에 아직 반영되지 않았습니다.`
-        : ''
+      const tail = uncovered ? ` ${uncovered} message(s) after it are not in the summary yet.` : ''
       out.push({
         role: 'user',
-        content: `[${OMITTED_LABEL}] 이 대화의 앞부분 ${dropped.length}개 메시지는 길이 제한으로 아래 요약으로 대체되었습니다(원문 아님 — 요약에 없는 사실은 사용자에게 확인하세요).${tail}\n${summaryText}`
+        content: `[${OMITTED_LABEL}] The first ${dropped.length} message(s) of this conversation were replaced by the summary below because of the length limit. It is a summary, not the original — ask the person about anything it does not say.${tail}\n${summaryText}`
       })
     } else {
       /* 요약이 아직 없으면 생략 사실만 알린다 — 개수만 밝히고 내용은 지어내지 않는다. */
       out.push({
         role: 'user',
-        content: `[${OMITTED_LABEL}] 이 대화의 앞부분 ${omitted}개 메시지는 길이 제한으로 생략되었습니다. 필요하면 사용자에게 다시 확인하세요.`
+        content: `[${OMITTED_LABEL}] The first ${omitted} message(s) of this conversation were left out because of the length limit. Ask the person again if you need them.`
       })
     }
   }
@@ -134,6 +144,15 @@ export function buildLlmHistory(rows: HistoryRow[], options: BuildLlmHistoryOpti
       out.push({ role: 'user', content: `[${SYSTEM_LABEL}] ${content}` })
       continue
     }
+    /*
+     * 사람의 말은 **누구에게 한 말인지까지** 적는다(ADR-0070 A15 결정 ②). 대상이 있을 때만 적으면
+     * 모델은 빈 자리에서 추론한다 — 옆 사람이 방에 한 말을 자기에게 온 지시로 읽는 것이 그 결과다.
+     */
+    const addressee = (row.addressee ?? '').trim()
+    if (addressee) {
+      out.push({ role: 'user', content: `[${speaker(row)} → ${addressee}] ${content}` })
+      continue
+    }
     out.push({ role: 'user', content: label ? `[${speaker(row)}] ${content}` : content })
   }
   return out

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

@@ -0,0 +1,87 @@
+/*
+ * ADR-0073 판정 1 — 답이 지난 문을 읽는 사람이 지나는가.
+ *
+ * 여기서 무는 것 넷: 문을 합치는가 · 모르는 도구가 가려지는 쪽으로 넘어지는가 · 한 요청에 한 번만
+ * 묻는가 · 가린 행에서 값 실린 칸이 함께 지워지는가.
+ */
+import { doorGate, doorsForAnswer, passesRow, redactByDoors } from './message-doors'
+
+const notice = (doors: string[]) => `needs ${doors.join(' + ')}`
+
+describe('message doors', () => {
+  it('★ 여러 도구를 부른 답은 그 문을 모두 지난 것으로 적힌다', () => {
+    const doorsOf = (name: string) =>
+      ({ getPlantOverview: ['Query.jobOrders', 'Query.productionReports'], findJobOrders: ['Query.jobOrders'] } as any)[name]
+
+    expect(doorsForAnswer(['getPlantOverview', 'findJobOrders'], doorsOf)).toEqual([
+      'Query.jobOrders',
+      'Query.productionReports'
+    ])
+  })
+
+  it('사람의 말과 문 없는 도구는 빈 목록이다 — 누구나 읽는다', () => {
+    expect(doorsForAnswer([], () => undefined)).toEqual([])
+    expect(doorsForAnswer(['getOpenScene'], () => [])).toEqual([])
+  })
+
+  it('★ 등록기가 모르는 도구는 아무도 못 지나는 자리로 적힌다', async () => {
+    const doors = doorsForAnswer(['whoIsThis'], () => undefined)
+    expect(doors).toEqual(['unresolved:whoIsThis'])
+
+    /* 통과 검사에 무엇을 넣어도 열리지 않는다. */
+    expect(await passesRow(doors, doorGate(async () => true))).toBe(false)
+  })
+
+  it('★ 같은 문은 한 요청에 한 번만 묻는다', async () => {
+    const asked: string[] = []
+    const gate = doorGate(async door => {
+      asked.push(door)
+      return true
+    })
+
+    const rows = Array.from({ length: 50 }, () => ({ doors: ['Query.jobOrders', 'Query.productionReports'] }))
+    await redactByDoors(rows, gate, notice)
+
+    expect(asked).toEqual(['Query.jobOrders', 'Query.productionReports'])
+  })
+
+  it('★ 문 하나라도 못 지나면 가린다 — 전부 지나야 한다(AND)', async () => {
+    const gate = doorGate(async door => door === 'Query.jobOrders')
+
+    const [row] = await redactByDoors(
+      [{ doors: ['Query.jobOrders', 'Query.productionReports'], content: '오늘 양품 1,204' }],
+      gate,
+      notice
+    )
+
+    expect(row.content).toBe('needs Query.jobOrders + Query.productionReports')
+    expect((row as any).redacted).toBe(true)
+  })
+
+  it('★ 가린 행에서는 값이 실린 칸도 함께 지워진다 — 본문만 지우면 그리로 샌다', async () => {
+    const [row] = await redactByDoors(
+      [
+        {
+          doors: ['Query.jobOrders'],
+          content: '오늘 양품 1,204',
+          extra: { rows: [{ good: 1204 }] },
+          proposals: [{ key: 'a', args: { jobOrder: 'JO-1' } }],
+          patchEntryId: 'patch-1'
+        }
+      ],
+      doorGate(async () => false),
+      notice
+    )
+
+    expect(row.extra).toBeNull()
+    expect(row.proposals).toBeNull()
+    expect(row.patchEntryId).toBeNull()
+  })
+
+  it('지나는 사람에게는 행이 손대지 않은 채로 간다', async () => {
+    const rows = [{ doors: ['Query.jobOrders'], content: '오늘 양품 1,204', extra: { good: 1204 } }]
+    const [row] = await redactByDoors(rows, doorGate(async () => true), notice)
+
+    expect(row).toBe(rows[0])
+  })
+})