@things-factory/ai-assistant 10.1.207 → 10.1.210

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

@@ -144,7 +144,8 @@ export class ChatSession {
    * 이 대화를 도메인 안 누구나 읽는가 — ADR-0073 판정 2.
    *
    *   `open`     도메인 안이면 누구나 들어와 읽고 말한다. 초대 절차는 없다.
-   *   `private`  참여자만 읽는다.
+   *   `group`    owner 가 들인 사람과 owner 만 읽고 말한다(2026-10-24, ADR-0073 결정 3).
+   *   `private`  owner 혼자. 아무도 앉히지 않고, 그룹을 비공개로 바꾸면 들인 사람이 나간다.
    *
    * 새 세션은 **모두** `private` 으로 시작한다(2026-09-30 — `initialVisibility`). 앵커는 무엇에 대한
    * 이야기인지를 말할 뿐 누구에게 보이는지를 정하지 않는다. 칸의 기본값 `open` 은 칸이 서기 전의 옛 행을
@@ -156,7 +157,7 @@ export class ChatSession {
    * 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)." })
+  @Field({ description: "Who may read this conversation: 'open' (anyone in the domain), 'group' (the owner and the people the owner brought in) or 'private' (the owner alone)." })
   visibility!: string
 
   /** 목록에 보여줄 마지막 메시지 미리보기 — 목록에서 메시지 테이블을 다시 읽지 않기 위해 짧게 저장. */

package/server/service/chat-session/group-room.test.ts

@@ -0,0 +1,233 @@
+/*
+ * A group conversation (ADR-0073 decision 3, 2026-10-24) - through the doors themselves, on sqlite.
+ *
+ * The owner brings people in; only they and the owner read, write, see the roster, hear the room and press a
+ * card there. Everyone else in the domain is refused at every one of those doors - asked for the room by its
+ * id, which is how a person outside it would try. A member's mention tells, it does not seat. Private is the
+ * owner's alone: turning a group private sends its members out.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+
+/* The resolvers and entities are type-graphql classes and need tsc's decorator metadata - the compiled modules are read. */
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', 'service', `${modulePath}.js`)
+  if (!existsSync(resolved)) throw new Error(`ai-assistant has no build output: ${resolved}\nBuild first:\n  yarn workspace @things-factory/ai-assistant build:server`)
+  return require(resolved)
+}
+const { ChatSession } = loadCompiled('chat-session/chat-session')
+const { ChatMessage } = loadCompiled('chat-message/chat-message')
+const { ChatSessionParticipant } = loadCompiled('chat-session-participant/chat-session-participant')
+const { ChatSessionResolver } = loadCompiled('chat-session-resolver')
+const { EntryProposalResolver } = loadCompiled('data-entry/entry-resolver')
+const { chatRoomLookup } = loadCompiled('chat-message/chat-message-room')
+const { mayHearRoom } = loadCompiled('chat-message/chat-message-broadcast')
+const { declareEntryTarget, clearEntryTargets } = loadCompiled('data-entry/entry-target')
+
+let db: DataSource
+let domain: any
+let owner: any
+let guest: any
+let outsider: any
+let notices: any[]
+/** Whose request state the application's mutation ran with, one id per row entered. */
+let enteredAs: string[]
+
+const doors = new ChatSessionResolver()
+const entry = new EntryProposalResolver()
+
+/** A request as that person - the state a door reads. `notify` keeps what an invite sends. */
+const as = (user: any) => ({ state: { domain, user, notify: async (payload: any) => notices.push(payload) } }) as any
+
+beforeAll(async () => {
+  db = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ChatSession, ChatMessage, ChatSessionParticipant],
+    logging: false
+  })
+  await db.initialize()
+  shell.addDataSource('default', db)
+  domain = await db.getRepository(shell.Domain).save({ name: 'acme', subdomain: 'acme' })
+  const person = (name: string) =>
+    db.getRepository(authBase.User).save({ name, username: name, email: `${name}@example.com`, status: 'activated', domains: [domain] })
+  /* A card's target: the application's own mutation, entered through the local client as the person who pressed. */
+  process['PRIVILEGE_OF_FIELD']['Mutation.addNote'] = null
+  declareEntryTarget({
+    key: 'test.note',
+    labelKey: 'label.note',
+    description: 'A note.',
+    fields: [{ name: 'title', type: 'text', required: true }],
+    mutation: 'mutation ($title: String!) { addNote(title: $title) { id } }',
+    variables: (row: any) => ({ title: row.values.title }),
+    appliedOf: (data: any) => ({ id: data?.addNote?.id })
+  })
+  shell.GraphqlLocalClient.client = {
+    mutate: async ({ context }: any) => {
+      enteredAs.push(context.state.user.id)
+      return { data: { addNote: { id: 'note-1' } } }
+    }
+  }
+  owner = await person('owner')
+  guest = await person('guest')
+  outsider = await person('outsider')
+})
+
+afterAll(async () => {
+  clearEntryTargets()
+  delete process['PRIVILEGE_OF_FIELD']['Mutation.addNote']
+  shell.removeDataSource('default')
+  await db?.destroy()
+})
+
+let session: any
+
+/** A group conversation the owner started, with one message in it. */
+beforeEach(async () => {
+  notices = []
+  enteredAs = []
+  session = await db.getRepository(ChatSession).save({ domain, anchorType: 'domain', anchorId: domain.id, name: 'pricing', visibility: 'group', creator: owner, lastMessageAt: new Date() })
+  await db.getRepository(ChatSessionParticipant).save({ domain, session: { id: session.id }, user: { id: owner.id }, role: 'owner', creator: owner })
+  await db.getRepository(ChatMessage).save({ session: { id: session.id }, role: 'user', content: 'the margin is 12%', creator: owner })
+  await db.getRepository(ChatMessage).save({
+    session: { id: session.id },
+    role: 'assistant',
+    content: 'one note to enter',
+    proposals: JSON.stringify([{ key: 'p-1', kind: 'entry', target: 'test.note', rows: [{ values: { title: 'margin' }, sources: [] }] }]),
+    creator: owner
+  })
+})
+
+const roomHears = (user: any) =>
+  mayHearRoom(chatRoomLookup({ sessions: db.getRepository(ChatSession), participants: db.getRepository(ChatSessionParticipant) }, { domainId: domain.id, sessionId: session.id, userId: user.id }))
+const inbox = async (user: any) => (await doors.chatSessionInbox('domain', domain.id, as(user))).map((row: any) => row.id)
+
+/** Everything a person outside the room is refused - each door asked by the room's id. */
+async function expectOutside(user: any) {
+  expect(await doors.chatMessages(session.id, 100, 0, as(user))).toEqual([])
+  expect(await doors.chatSession(session.id, as(user))).toBeNull()
+  expect(await doors.chatSessionParticipants(session.id, as(user))).toEqual([])
+  expect(await inbox(user)).not.toContain(session.id)
+  expect(await roomHears(user)).toBe(false)
+  await expect(doors.sayToRoom(session.id, 'let me in', undefined, as(user))).rejects.toThrow(/private/)
+  await expect(doors.sayTyping(session.id, as(user))).rejects.toThrow(/private/)
+  await expect(entry.applyEntryProposal(session.id, 'p-1', as(user))).rejects.toThrow(/private/)
+  expect(enteredAs).not.toContain(user.id)
+}
+
+describe('a group conversation', () => {
+  it('★ someone the owner did not bring in reads, writes, hears and presses nothing', async () => {
+    await expectOutside(outsider)
+    await expectOutside(guest)
+  })
+
+  it('★ the owner brings someone in - they are told, and from then on they read and write', async () => {
+    expect(await doors.inviteToAISession(session.id, [guest.id], as(owner))).toEqual([guest.id])
+    expect(notices.map(n => n.mode)).toEqual(['foreground', 'background'])
+    expect(notices[0].receivers).toEqual([guest.id])
+    expect(notices[0].body).toContain('pricing')
+
+    expect((await doors.chatMessages(session.id, 100, 0, as(guest))).map((m: any) => m.content).sort()).toEqual(['one note to enter', 'the margin is 12%'])
+    expect(await doors.chatSession(session.id, as(guest))).not.toBeNull()
+    expect(await inbox(guest)).toContain(session.id)
+    expect(await roomHears(guest)).toBe(true)
+    expect((await doors.chatSessionParticipants(session.id, as(guest))).map((p: any) => p.role).sort()).toEqual(['member', 'owner'])
+    expect(await doors.sayToRoom(session.id, 'agreed', undefined, as(guest))).toBeTruthy()
+    expect(await doors.sayTyping(session.id, as(guest))).toBe(true)
+
+    /* ★ The card the owner's conversation made is pressed by the guest - and written as the guest, never as the owner. */
+    expect(await entry.applyEntryProposal(session.id, 'p-1', as(guest))).toMatchObject({ verdict: 'accepted', applied: 1 })
+    expect(enteredAs).toEqual([guest.id])
+
+    /* The one brought in is still not the one who brings people in. */
+    await expectOutside(outsider)
+  })
+
+  it('★ a member cannot bring someone in - not by the door and not by a mention', async () => {
+    await doors.inviteToAISession(session.id, [guest.id], as(owner))
+    expect(await doors.mayInviteToAISession(session.id, as(owner))).toBe(true)
+    expect(await doors.mayInviteToAISession(session.id, as(guest))).toBe(false)
+    await expect(doors.inviteToAISession(session.id, [outsider.id], as(guest))).rejects.toThrow(/only the person who started/)
+    await doors.sayToRoom(session.id, `ask @outsider{userId:${outsider.id}}`, undefined, as(guest))
+    await expectOutside(outsider)
+  })
+
+  it("the owner's mention seats, as the invite does", async () => {
+    await doors.sayToRoom(session.id, `see @guest{userId:${guest.id}}`, undefined, as(owner))
+    expect(await roomHears(guest)).toBe(true)
+    expect(notices.map(n => n.receivers)).toEqual([[guest.id], [guest.id]])
+  })
+
+  it('a person outside the domain is not seated', async () => {
+    const stranger = await db.getRepository(authBase.User).save({ name: 'stranger', username: 'stranger', email: 'stranger@example.com', status: 'activated' })
+    expect(await doors.inviteToAISession(session.id, [stranger.id], as(owner))).toEqual([])
+  })
+
+  it('★ sent out or gone out, the seat closes again', async () => {
+    await doors.inviteToAISession(session.id, [guest.id, outsider.id], as(owner))
+    await expect(doors.removeFromAISession(session.id, outsider.id, as(guest))).rejects.toThrow(/only the person who started/)
+    expect(await doors.removeFromAISession(session.id, outsider.id, as(owner))).toBe(true)
+    await expectOutside(outsider)
+
+    expect(await doors.leaveAISession(session.id, as(guest))).toBe(true)
+    await expectOutside(guest)
+
+    await expect(doors.leaveAISession(session.id, as(owner))).rejects.toThrow(/cannot leave/)
+  })
+
+  it('a hide-only row is not a seat - hiding a group does not open it', async () => {
+    await doors.hideAISession(session.id, as(outsider), true)
+    await expectOutside(outsider)
+  })
+})
+
+describe('private is the owner alone', () => {
+  it('★ turning a group private sends its members out', async () => {
+    await doors.inviteToAISession(session.id, [guest.id], as(owner))
+    expect(await doors.setSessionVisibility(session.id, 'private', as(owner))).toBe(true)
+    await expectOutside(guest)
+    expect((await doors.chatSessionParticipants(session.id, as(owner))).map((p: any) => p.role)).toEqual(['owner'])
+  })
+
+  it('★ a private room takes nobody - make it a group first', async () => {
+    await doors.setSessionVisibility(session.id, 'private', as(owner))
+    expect(await doors.mayInviteToAISession(session.id, as(owner))).toBe(false)
+    await expect(doors.inviteToAISession(session.id, [guest.id], as(owner))).rejects.toThrow(/make it a group/)
+    await doors.sayToRoom(session.id, `@guest{userId:${guest.id}}`, undefined, as(owner))
+    await expectOutside(guest)
+
+    await doors.setSessionVisibility(session.id, 'group', as(owner))
+    expect(await doors.inviteToAISession(session.id, [guest.id], as(owner))).toEqual([guest.id])
+    expect(await roomHears(guest)).toBe(true)
+  })
+
+  it('only the owner changes who reads it, and only to the three it knows', async () => {
+    await doors.inviteToAISession(session.id, [guest.id], as(owner))
+    expect(await doors.setSessionVisibility(session.id, 'open', as(guest))).toBe(false)
+    await expect(doors.setSessionVisibility(session.id, 'team', as(owner))).rejects.toThrow(/unknown visibility/)
+  })
+})
+
+describe('an open room', () => {
+  it('★ someone who walks in and speaks is in the roster after that - the writers and the roster agree', async () => {
+    await doors.setSessionVisibility(session.id, 'open', as(owner))
+    await doors.sayToRoom(session.id, 'I read it too', undefined, as(outsider))
+    const roster = await doors.chatSessionParticipants(session.id, as(owner))
+    expect(roster.map((p: any) => [p.userId, p.role]).sort()).toEqual([[outsider.id, 'member'], [owner.id, 'owner']].sort())
+    expect(await doors.touchPresence(session.id, as(outsider))).toBe(true)
+  })
+
+  it('anyone in the domain reads it and anyone may point a colleague at it', async () => {
+    await doors.setSessionVisibility(session.id, 'open', as(owner))
+    expect((await doors.chatMessages(session.id, 100, 0, as(outsider))).length).toBe(2)
+    expect(await doors.inviteToAISession(session.id, [guest.id], as(outsider))).toEqual([guest.id])
+  })
+})

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

@@ -16,6 +16,9 @@
  * 참여자 조회는 발행당 1회 — 사람 대화 빈도에서 감당 가능한 비용이다.
  */
 
+import { isOpenRoom } from './session-visibility.js'
+import { isRoomRole } from '../chat-session-participant/participant-lookup-roles.js'
+
 /** 세션 활동 방송 토픽. */
 export const SESSION_ACTIVITY_TOPIC = 'board-ai-session-activity'
 
@@ -44,6 +47,23 @@ export interface SessionActivityPayload {
   actorId?: string
 }
 
+/**
+ * Who hears a session's activity - pure, so the rule is tested alone.
+ *
+ * A `viewer` row only remembers a hide. In an open room its person may read anyway, so they hear (a hidden
+ * conversation comes back on new activity). In a group or private room they are outside, and the notice
+ * carries a preview - they do not hear it. `alsoTo` is the people who just left, told once so their list
+ * drops the conversation.
+ */
+export function activityReceivers(
+  rows: ReadonlyArray<{ userId?: string; role?: string }>,
+  visibility: string | null | undefined,
+  alsoTo: ReadonlyArray<string> = []
+): string[] {
+  const heard = rows.filter(row => isOpenRoom(visibility) || isRoomRole(row.role)).map(row => row.userId)
+  return [...new Set([...heard, ...alsoTo])].filter((id): id is string => !!id)
+}
+
 /**
  * 같은 도메인 + **내가 참여자인 세션**의 활동만 통과. 도메인 격리가 보안 핵심이고,
  * 참여자 검사가 "내 것만" 을 성립시킨다(참여하지 않은 대화의 활동을 받지 않는다).

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

@@ -9,6 +9,8 @@
 import { pubsub, getRepository } from '@things-factory/shell'
 
 import { ChatSessionParticipant } from '../chat-session-participant/chat-session-participant.js'
+import { ChatSession } from './chat-session.js'
+import { activityReceivers } from './session-activity-broadcast.js'
 import { SESSION_ACTIVITY_TOPIC, type SessionActivityPayload, type SessionActivityKind } from './session-activity-broadcast.js'
 
 export async function publishSessionActivity(input: {
@@ -21,16 +23,19 @@ export async function publishSessionActivity(input: {
   at?: Date
   preview?: string
   actorId?: string
+  /** People who just left the room - told once more, so their list drops it. They are no longer seated. */
+  alsoTo?: string[]
 }): Promise<void> {
   try {
     const participants = await getRepository(ChatSessionParticipant).find({
       where: { domain: { id: input.domainId } as any, session: { id: input.sessionId } as any }
     })
+    const session = await getRepository(ChatSession).findOne({ where: { id: input.sessionId, domain: { id: input.domainId } } as any })
     const payload: SessionActivityPayload = {
       domainId: input.domainId,
       sessionId: input.sessionId,
       kind: input.kind ?? 'message',
-      participantIds: participants.map(p => (p as any).userId).filter(Boolean),
+      participantIds: activityReceivers(participants as any, (session as any)?.visibility, input.alsoTo),
       anchorType: input.anchorType,
       anchorId: input.anchorId,
       at: (input.at ?? new Date()).toISOString(),

package/server/service/chat-session/session-activity-receivers.test.ts

@@ -0,0 +1,26 @@
+/*
+ * Who hears a session's activity. The notice carries a preview, so outside a group or private room a
+ * hide-only `viewer` row hears nothing; the people just sent out are told once so their lists drop it.
+ */
+import { activityReceivers } from './session-activity-broadcast'
+
+const rows = [
+  { userId: 'owner', role: 'owner' },
+  { userId: 'member', role: 'member' },
+  { userId: 'hid-it', role: 'viewer' }
+]
+
+describe('activity receivers', () => {
+  it('★ a hide-only row hears nothing of a group or private room', () => {
+    expect(activityReceivers(rows, 'group')).toEqual(['owner', 'member'])
+    expect(activityReceivers(rows, 'private')).toEqual(['owner', 'member'])
+  })
+
+  it('in an open room a hidden conversation still comes back on new activity', () => {
+    expect(activityReceivers(rows, 'open')).toEqual(['owner', 'member', 'hid-it'])
+  })
+
+  it('the people who just left are told once, never twice', () => {
+    expect(activityReceivers([{ userId: 'owner', role: 'owner' }], 'private', ['member', 'owner'])).toEqual(['owner', 'member'])
+  })
+})

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

@@ -3,7 +3,7 @@
  *
  * 옮겨 적어 만든 세션이 공개로 태어나면 사적으로 오간 원문이 소급해서 공개된다. 그 한 줄을 여기서 문다.
  */
-import { initialVisibility, mayReadSession } from './session-visibility'
+import { initialVisibility, isOpenRoom, mayReadSession, maySeat, SESSION_VISIBILITIES } from './session-visibility'
 
 describe('session visibility', () => {
   it('★ 앵커가 있어도 비공개로 시작한다 — 앵커는 무엇에 대한 이야기인지이지 누구에게 보이는지가 아니다', () => {
@@ -35,6 +35,37 @@ describe('session visibility', () => {
   })
 })
 
+/*
+ * ADR-0073 decision 3 (2026-10-24) — a group is read by its seats, and only the owner hands a seat out.
+ */
+describe('a group room', () => {
+  it('three rooms, no more', () => {
+    expect([...SESSION_VISIBILITIES]).toEqual(['open', 'group', 'private'])
+  })
+
+  it('★ a group is read by the people seated in it only', () => {
+    expect(mayReadSession('group', false)).toBe(false)
+    expect(mayReadSession('group', true)).toBe(true)
+  })
+
+  it('★ only an open room skips the seat lookup - a group is not open', () => {
+    expect(isOpenRoom('open')).toBe(true)
+    expect(isOpenRoom(undefined)).toBe(true)
+    expect(isOpenRoom('group')).toBe(false)
+    expect(isOpenRoom('private')).toBe(false)
+  })
+
+  it('★ who seats: anyone in an open room, the owner in a group, nobody in a private one', () => {
+    expect(maySeat('open', undefined)).toBe(true)
+    expect(maySeat('open', 'member')).toBe(true)
+    expect(maySeat('group', 'owner')).toBe(true)
+    expect(maySeat('group', 'member')).toBe(false)
+    expect(maySeat('group', 'viewer')).toBe(false)
+    expect(maySeat('group', undefined)).toBe(false)
+    expect(maySeat('private', 'owner')).toBe(false)
+  })
+})
+
 /*
  * ADR-0073 결정 2 — 대상 없는 개인 질문은 공개 방으로 태어나지 않는다.
  *

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

@@ -4,9 +4,15 @@
  * 판정을 세션을 만드는 자리마다 적으면 한 곳이 빠진 날 그 세션만 다른 규칙으로 산다. 한 줄로 모은다.
  */
 
-export type SessionVisibility = 'open' | 'private'
+/*
+ * Three rooms (2026-10-24, the user - ADR-0073 decision 3):
+ *   open     anyone in the domain walks in and writes.
+ *   group    the people the owner brought in, and the owner.
+ *   private  the owner alone. Nobody is seated, and turning a group private sends its members out.
+ */
+export type SessionVisibility = 'open' | 'group' | 'private'
 
-export const SESSION_VISIBILITIES: readonly SessionVisibility[] = ['open', 'private']
+export const SESSION_VISIBILITIES: readonly SessionVisibility[] = ['open', 'group', 'private']
 
 /**
  * 이렇게 만들어진 세션은 무엇으로 시작하나 — **언제나 비공개.**
@@ -22,9 +28,32 @@ export function initialVisibility(_session: { anchorType?: string | null; copyOf
   return 'private'
 }
 
-/** 이 사람이 이 대화를 읽을 수 있나. open 이면 도메인 안 누구나, private 이면 참여자만. */
+/**
+ * Is the room open to everyone in the domain - so no seat needs looking up?
+ *
+ * Doors skip the participant lookup for an open room. They asked `visibility === 'private'` for it, and a
+ * group room is neither: asked that way, a group conversation read like an open one. They ask here.
+ */
+export function isOpenRoom(visibility: string | null | undefined): boolean {
+  return (visibility ?? 'open') === 'open'
+}
+
+/** 이 사람이 이 대화를 읽을 수 있나. open 이면 도메인 안 누구나, group · private 이면 앉은 사람만. */
 export function mayReadSession(visibility: string | null | undefined, isParticipant: boolean): boolean {
-  return (visibility ?? 'open') === 'open' || isParticipant
+  return isOpenRoom(visibility) || isParticipant
+}
+
+/**
+ * May this person seat someone in this conversation - by a mention or by inviting them?
+ *
+ * In an open room a seat grants nothing (anyone walks in), so anyone may point a colleague at it. In a group
+ * the seat is the key, and only the owner hands it out - a member's mention tells, it does not seat. A private
+ * room seats nobody: it is the owner's alone. Both seating doors ask this one line.
+ */
+export function maySeat(visibility: string | null | undefined, seatRole: string | null | undefined): boolean {
+  if (isOpenRoom(visibility)) return true
+  if (visibility === 'group') return seatRole === 'owner'
+  return false
 }
 
 /**

package/server/service/chat-session/session-write-gate.test.ts

@@ -25,7 +25,13 @@ describe('who may write into a conversation', () => {
   it('★ an outsider is refused on a private one, by a sentence that says what to do', async () => {
     await expect(
       assertMayWriteSession({ session: { visibility: 'private' }, userId: 'bob', isParticipant: async () => false, t })
-    ).rejects.toThrow(/private - only the people in it can write here/)
+    ).rejects.toThrow(/only they can write here\. ask the person who started it to bring you in/)
+  })
+
+  it('★ an outsider is refused on a group one too - a group is not an open room', async () => {
+    await expect(
+      assertMayWriteSession({ session: { visibility: 'group' }, userId: 'bob', isParticipant: async () => false, t })
+    ).rejects.toThrow(/private to the people in it/)
   })
 
   it('a participant writes into a private one', async () => {

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

@@ -10,7 +10,7 @@ import { mayWriteSession } from './session-visibility.js'
 export interface WriteGateInput {
   session: { id?: string; visibility?: string | null }
   userId?: string
-  /** Is this user a participant of the session (owner or member)? Asked only for a private one. */
+  /** Is this user a participant of the session (owner or member)? Asked only for a group or private one. */
   isParticipant: () => Promise<boolean>
   t: (key: string, options?: Record<string, unknown>) => string
 }
@@ -24,7 +24,7 @@ export async function assertMayWriteSession({ session, userId, isParticipant, t
   if (!mayWriteSession(visibility, participant)) {
     throw new Error(
       t('ai-assistant.text.private-session-refused', {
-        defaultValue: 'this conversation is private - only the people in it can write here. ask one of them to bring you in.'
+        defaultValue: 'this conversation is private to the people in it - only they can write here. ask the person who started it to bring you in.'
       })
     )
   }

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

@@ -2,5 +2,7 @@ import { ChatSessionParticipant } from './chat-session-participant.js'
 
 export { ChatSessionParticipant }
 export { isOnline, PRESENCE_TTL_MS } from './presence.js'
+/* "Is this person in the room" - one lookup for every gate, board-ai's revert included (a `viewer` row is not a seat). */
+export { isSessionParticipant } from './participant-lookup.js'
 
 export const entities = [ChatSessionParticipant]

package/server/service/chat-session-participant/invite-notification.test.ts

@@ -1,4 +1,4 @@
-import { buildInviteNotification } from './invite-notification'
+import { buildInviteNotification, sendInviteNotification } from './invite-notification'
 
 describe('buildInviteNotification — 협업 초대 알림 payload', () => {
   test('받는 사람 없으면 null', () => {
@@ -43,3 +43,38 @@ describe('an invite outside a board', () => {
     expect(buildInviteNotification(['u1'], undefined, { name: 'Kim' })!.body).toBe('Kim brought you into a conversation.')
   })
 })
+
+describe('sendInviteNotification — the list and the push', () => {
+  test('★ the invite reaches the app\'s notification list (foreground) and the push (background)', async () => {
+    const sent: any[] = []
+    await sendInviteNotification(async (payload: any) => void sent.push(payload), ['u1'], { name: 'Kim' }, 'pricing')
+    expect(sent.map(one => one.mode)).toEqual(['foreground', 'background'])
+    expect(sent.every(one => one.receivers.join() === 'u1' && one.body.includes('pricing'))).toBe(true)
+  })
+
+  test('a failed way does not stop the other, and nobody to tell sends nothing', async () => {
+    const sent: any[] = []
+    await sendInviteNotification(async (payload: any) => {
+      if (payload.mode === 'foreground') throw new Error('down')
+      sent.push(payload)
+    }, ['u1'], null)
+    expect(sent.map(one => one.mode)).toEqual(['background'])
+    await sendInviteNotification(async () => { throw new Error('never') }, [], null)
+    await sendInviteNotification(undefined, ['u1'], null)
+  })
+})
+
+describe('the invite in the reader\'s words', () => {
+  test('★ the words go through the request\'s translator, the names filled in', () => {
+    const asked: any[] = []
+    const t = (key: string, options: any) => (asked.push([key, options]), `${key}:${options.who ?? ''}:${options.name ?? ''}`)
+    const p = buildInviteNotification(['u1'], undefined, { name: 'Kim' }, 'pricing', t)!
+    expect(p.title).toBe('ai-assistant.text.invite-title::')
+    expect(p.body).toBe('ai-assistant.text.invite-body-named:Kim:pricing')
+    expect(buildInviteNotification(['u1'], 'b1', { name: 'Kim' }, undefined, t)!.body).toBe('ai-assistant.text.board-invite-body:Kim:')
+  })
+
+  test('without a translator the English words, names filled in', () => {
+    expect(buildInviteNotification(['u1'], undefined, { name: 'Kim' }, 'pricing')!.body).toBe('Kim brought you into the conversation "pricing".')
+  })
+})

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

@@ -23,19 +23,28 @@ export interface Inviter {
   email?: string | null
 }
 
+/** The request's translator - `requestTranslator(context)`. Absent: the English words. */
+export type InviteTranslate = (key: string, options: Record<string, unknown>) => string
+
 /**
  * 초대된 사용자들에게 보낼 협업 초대 알림 payload 를 만든다.
  * 받는 사람이 없으면 null (= 보낼 것 없음).
+ *
+ * The words are the inviting request's language (`t`). The people of one domain read one language; a receiver's
+ * own locale is not asked here (2026-10-24: the English words stood on a Korean screen).
  */
 export function buildInviteNotification(
   userIds: string[],
   boardId: string | undefined,
   inviter: Inviter | undefined | null,
-  sessionName?: string | null
+  sessionName?: string | null,
+  t?: InviteTranslate
 ): InviteNotification | null {
   if (!Array.isArray(userIds) || userIds.length === 0) return null
 
   const who = inviter?.name || inviter?.email || 'someone'
+  const say = (key: string, defaultValue: string, params: Record<string, string> = {}) =>
+    t ? t(`ai-assistant.text.${key}`, { ...params, defaultValue }) : defaultValue.replace(/\{(\w+)\}/g, (_, name) => params[name] ?? '')
 
   /* A board conversation keeps its board wording and the link to the modeller. */
   if (boardId) {
@@ -43,8 +52,8 @@ export function buildInviteNotification(
       receivers: userIds,
       type: 'board-collab-invite',
       subject: 'info',
-      title: 'Board collaboration invite',
-      body: `${who} invited you to collaborate on a board.`,
+      title: say('board-invite-title', 'Board collaboration invite'),
+      body: say('board-invite-body', '{who} invited you to collaborate on a board.', { who }),
       url: `board-modeller/${boardId}`,
       mode: 'background'
     }
@@ -59,8 +68,37 @@ export function buildInviteNotification(
     receivers: userIds,
     type: 'chat-invite',
     subject: 'info',
-    title: 'Conversation invite',
-    body: name ? `${who} brought you into the conversation "${name}".` : `${who} brought you into a conversation.`,
+    title: say('invite-title', 'Conversation invite'),
+    body: name
+      ? say('invite-body-named', '{who} brought you into the conversation "{name}".', { who, name })
+      : say('invite-body', '{who} brought you into a conversation.', { who }),
     mode: 'background'
   }
 }
+
+/**
+ * Tell the people just seated - in the app's notification list while they are in it (`foreground`, published to
+ * them live) and by web push when they are not (`background`). The notifier takes one way per call, so it is
+ * called once for each; the list was the one place an invite never reached (2026-10-24: only push was sent).
+ *
+ * A letter that does not arrive does not undo the seat - the roster is the record, the notice only tells of it.
+ */
+export async function sendInviteNotification(
+  notify: ((payload: InviteNotification) => Promise<unknown> | unknown) | undefined,
+  userIds: string[],
+  inviter: Inviter | undefined | null,
+  sessionName?: string | null,
+  /** A board conversation keeps its board wording and the link to the modeller. */
+  boardId?: string,
+  t?: InviteTranslate
+): Promise<void> {
+  const payload = buildInviteNotification(userIds, boardId, inviter, sessionName, t)
+  if (!payload || !notify) return
+  for (const mode of ['foreground', 'background'] as const) {
+    try {
+      await notify({ ...payload, mode })
+    } catch {
+      /* the other way may still reach them */
+    }
+  }
+}