@things-factory/ai-assistant 10.1.26 → 10.1.28

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

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

@@ -0,0 +1,117 @@
+/*
+ * 답에 실린 문 — ADR-0073 판정 1.
+ *
+ * ── 무엇을 막는가 ─────────────────────────────────────────────────────────
+ * 대화방은 도메인 안에서 공개다(ADR-0073 판정 2). 그런데 대화 안에는 어시스턴트가 도구 결과로 근거를
+ * 대고 쓴 답이 들어 있고, 그 근거는 **부른 사람의 문**을 지나 얻은 값이다. 도구는 문을 지켰는데
+ * 어시스턴트의 문장이 그 값을 이미 평문으로 적어 놓았다. 나중에 읽는 사람은 자기가 못 여는 문 너머의
+ * 값을 어시스턴트의 말로 읽는다 — 도구 권한을 다 지켜도 **글로 새는 길**이다.
+ *
+ * 그래서 답 행에 그 답을 만든 도구들이 지난 문 목록을 적어 두고(사람의 말은 `[]`), 읽는 사람이 그 문을
+ * 전부 지나는지 볼 때마다 확인한다. 못 지나면 본문 대신 한 줄이 나간다 — **행이 있다는 사실은 보이고
+ * 값만 안 보인다.** 방에 무슨 일이 있었는지는 알 수 있고, 값은 자기 권한만큼만 읽는다.
+ *
+ * ── 시점은 뜻이 없다 ──────────────────────────────────────────────────────
+ * 언제 들어왔는지로 가르지 않는다. 오전에 있었든 방금 들어왔든, 볼 수 있는 것은 본다. 권한이 나중에
+ * 붙으면 그때부터 보이고, 떨어지면 그때부터 안 보인다. 저장된 행은 그대로 있고 **보는 일만** 달라진다.
+ *
+ * ── 모델이 읽는 이력도 같다 ───────────────────────────────────────────────
+ * 부른 사람이 못 여는 문의 답은 모델에게도 가리고 보낸다. 가리지 않으면 모델이 그 값을 다음 답에 옮겨
+ * 적어서, 문을 한 번도 안 지난 사람이 값을 갖게 된다. 가린 자리를 지우지 않고 한 줄로 남기는 이유도
+ * 같다 — 모델이 "그런 말 한 적 없다"고 답하면 그것은 거짓말이다.
+ *
+ * 이 파일은 저장소·엔티티를 모르는 순수 판정이다.
+ */
+
+/** 문 이름으로 보이지 않는 값 — 등록되지 않은 도구가 답에 끼었을 때. */
+const UNRESOLVED = 'unresolved:'
+
+/**
+ * 이 답이 지난 문들 — 부른 도구들의 문을 합친다(중복 없이, 정렬).
+ *
+ * 등록기에 없는 도구가 답에 끼면 그 도구가 무엇을 읽었는지 알 길이 없다. 그때 `[]`(누구나 읽는 답)로
+ * 적으면 모르는 값이 공개된다. 아무도 못 지나는 이름을 적어 **가려지는 쪽**으로 넘어뜨리고, 이름에
+ * 원인을 실어 둔다.
+ */
+export function doorsForAnswer(toolNames: readonly string[], doorsOf: (name: string) => string[] | undefined): string[] {
+  const doors = new Set<string>()
+
+  for (const name of toolNames) {
+    const declared = doorsOf(name)
+    if (declared === undefined) doors.add(`${UNRESOLVED}${name}`)
+    else for (const door of declared) doors.add(door)
+  }
+
+  return [...doors].sort()
+}
+
+/**
+ * 한 요청 안에서 (사람, 문) 별로 한 번만 묻는 관문.
+ *
+ * 한 화면이 백 줄을 읽고 그 줄들이 같은 문 서넛을 가리킨다. 줄마다 물으면 권한 조회가 백 번 간다.
+ * 같은 요청 안에서 답이 바뀔 일은 없으므로 문 하나에 한 번 묻고 그 답을 쓴다. 관문은 요청마다 새로
+ * 만든다 — 프로세스가 들고 있으면 권한이 바뀌어도 낡은 답을 준다.
+ */
+export function doorGate(check: (door: string) => Promise<boolean>): (door: string) => Promise<boolean> {
+  const asked = new Map<string, Promise<boolean>>()
+
+  return (door: string) => {
+    /* 등록되지 않은 도구의 자리는 물을 것도 없다 — 지나는 사람이 없다. */
+    if (door.startsWith(UNRESOLVED)) return Promise.resolve(false)
+
+    let answer = asked.get(door)
+    if (!answer) {
+      answer = check(door)
+      asked.set(door, answer)
+    }
+    return answer
+  }
+}
+
+/** 이 사람이 이 행을 열 수 있나 — 적힌 문을 **전부** 지나야 한다(AND). */
+export async function passesRow(doors: readonly string[] | null | undefined, gate: (door: string) => Promise<boolean>): Promise<boolean> {
+  for (const door of doors ?? []) {
+    if (!(await gate(door))) return false
+  }
+  return true
+}
+
+/** 문 판정에 필요한 만큼만 — 엔티티를 이 자리로 끌고 오지 않는다. */
+export interface DoorReadableRow {
+  doors?: string[] | null
+  content?: string | null
+}
+
+/** 가린 행에서 값이 실려 있는 칸들 — 본문만 지우고 두면 그리로 새어 나간다. */
+const VALUE_CARRYING = ['extra', 'proposals', 'grounding', 'patchEntryId', 'importSessionId'] as const
+
+/**
+ * 못 지나는 행의 값을 가린다 — 행은 남기고 본문을 한 줄로 바꾼다.
+ *
+ * `notice` 는 부르는 쪽이 번역해 넘긴다(서버 번역, 화면 말은 서버가 만든다 — ADR-0061 결정 7).
+ */
+export async function redactByDoors<T extends DoorReadableRow>(
+  rows: readonly T[],
+  gate: (door: string) => Promise<boolean>,
+  notice: (doors: string[]) => string
+): Promise<T[]> {
+  const out: T[] = []
+
+  for (const row of rows) {
+    const doors = row.doors ?? []
+    if (doors.length === 0 || (await passesRow(doors, gate))) {
+      out.push(row)
+      continue
+    }
+
+    const hidden: any = { ...row, content: notice(doors) }
+    for (const field of VALUE_CARRYING) {
+      if (field in hidden) hidden[field] = null
+    }
+    /* 가려졌다는 것 자체는 사실이다. 화면이 자물쇠를 그릴 수 있게 남긴다. */
+    hidden.redacted = true
+    out.push(hidden)
+  }
+
+  return out
+}

package/server/service/chat-message/proposal-outcome.test.ts

@@ -0,0 +1,48 @@
+/*
+ * What this guards: the line the server writes is the line the panel reads.
+ *
+ * Two files hold the shape — one writes it into the conversation, one reads it back for the card.
+ * They are tested together here, so a change to either breaks a test instead of quietly leaving
+ * cards in "sending" forever.
+ *
+ * The test lives on the server side on purpose: the client build compiles everything under
+ * `client/`, so a client test importing the server would pull the server into the browser build's
+ * root and move every emitted path (`dist-client/client/…`). The server build excludes tests, so
+ * reaching the other way costs nothing.
+ */
+import { formatProposalOutcomeLine, PROPOSAL_VERDICTS } from './proposal-outcome'
+import { parseProposalOutcomeLine } from '../../../client/components/proposal-outcome-line'
+
+const key = 'proposeSceneEdit|{"kind":"scene-edit"}'
+
+it('★ every verdict survives the round trip', () => {
+  for (const verdict of PROPOSAL_VERDICTS) {
+    const line = formatProposalOutcomeLine(key, { verdict })
+    expect(parseProposalOutcomeLine(line)).toEqual({ key, verdict, errorCode: undefined, applied: undefined, total: undefined })
+  }
+})
+
+it('★ the reason code comes back exactly as the host gave it', () => {
+  const line = formatProposalOutcomeLine(key, { verdict: 'refused', errorCode: 'unknown-tag' })
+
+  expect(parseProposalOutcomeLine(line)?.errorCode).toBe('unknown-tag')
+})
+
+it('★ counts come back as "how many of how many"', () => {
+  const line = formatProposalOutcomeLine(key, { verdict: 'accepted', applied: 2, missed: 1 })
+
+  expect(parseProposalOutcomeLine(line)).toMatchObject({ verdict: 'accepted', applied: 2, total: 3 })
+})
+
+it('★ another system row is not read as an outcome — no guessing', () => {
+  expect(parseProposalOutcomeLine('User directly edited the board: moved EQ-1')).toBeUndefined()
+  expect(parseProposalOutcomeLine('proposal something without a verdict')).toBeUndefined()
+  expect(parseProposalOutcomeLine('')).toBeUndefined()
+})
+
+it('a key containing colons and spaces still parses', () => {
+  const awkward = 'proposeAction|stop|EQ-1|{"note":"a: b"}'
+  const line = formatProposalOutcomeLine(awkward, { verdict: 'accepted' })
+
+  expect(parseProposalOutcomeLine(line)?.key).toBe(awkward)
+})

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

@@ -0,0 +1,42 @@
+/*
+ * What the host did with a proposal, written into the conversation (ADR-0070 A12-a).
+ *
+ * The card used to change to "executed" the moment it was pressed, which is the one thing it knew
+ * and the one thing that is not the answer. The host's answer comes back through a server door and
+ * is stored as a `system` row, so three readers get it from the same place: the card that is open,
+ * the card after a refresh, and the model on its next turn — a model that is not told its proposal
+ * was refused goes on as though it had been applied.
+ *
+ * The line is the row's content. It is parsed back by the panel, so the shape is fixed here and the
+ * panel's parser is tested against this formatter.
+ */
+
+/** ADR-0042's verdicts, plus the one for a person who backed out at the confirm step. */
+export type ProposalVerdict = 'accepted' | 'refused' | 'unavailable' | 'declined'
+
+export interface ProposalOutcome {
+  verdict: ProposalVerdict
+  /** The host's own reason code, carried through untouched — no mapping table (ADR-0042). */
+  errorCode?: string
+  /** For a proposal made of several edits: how many went in, and how many did not. */
+  applied?: number
+  missed?: number
+}
+
+export const PROPOSAL_OUTCOME_PREFIX = 'proposal '
+
+export const PROPOSAL_VERDICTS: ProposalVerdict[] = ['accepted', 'refused', 'unavailable', 'declined']
+
+/**
+ * `proposal <key>: <verdict> (<errorCode>) 2/3`
+ *
+ * English, like the other lines the model reads. The panel turns it into the reader's language.
+ */
+export function formatProposalOutcomeLine(key: string, outcome: ProposalOutcome): string {
+  const reason = outcome.errorCode ? ` (${outcome.errorCode})` : ''
+  const counted =
+    typeof outcome.applied === 'number' || typeof outcome.missed === 'number'
+      ? ` ${outcome.applied ?? 0}/${(outcome.applied ?? 0) + (outcome.missed ?? 0)}`
+      : ''
+  return `${PROPOSAL_OUTCOME_PREFIX}${key}: ${outcome.verdict}${reason}${counted}`
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 읽는 사람의 관문 — ADR-0073 판정 1·2 를 요청 하나에 세운다.
+ *
+ * 리졸버는 이것을 한 번 만들고 행 목록을 통과시킨다. 문 판정은 (사람, 문) 별로 한 번만 일어나고,
+ * 세션이 private 인지도 여기서 함께 답한다. 리졸버마다 같은 판정을 다시 적으면 한 곳이 빠진 날
+ * 그 문으로 샌다.
+ */
+import { getAllToolSpecs } from '@things-factory/ai-client-base'
+import { User } from '@things-factory/auth-base'
+
+import { doorCheck } from './door-access.js'
+import { doorGate, redactByDoors, type DoorReadableRow } from './message-doors.js'
+import { requestTranslator } from '../request-translator.js'
+
+/** 이 요청에서 행을 가려 내보내는 함수. 같은 요청 안에서 계속 쓴다. */
+export function readerGate(context: any): <T extends DoorReadableRow>(rows: readonly T[]) => Promise<T[]> {
+  const { domain, user } = context.state
+  const t = requestTranslator(context)
+
+  const gate = doorGate(
+    doorCheck({
+      specs: getAllToolSpecs(),
+      hasPrivilege: privilege => User.hasPrivilege(privilege.privilege, privilege.category, domain, user)
+    })
+  )
+
+  /*
+   * 문 이름(`Query.productionReports`)은 이 문장에 넣지 않는다.
+   *
+   * 현장에서 읽는 사람에게 GraphQL 이름은 아무 말도 아니다. 문 이름을 사람의 말로 바꿀 표는 AUTH 의
+   * 필드→권한 표와 같은 자리에서 나와야 하고, 그것은 아직 없다(ADR-0072 결정 2 (b)). 없는 표를 흉내
+   * 내느니 문장은 사실만 말하고, 목록은 `ChatMessage.doors` 로 따로 나간다 — 관리자에게 무엇을
+   * 청할지 알아야 하는 화면은 거기서 읽는다. 문구는 UX 레인이 정한다.
+   */
+  return rows =>
+    redactByDoors(rows, gate, () =>
+      t('ai-assistant.text.answer-needs-permission', {
+        /* 구독에는 요청 번역기가 없다 — `request-translator.ts` 참조. */
+        defaultValue: 'you do not have permission to see this answer. ask an administrator for access.'
+      })
+    )
+}

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

@@ -0,0 +1,21 @@
+/*
+ * What this guards: the people's door keeps what was said, and refuses what was not.
+ *
+ * An empty turn stored as a message is a blank line in a shared conversation and a blank line in
+ * what the model reads — both mean "someone said something" when nobody did.
+ */
+import { ROOM_MESSAGE_LIMIT, roomMessageBody } from './room-message'
+
+it('keeps what was said, without the whitespace around it', () => {
+  expect(roomMessageBody('  3 라인이 멈춘 것 같아요  ')).toBe('3 라인이 멈춘 것 같아요')
+})
+
+it('★ an empty turn is nothing to store', () => {
+  expect(roomMessageBody('   ')).toBeUndefined()
+  expect(roomMessageBody('')).toBeUndefined()
+  expect(roomMessageBody(undefined)).toBeUndefined()
+})
+
+it('a very long turn is capped — this is a conversation, not an archive', () => {
+  expect(roomMessageBody('가'.repeat(ROOM_MESSAGE_LIMIT + 100))?.length).toBe(ROOM_MESSAGE_LIMIT)
+})

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

@@ -0,0 +1,22 @@
+/*
+ * A person saying something to the room (ADR-0070 A15).
+ *
+ * The addressee column has two values and, until this door, a screen could only produce one of
+ * them: every turn a person typed went through `assistantChat`, which means every turn was for the
+ * assistant. `room` existed only on turns carried in from somewhere else. So the half of the design
+ * that says "people also talk to each other here, and the assistant reads it as context" had no way
+ * to happen.
+ *
+ * The rule the door follows is the same one: the addressee comes from **which door was called**,
+ * never from an argument. This one is the people's door — it stores the turn and does not call the
+ * model. Nobody is answered, and that silence is the point (A15 decision ⑦).
+ */
+
+/** How much of one turn is kept — the same cap the carried turns use. */
+export const ROOM_MESSAGE_LIMIT = 4000
+
+/** Trimmed and capped, or nothing when there is no message. */
+export function roomMessageBody(content: string | undefined | null): string | undefined {
+  const body = (content ?? '').trim().slice(0, ROOM_MESSAGE_LIMIT)
+  return body || undefined
+}

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

@@ -43,7 +43,7 @@ const DATABASE_TYPE = ORMCONFIG.type
 // 앵커 조회용 — chatSessionsByAnchor 가 [domain, anchorType, anchorId] 로 질의.
 @Index('ix_chat_session_2', (session: ChatSession) => [session.domain, session.anchorType, session.anchorId])
 @ObjectType({
-  description: 'AI 협력 세션 — Board 와 결합. 한 보드에 여러 세션 가능 (thread / 사용자별 / 컨텍스트별 등 미래 확장).'
+  description: 'One AI conversation, anchored to what it is about. An anchor may have several — threads, one per person, one per context.'
 })
 export class ChatSession {
   @PrimaryGeneratedColumn('uuid')
@@ -125,11 +125,41 @@ export class ChatSession {
   @Field({ nullable: true, description: 'Timestamp of the last message in this session (denormalized for list ordering and unread comparison — avoids per-session aggregation across the supported DB drivers).' })
   lastMessageAt?: Date
 
+  /**
+   * 이 대화를 도메인 안 누구나 읽는가 — ADR-0073 판정 2.
+   *
+   *   `open`     도메인 안이면 누구나 들어와 읽고 말한다. 초대 절차는 없다.
+   *   `private`  참여자만 읽는다.
+   *
+   * 앵커가 있는 세션(space · board · station)은 공유된 무엇을 놓고 하는 이야기이므로 `open` 으로
+   * 시작한다. 앵커가 없는 세션과 **옮겨 적어 만든 세션**은 `private` 으로 시작한다 — 가벼운 질문을
+   * 승격하면서 앞선 대화가 새 세션에 옮겨 적히는데(`appendSessionTurns`), 그것이 공개로 태어나면
+   * 사적으로 오간 원문이 소급해서 공개된다.
+   *
+   * owner 가 양방향으로 바꿀 수 있다. 공개로 바꾸기 전에 화면이 한 줄을 먼저 보인다.
+   *
+   * open 이어도 답 행의 문 판정(ADR-0073 판정 1)은 그대로다 — 방에 들어온 것과 값을 읽는 것은 다르다.
+   */
+  @Column({ type: 'varchar', length: 16, default: 'open' })
+  @Field({ description: "Who may read this conversation: 'open' (anyone in the domain) or 'private' (participants only)." })
+  visibility!: string
+
   /** 목록에 보여줄 마지막 메시지 미리보기 — 목록에서 메시지 테이블을 다시 읽지 않기 위해 짧게 저장. */
   @Column({ nullable: true, length: 200 })
   @Field({ nullable: true, description: 'Short preview of the last message, stored so the session list does not need to query messages.' })
   lastMessagePreview?: string
 
+  /**
+   * 그 미리보기가 지나온 문 — ADR-0073 판정 1.
+   *
+   * 목록은 답을 **다시 읽는 두 번째 길**이다. 메시지 화면에서만 가리면 같은 문장이 목록에 그대로 뜬다.
+   * 문이 둘이고 한쪽이 느슨하면 느슨한 쪽이 이긴다(ADR-0061 결정 1). 미리보기를 저장할 때 그 행의 문을
+   * 함께 옮겨 적고, 목록도 같은 관문을 지난다.
+   */
+  @Column({ type: 'simple-array', nullable: true })
+  @Field(() => [String], { nullable: true, description: 'Doors of the message the preview came from — the session list passes the same gate as the conversation.' })
+  lastMessageDoors?: string[]
+
   @Column({
     nullable: true,
     type:

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

@@ -183,3 +183,21 @@ describe('searchInbox — 대량 목록의 풀텍스트 필터', () => {
     expect(searchInbox(rows, 'zzz')).toEqual([])
   })
 })
+
+/*
+ * ADR-0073 판정 1 — 목록 미리보기도 같은 관문을 지나야 한다.
+ *
+ * 대화 화면에서만 가리면 같은 문장이 목록에 그대로 뜬다. 문이 둘이고 한쪽이 느슨하면 느슨한 쪽이 이긴다.
+ */
+describe('preview carries its doors', () => {
+  it('★ 미리보기를 적을 때 그 답이 지나온 문도 함께 적는다', () => {
+    const patch = activityPatch('오늘 양품 1,204', new Date('2026-09-18T00:00:00Z'), ['Query.productionReports'])
+
+    expect(patch.lastMessageDoors).toEqual(['Query.productionReports'])
+    expect(patch.lastMessagePreview).toBe('오늘 양품 1,204')
+  })
+
+  it('사람의 말에는 문이 없다 — 빈 목록이면 누구나 본다', () => {
+    expect(activityPatch('이것 좀 봐줘').lastMessageDoors).toEqual([])
+  })
+})

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

@@ -24,6 +24,8 @@ export interface InboxSessionRow {
   boardId?: string
   lastMessageAt?: Date | string | null
   lastMessagePreview?: string | null
+  /** 그 미리보기가 지나온 문 — 목록도 같은 관문을 지난다. */
+  lastMessageDoors?: string[] | null
   createdAt?: Date | string | null
 }
 
@@ -137,9 +139,14 @@ export function countUnreadSessions(entries: InboxEntry[]): number {
  * 메시지 저장 시 세션에 반영할 활동 값. 미리보기는 짧게 자르고 개행을 없앤다
  * (목록 한 줄에 들어가야 하고, 컬럼 길이 제한이 있다).
  */
-export function activityPatch(content: string, at: Date = new Date()): { lastMessageAt: Date; lastMessagePreview: string } {
+export function activityPatch(
+  content: string,
+  at: Date = new Date(),
+  doors: string[] = []
+): { lastMessageAt: Date; lastMessagePreview: string; lastMessageDoors: string[] } {
   const flat = (content ?? '').replace(/\s+/g, ' ').trim()
-  return { lastMessageAt: at, lastMessagePreview: flat.slice(0, 200) }
+  /* 미리보기가 어느 문을 지나온 값인지 함께 적는다 — 목록도 같은 관문을 지난다(ADR-0073 판정 1). */
+  return { lastMessageAt: at, lastMessagePreview: flat.slice(0, 200), lastMessageDoors: doors }
 }
 
 /**

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

@@ -0,0 +1,36 @@
+/*
+ * ADR-0073 판정 2 — 새 대화가 공개로 태어나는가, 비공개는 누가 읽는가.
+ *
+ * 옮겨 적어 만든 세션이 공개로 태어나면 사적으로 오간 원문이 소급해서 공개된다. 그 한 줄을 여기서 문다.
+ */
+import { initialVisibility, mayReadSession } from './session-visibility'
+
+describe('session visibility', () => {
+  it('앵커가 있는 대화는 공개로 시작한다 — 공유된 대상을 놓고 하는 이야기다', () => {
+    expect(initialVisibility({ anchorType: 'space' })).toBe('open')
+    expect(initialVisibility({ anchorType: 'board' })).toBe('open')
+    expect(initialVisibility({ anchorType: 'station' })).toBe('open')
+  })
+
+  it('★ 옮겨 적어 만든 대화는 비공개로 시작한다 — 원문이 소급 공개되지 않는다', () => {
+    expect(initialVisibility({ anchorType: 'board', copyOf: 'session-1' })).toBe('private')
+  })
+
+  it('앵커 없는 대화는 비공개로 시작한다', () => {
+    expect(initialVisibility({})).toBe('private')
+    expect(initialVisibility({ anchorType: null })).toBe('private')
+  })
+
+  it('★ 비공개 대화는 참여자만 읽는다', () => {
+    expect(mayReadSession('private', false)).toBe(false)
+    expect(mayReadSession('private', true)).toBe(true)
+  })
+
+  it('공개 대화는 참여자가 아니어도 읽는다 — 초대 절차가 없다', () => {
+    expect(mayReadSession('open', false)).toBe(true)
+  })
+
+  it('값이 없는 옛 행은 공개로 읽는다 — 오늘까지 도메인만 보고 있었다', () => {
+    expect(mayReadSession(undefined, false)).toBe(true)
+  })
+})

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

@@ -0,0 +1,26 @@
+/*
+ * 새 대화가 공개로 태어나는가 — ADR-0073 판정 2.
+ *
+ * 판정을 세션을 만드는 자리마다 적으면 한 곳이 빠진 날 그 세션만 다른 규칙으로 산다. 한 줄로 모은다.
+ */
+
+export type SessionVisibility = 'open' | 'private'
+
+export const SESSION_VISIBILITIES: readonly SessionVisibility[] = ['open', 'private']
+
+/**
+ * 이렇게 만들어진 세션은 무엇으로 시작하나.
+ *
+ * 앵커가 있으면 공유된 대상을 놓고 하는 이야기다 — 공개. 앵커가 없거나 앞선 대화를 옮겨 적어 만든
+ * 것이면 비공개. `copyOf` 가 있다는 것은 다른 대화의 원문이 이 안에 들어왔다는 뜻이고, 그 원문은
+ * 자기가 있던 자리의 규칙으로 쓰였다.
+ */
+export function initialVisibility(session: { anchorType?: string | null; copyOf?: string | null }): SessionVisibility {
+  if (session.copyOf) return 'private'
+  return session.anchorType ? 'open' : 'private'
+}
+
+/** 이 사람이 이 대화를 읽을 수 있나. open 이면 도메인 안 누구나, private 이면 참여자만. */
+export function mayReadSession(visibility: string | null | undefined, isParticipant: boolean): boolean {
+  return (visibility ?? 'open') === 'open' || isParticipant
+}

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

@@ -2,9 +2,13 @@
  * This is a consistency check, not authorization; tenant/privilege checks stay in the resolver.
  * Older Board sessions have only boardId, so preserve that supported read shape.
  */
+const STATION_MISMATCH = 'this conversation belongs to another station screen. open the conversation of the screen you are on.'
+
 export function assertStationSession(
   session: {anchorType?:string|null;anchorId?:string|null;boardId?:string|null}|undefined,
-  host: {surface?:string;boardId?:unknown}|undefined
+  host: {surface?:string;boardId?:unknown}|undefined,
+  /* The reader's sentence comes from the request (ADR-0054); without a translator it falls back to English. */
+  t?: (key: string, params?: Record<string, any>) => string
 ) {
   if(host?.surface!=='station-screen-modeller')return
   const boardId=host.boardId
@@ -13,5 +17,9 @@ export function assertStationSession(
     (session.anchorType==='board'||legacy)&&
     (session.anchorId||session.boardId)===boardId&&
     (!session.boardId||session.boardId===boardId)
-  if(!valid)throw new Error('현재 Station Screen과 대화 이력이 일치하지 않습니다. 해당 화면의 대화를 다시 여세요.')
+  if(!valid)throw new Error(
+    t
+      ? t('ai-assistant.text.other-station-history', { defaultValue: STATION_MISMATCH })
+      : STATION_MISMATCH
+  )
 }