@things-factory/ai-assistant 10.1.27 → 10.1.29

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,44 @@
+/*
+ * 읽는 사람의 관문 — ADR-0073 판정 1·2 를 요청 하나에 세운다.
+ *
+ * 리졸버는 이것을 한 번 만들고 행 목록을 통과시킨다. 문 판정은 (사람, 문) 별로 한 번만 일어나고,
+ * 세션이 private 인지도 여기서 함께 답한다. 리졸버마다 같은 판정을 다시 적으면 한 곳이 빠진 날
+ * 그 문으로 샌다.
+ */
+import { checkPermission, privilegeOfField } 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 { unsafeIP, prohibitedPrivileges } = context.state
+
+  const gate = doorGate(
+    /* 문에서 쓰는 판정을 그대로 쓴다 — 같은 인자, 같은 함수(ADR-0072 결정 5). */
+    doorCheck({
+      lookup: privilegeOfField,
+      permits: fieldGate => checkPermission(fieldGate as any, user, domain, unsafeIP, prohibitedPrivileges)
+    })
+  )
+
+  /*
+   * 문 이름(`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,56 @@ 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
 
+  /**
+   * 어느 대화인가 — `twin.board` · `figure.catalog` 같은 모드의 kind (ADR-0072 결정 3).
+   *
+   * **서버가 적는다.** 클라이언트가 보내는 값이 아니다 — 등록된 모드에서 나온 것만 적힌다(`addressee`
+   * 와 같은 결). 한 대상 위에 대화가 둘 설 수 있게 되면서(A17), 세션이 자기가 어느 대화인지 알아야
+   * 한다. 몰랐을 때 화면에서 이렇게 나왔다: 모드를 바꿔도 같은 세션이 그대로 남아, 「도형 찾기」로
+   * 바꾼 뒤 보낸 말이 앞의 고치기 대화에 붙었다(2026-09-18, Figure 레인 :3300).
+   *
+   * 값이 없는 세션은 이 칸이 서기 전에 난 것이다. 다음 턴에 요청한 kind 로 한 번 찍고, 찍힌 뒤에는
+   * 「요청한 모드와 다르면 거절」 하나만 남는다. 마이그레이션은 만들지 않는다.
+   */
+  @Column({ type: 'varchar', length: 64, nullable: true })
+  @Field({ nullable: true, description: "Which conversation this session is — the registered mode kind. Written by the server, never sent by the client." })
+  kind?: string
+
+  /**
+   * 이 대화를 도메인 안 누구나 읽는가 — 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-anchor.ts

@@ -101,8 +101,17 @@ export function anchorColumns(
  * 여기서도 앵커 이름을 검사한다 — 읽기 경로에서 틀린 이름은 오류가 아니라 **0 행**으로 나오고,
  * 화면은 「대화가 없다」로 그린다. 그 증상으로는 원인을 못 찾는다.
  */
-export function anchorWhere(domainId: string, anchorType: string, anchorId: string): any {
+/**
+ * 이 앵커의 세션을 찾는 조건 — `kind` 를 주면 **그 대화의** 세션만 본다(ADR-0072 결정 3).
+ *
+ * 한 대상 위에 대화가 둘 설 수 있게 되면서(A17), 앵커만으로 찾으면 저작 대화를 찾는 자리에서 운영
+ * 대화가 잡힌다. figure 에서 그것이 화면으로 나왔다 — 모드를 바꿨는데 같은 세션이 그대로 남아 새 말이
+ * 앞 대화에 붙었다(2026-09-18, Figure 레인 :3300).
+ *
+ * `kind` 를 안 주면 앵커의 대화를 모두 본다 — 목록처럼 대화를 가리지 않고 훑는 자리다.
+ */
+export function anchorWhere(domainId: string, anchorType: string, anchorId: string, kind?: string): any {
   const type = assertAnchorType(anchorType, 'anchorWhere')
-  if (type === 'board') return { boardId: anchorId, domain: { id: domainId } }
-  return { anchorType: type, anchorId, domain: { id: domainId } }
+  const where = type === 'board' ? { boardId: anchorId, domain: { id: domainId } } : { anchorType: type, anchorId, domain: { id: domainId } }
+  return kind ? { ...where, kind } : where
 }

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

@@ -19,11 +19,15 @@
 export interface InboxSessionRow {
   id?: string
   name?: string
+  /** 어느 대화인가 — 목록이 대화를 가리지 않으므로, 고른 뒤 화면이 따라갈 수 있게 함께 낸다. */
+  kind?: string
   anchorType?: string
   anchorId?: string
   boardId?: string
   lastMessageAt?: Date | string | null
   lastMessagePreview?: string | null
+  /** 그 미리보기가 지나온 문 — 목록도 같은 관문을 지난다. */
+  lastMessageDoors?: string[] | null
   createdAt?: Date | string | null
 }
 
@@ -137,9 +141,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-kind.test.ts

@@ -0,0 +1,24 @@
+/*
+ * ADR-0072 결정 3 — 세션이 자기 대화를 알고, 다른 대화의 말을 받지 않는다.
+ */
+import { judgeSessionKind } from './session-kind'
+
+describe('session kind', () => {
+  it('같은 대화면 그대로 간다', () => {
+    expect(judgeSessionKind('figure.modeller', 'figure.modeller')).toEqual({ action: 'proceed' })
+  })
+
+  it('★ 칸이 서기 전 세션은 요청한 대화로 한 번 찍는다 — 마이그레이션을 만들지 않는다', () => {
+    expect(judgeSessionKind(null, 'figure.catalog')).toEqual({ action: 'stamp', kind: 'figure.catalog' })
+    expect(judgeSessionKind('', 'figure.catalog')).toEqual({ action: 'stamp', kind: 'figure.catalog' })
+    expect(judgeSessionKind('   ', 'figure.catalog')).toEqual({ action: 'stamp', kind: 'figure.catalog' })
+  })
+
+  it('★ 다른 대화의 세션은 거절한다 — 조용히 섞으면 그 이력이 남의 프롬프트로 들어간다', () => {
+    expect(judgeSessionKind('figure.modeller', 'figure.catalog')).toEqual({
+      action: 'refuse',
+      errorCode: 'session-kind-mismatch',
+      params: { sessionKind: 'figure.modeller', requested: 'figure.catalog' }
+    })
+  })
+})

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

@@ -0,0 +1,32 @@
+/*
+ * 이 세션이 어느 대화인가 — ADR-0072 결정 3.
+ *
+ * 한 대상 위에 대화가 둘 설 수 있게 되면서(A17), 세션이 자기가 어느 대화인지 알아야 한다. 모르면 모드를
+ * 바꿔도 같은 세션이 그대로 남고, 새 말이 앞 대화에 붙는다 — 화면에서는 줄이 사라져 새 대화처럼 보이니
+ * 보낸 사람은 그것을 알 수 없다. 새로 고쳐야 드러난다(2026-09-18, Figure 레인 :3300).
+ *
+ * 답은 셋이다.
+ *   `proceed`  세션의 대화와 요청한 대화가 같다.
+ *   `stamp`    칸이 서기 전에 난 세션이다 — 요청한 대화로 한 번 찍고 진행한다. 찍힌 뒤에는 아래 하나만
+ *              남는다. 마이그레이션은 만들지 않는다.
+ *   `refuse`   다른 대화의 세션이다. **조용히 섞지 않는다** — 섞으면 그 대화의 이력이 다른 대화의
+ *              프롬프트로 들어가고, 읽는 사람은 자기가 무엇에 답하고 있는지 모른다.
+ */
+
+export type SessionKindVerdict =
+  | { action: 'proceed' }
+  | { action: 'stamp'; kind: string }
+  | { action: 'refuse'; errorCode: 'session-kind-mismatch'; params: { sessionKind: string; requested: string } }
+
+export function judgeSessionKind(sessionKind: string | null | undefined, requested: string): SessionKindVerdict {
+  const stored = (sessionKind ?? '').trim()
+
+  if (!stored) return { action: 'stamp', kind: requested }
+  if (stored === requested) return { action: 'proceed' }
+
+  return {
+    action: 'refuse',
+    errorCode: 'session-kind-mismatch',
+    params: { sessionKind: stored, requested }
+  }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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)
+  })
+})
+
+/*
+ * ADR-0073 결정 2 — 대상 없는 개인 질문은 공개 방으로 태어나지 않는다.
+ *
+ * `'none'` 은 저장되는 앵커 종류 목록에 든 글자다(대상이 없다는 것도 행에 적어야 하므로). 「값이 있으면
+ * 앵커가 있다」로 읽으면 그 글자가 앵커 노릇을 하고, `twin.none` 대화가 도메인 안 누구에게나 열린다.
+ */
+describe("'none' is not an anchor", () => {
+  it('★ 대상 없는 대화는 비공개로 시작한다 — 앵커 종류 목록에 그 글자가 있어도', () => {
+    expect(initialVisibility({ anchorType: 'none' })).toBe('private')
+  })
+
+  it('대상이 있는 대화는 그대로 공개다', () => {
+    expect(initialVisibility({ anchorType: 'space' })).toBe('open')
+  })
+})

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

@@ -0,0 +1,34 @@
+/*
+ * 새 대화가 공개로 태어나는가 — 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'
+
+  /*
+   * `'none'` 은 **앵커가 아니다.** 저장되는 앵커 종류 목록에 그 글자가 들어 있어서(`session-anchor.ts`
+   * — 대상이 없다는 것도 행에 적어야 하므로), 「값이 있으면 앵커가 있다」로 읽으면 대상 없는 개인 질문이
+   * 공개 방으로 태어난다. ADR-0073 결정 2 가 그것을 `private` 로 못박았다 — 「앵커 없는 세션(`twin.none`
+   * 같은 개인 질문)」.
+   */
+  const anchored = !!session.anchorType && session.anchorType !== 'none'
+  return anchored ? '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
+  )
 }