@things-factory/ai-assistant 10.1.207 → 10.1.210

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

@@ -5,7 +5,7 @@
  * Until this moved out of the board product, `@name` in a twin deliberation added nobody at all,
  * and the person who typed it had every reason to think they had called a colleague in.
  */
-import { extractMentionUserIds, inviteMentionedUsers, newParticipantUserIds } from './mention-invite'
+import { extractMentionUserIds, inviteMentionedUsers, newParticipantUserIds, seatTurn, seatWriter } from './mention-invite'
 
 const marker = (id: string) => `@someone{userId:${id}}`
 
@@ -123,3 +123,51 @@ describe('the pure parts', () => {
     expect(newParticipantUserIds(['a', 'b', 'me'], ['b'], 'me')).toEqual(['a'])
   })
 })
+
+/*
+ * The writer's seat (2026-10-24): four people wrote in an open conversation and its roster showed two - speaking
+ * seated nobody, so the two who walked in had no chip, no presence and no unread badge.
+ */
+describe('the person who spoke', () => {
+  const room = (rows: any[], visibility = 'open') => {
+    const p = participants(rows)
+    return { ...p, input: { sessionId: 's1', domainId: 'd1', inviter: { id: 'walker' }, participants: p.repo, visibility } }
+  }
+
+  it('★ someone who walks into an open room and speaks is seated as a member', async () => {
+    const { input, saved } = room([owner])
+    expect(await seatWriter(input)).toBe(true)
+    expect(saved).toEqual([expect.objectContaining({ user: { id: 'walker' }, role: 'member' })])
+  })
+
+  it('★ the turn seats the writer and the people mentioned together', async () => {
+    const { input, saved } = room([owner])
+    await seatTurn({ ...input, content: `ask ${marker('kim')}` })
+    expect(saved.map(row => row.user.id)).toEqual(['walker', 'kim'])
+  })
+
+  it('someone seated already is left as they are', async () => {
+    const { input, saved, updated } = room([owner, { id: 'p2', userId: 'walker', role: 'member' }])
+    expect(await seatWriter(input)).toBe(false)
+    expect(saved).toEqual([])
+    expect(updated).toEqual([])
+  })
+
+  it('who hid it or left it comes back on the same row', async () => {
+    const hid = room([owner, { id: 'p2', userId: 'walker', role: 'viewer' }])
+    await seatWriter(hid.input)
+    expect(hid.updated).toEqual([{ id: 'p2', patch: expect.objectContaining({ role: 'member', deletedAt: null }) }])
+    const left = room([owner, { id: 'p3', userId: 'walker', role: 'member', deletedAt: new Date() }])
+    await seatWriter(left.input)
+    expect(left.updated).toEqual([{ id: 'p3', patch: expect.objectContaining({ role: 'member', deletedAt: null }) }])
+  })
+
+  it('★ a group or private room is not seated by speaking - there the seat is the key', async () => {
+    for (const visibility of ['group', 'private']) {
+      const { input, saved, updated } = room([owner], visibility)
+      expect(await seatWriter(input)).toBe(false)
+      expect(saved).toEqual([])
+      expect(updated).toEqual([])
+    }
+  })
+})

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

@@ -19,7 +19,13 @@
  * What went: the inviter's own role (there is nothing to hand out), the refusal verdicts, and the
  * notice shown before sending. A private conversation is the one place a mention cannot seat
  * someone — there the named person is told and stays outside until an owner opens it.
+ *
+ * ── A group (2026-10-24, ADR-0073 decision 3) ──────────────────────────────────
+ * In a group the seat is the key, so who seats is asked again: the owner's mention seats, a member's
+ * tells (`maySeat`). The invite door (`inviteToAISession`) seats through the same `seatParticipants`
+ * under the same rule - two ways in, one seat.
  */
+import { isOpenRoom, maySeat } from '../chat-session/session-visibility.js'
 
 /** 본문에서 `@user{userId:UUID}` 마커의 userId 를 뽑는다 — 첫 등장 순, 중복 제거. */
 export function extractMentionUserIds(text: string | null | undefined): string[] {
@@ -59,7 +65,7 @@ export function newParticipantUserIds(
 export interface MentionInviteResult {
   /** 이번에 새로 앉은 사람들. 알림은 이들에게 간다. */
   invited: string[]
-  /** 비공개 대화라 앉히지 못한 사람들 — 이름은 불렸고 방에는 못 들어온다. 화면이 그대로 말한다. */
+  /** 앉힐 수 없는 방이거나 부른 사람에게 그 자리가 없어 앉히지 못한 사람들 — 이름은 불렸고 방에는 못 들어온다. */
   notSeated?: string[]
 }
 
@@ -71,51 +77,99 @@ export interface MentionInviteInput {
   inviter: { id?: string } | undefined | null
   /** 참여자 저장소 — 시험이 가짜를 넣는다. */
   participants: any
-  /** 이 대화가 공개인가(ADR-0073 판정 2). 비공개면 이름만 알리고 앉히지 않는다. */
+  /** 이 대화의 공개 범위(ADR-0073). 그룹은 owner 의 멘션만, 비공개는 아무의 멘션도 앉히지 않는다. */
   visibility?: string | null
 }
 
-/**
- * 멘션된 사람을 참여자로 앉힌다.
- *
- * 나갔던 사람(soft delete)은 되살린다 — 다시 부른 것이지 새 사람이 아니다.
- */
+/** 멘션된 사람을 참여자로 앉힌다 — 앉힐 수 있는 방이고 부른 사람에게 그 자리가 있을 때만(`maySeat`). */
 export async function inviteMentionedUsers(input: MentionInviteInput): Promise<MentionInviteResult> {
   const mentioned = extractMentionUserIds(input.content)
   if (mentioned.length === 0) return { invited: [] }
+  return seatParticipants({ ...input, userIds: mentioned })
+}
 
+export interface SeatInput {
+  sessionId: string
+  domainId: string
+  inviter: { id?: string } | undefined | null
+  /** 앉힐 사람들. 이미 앉은 사람과 부른 사람 자신은 빠진다. */
+  userIds: ReadonlyArray<string>
+  participants: any
+  visibility?: string | null
+}
+
+/**
+ * 사람을 앉힌다 — 멘션과 초대 단추가 함께 쓰는 한 곳.
+ *
+ * 규칙은 `maySeat` 한 줄이다: 공개 방은 누구나, 그룹은 owner 만, 비공개는 아무도. 앉히지 못하면
+ * 아무것도 쓰지 않고 그 사람들을 `notSeated` 로 돌려준다 — 화면이 그대로 말한다.
+ * 나갔던 사람(soft delete)은 되살린다 — 다시 부른 것이지 새 사람이 아니다.
+ */
+export async function seatParticipants(input: SeatInput): Promise<MentionInviteResult> {
   const repo = input.participants
   const existing = await repo.find({
     where: { session: { id: input.sessionId } as any, domain: { id: input.domainId } as any },
     withDeleted: true
   })
 
-  const activeIds = existing.filter((row: any) => !row.deletedAt).map((row: any) => row.userId).filter(Boolean)
-  const fresh = newParticipantUserIds(mentioned, activeIds, input.inviter?.id)
+  /* A hide-only `viewer` row is not a seat - the person is brought in over it, as a member. */
+  const seated = existing.filter((row: any) => !row.deletedAt && row.role !== 'viewer')
+  const activeIds = seated.map((row: any) => row.userId).filter(Boolean)
+  const fresh = newParticipantUserIds(input.userIds, activeIds, input.inviter?.id)
   if (fresh.length === 0) return { invited: [] }
 
   /*
-   * 비공개 대화에서는 이름을 불러도 앉히지 않는다. 공개 대화에서는 앉히는 일이 아무것도 주지 않지만
-   * (누구나 들어온다), 비공개에서는 그것이 곧 접근을 주는 일이다. 부르는 사람이 아니라 owner 가 열
-   * 일이다 — 이름이 불렸다는 것만 알린다.
+   * 공개 방에서 앉히는 일은 아무것도 주지 않지만(누구나 들어온다), 그룹과 비공개에서는 그것이 곧 접근을
+   * 주는 일이다. 그룹에서는 owner 가 주고, 비공개에서는 아무도 주지 않는다 — 이름이 불렸다는 것만 남는다.
    */
-  if ((input.visibility ?? 'open') !== 'open') return { invited: [], notSeated: fresh }
+  const inviterRole = seated.find((row: any) => row.userId === input.inviter?.id)?.role
+  if (!maySeat(input.visibility, inviterRole)) return { invited: [], notSeated: fresh }
 
-  for (const userId of fresh) {
-    const prior = existing.find((row: any) => row.userId === userId && row.deletedAt)
-    if (prior) {
-      await repo.update(prior.id, { deletedAt: null, role: 'member', updater: input.inviter } as any)
-    } else {
-      await repo.save({
-        domain: { id: input.domainId } as any,
-        session: { id: input.sessionId } as any,
-        user: { id: userId } as any,
-        role: 'member',
-        creator: input.inviter,
-        updater: input.inviter
-      } as any)
-    }
-  }
+  for (const userId of fresh) await writeMemberSeat(repo, existing, input, userId)
 
   return { invited: fresh }
 }
+
+/**
+ * The seats a person's turn gives - what every door that stores a person's words calls.
+ *
+ * The writer first: in an open room anyone may walk in and speak, and until 2026-10-24 speaking seated nobody. A
+ * conversation four people wrote in showed two in its roster - the one who started it and the one who was
+ * mentioned - and the other two had no presence, no unread badge and no activity notice. In a group or private
+ * room the writer is seated already (the write gate let them in by their seat). Then the people mentioned.
+ */
+export async function seatTurn(input: MentionInviteInput): Promise<MentionInviteResult> {
+  await seatWriter(input)
+  return inviteMentionedUsers(input)
+}
+
+/** Seat the person who spoke, in an open room only - there the seat grants nothing, it records who took part. */
+export async function seatWriter(input: Omit<SeatInput, 'userIds'>): Promise<boolean> {
+  const writerId = input.inviter?.id
+  if (!writerId || !isOpenRoom(input.visibility)) return false
+  const repo = input.participants
+  const existing = await repo.find({
+    where: { session: { id: input.sessionId } as any, domain: { id: input.domainId } as any },
+    withDeleted: true
+  })
+  if (existing.some((row: any) => row.userId === writerId && !row.deletedAt && row.role !== 'viewer')) return false
+  await writeMemberSeat(repo, existing, input, writerId)
+  return true
+}
+
+/** One member seat: someone who left (soft delete) or only hid it (`viewer`) is brought back on that row, never a second one. */
+async function writeMemberSeat(repo: any, existing: any[], input: { sessionId: string; domainId: string; inviter: { id?: string } | undefined | null }, userId: string) {
+  const prior = existing.find((row: any) => row.userId === userId && (row.deletedAt || row.role === 'viewer'))
+  if (prior) {
+    await repo.update(prior.id, { deletedAt: null, role: 'member', updater: input.inviter } as any)
+  } else {
+    await repo.save({
+      domain: { id: input.domainId } as any,
+      session: { id: input.sessionId } as any,
+      user: { id: userId } as any,
+      role: 'member',
+      creator: input.inviter,
+      updater: input.inviter
+    } as any)
+  }
+}

package/server/service/chat-session-participant/read-roster.test.ts

@@ -2,17 +2,26 @@ import { readRoster } from './read-roster'
 
 describe('participant roster identities', () => {
   it('loads the participating user relation for public conversations', async () => {
-    const find = jest.fn(async options => options.relations.includes('user') ? [{id:'p',user:{id:'u',name:'김희태'}}] : [{id:'p'}])
+    const find = jest.fn(async options => options.relations.includes('user') ? [{id:'p',role:'owner',user:{id:'u',name:'김희태'}}] : [{id:'p',role:'owner'}])
     const isParticipant=jest.fn(async()=>false)
     const rows=await readRoster({id:'room',domainId:'domain',visibility:'open'},{find,isParticipant})
-    expect(rows).toEqual([{id:'p',user:{id:'u',name:'김희태'}}])
+    expect(rows).toEqual([{id:'p',role:'owner',user:{id:'u',name:'김희태'}}])
     expect(find).toHaveBeenCalledWith(expect.objectContaining({where:{session:{id:'room'},domain:{id:'domain'}},relations:['user']}))
     expect(isParticipant).not.toHaveBeenCalled()
   })
   it('does not expose identities from a private room to an outsider', async () => {
-    const find=jest.fn(async()=>[{id:'p',user:{name:'Private'}}])
+    const find=jest.fn(async()=>[{id:'p',role:'owner',user:{name:'Private'}}])
     expect(await readRoster({id:'r',domainId:'d',visibility:'private'},{find,isParticipant:async()=>false})).toEqual([])
     expect(find).not.toHaveBeenCalled()
-    expect(await readRoster({id:'r',domainId:'d',visibility:'private'},{find,isParticipant:async()=>true})).toEqual([{id:'p',user:{name:'Private'}}])
+    expect(await readRoster({id:'r',domainId:'d',visibility:'private'},{find,isParticipant:async()=>true})).toEqual([{id:'p',role:'owner',user:{name:'Private'}}])
+  })
+  it('★ a group room is closed to an outsider too - it is not a public room', async () => {
+    const find=jest.fn(async()=>[{id:'p',role:'owner',user:{name:'Group'}}])
+    expect(await readRoster({id:'r',domainId:'d',visibility:'group'},{find,isParticipant:async()=>false})).toEqual([])
+    expect(find).not.toHaveBeenCalled()
+  })
+  it('lists the seats - a hide-only viewer row is not someone in the room', async () => {
+    const find=jest.fn(async()=>[{id:'p',role:'owner'},{id:'q',role:'member'},{id:'v',role:'viewer'}])
+    expect((await readRoster({id:'r',domainId:'d',visibility:'open'},{find,isParticipant:async()=>false})).map((row:any)=>row.id)).toEqual(['p','q'])
   })
 })

package/server/service/chat-session-participant/read-roster.ts

@@ -1,14 +1,17 @@
-import { mayReadSession } from '../chat-session/session-visibility.js'
+import { isOpenRoom, mayReadSession } from '../chat-session/session-visibility.js'
+import { isRoomRole } from './participant-lookup-roles.js'
 
 /** Read the room roster with user identities hydrated, after applying the room's visibility gate. */
 export async function readRoster<T>(
   room: { id: string; domainId: string; visibility?: string },
   port: { isParticipant(): Promise<boolean>; find(options: any): Promise<T[]> }
 ): Promise<T[]> {
-  if (!mayReadSession(room.visibility, room.visibility === 'private' ? await port.isParticipant() : false)) return []
-  return port.find({
+  if (!mayReadSession(room.visibility, isOpenRoom(room.visibility) ? false : await port.isParticipant())) return []
+  /* A hide-only `viewer` row is not someone in the room - the roster lists the seats. */
+  const rows = await port.find({
     where: { session: { id: room.id }, domain: { id: room.domainId } },
     relations: ['user'],
     order: { createdAt: 'ASC' }
   })
+  return rows.filter((row: any) => isRoomRole(row?.role))
 }

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

@@ -9,7 +9,7 @@ import { GraphQLJSON } from 'graphql-scalars'
 import { User } from '@things-factory/auth-base'
 import { buildDomainUsersQueryBuilder } from '@things-factory/auth-base/dist-server/utils/get-domain-users.js'
 
-import { getRepository } from '@things-factory/shell'
+import { getRepository, pubsub } from '@things-factory/shell'
 import { In, Like } from 'typeorm'
 
 import { ChatSession } from './chat-session/chat-session.js'
@@ -18,28 +18,29 @@ import { buildInbox, applyHidden, activityPatch, searchInbox, filterInbox, searc
 import { carriedOriginalWhere, planCarriedTurns, quoteCarriedAnswer } from './chat-message/carried-turns.js'
 import { roomMessageBody } from './chat-message/room-message.js'
 import { readerGate } from './chat-message/reader-gate.js'
-import { initialVisibility, mayReadSession, SESSION_VISIBILITIES } from './chat-session/session-visibility.js'
-import { inviteMentionedUsers } from './chat-session-participant/mention-invite.js'
-import { buildInviteNotification } from './chat-session-participant/invite-notification.js'
+import { requestTranslator } from './request-translator.js'
+import { initialVisibility, isOpenRoom, mayReadSession, maySeat, SESSION_VISIBILITIES } from './chat-session/session-visibility.js'
+import { seatParticipants, seatTurn } from './chat-session-participant/mention-invite.js'
+import { CHAT_TYPING_TOPIC, typingNotice } from './chat-message/chat-typing.js'
+import { sendInviteNotification } from './chat-session-participant/invite-notification.js'
 import { readRoster } from './chat-session-participant/read-roster.js'
 import { isSessionParticipant } from './chat-session-participant/participant-lookup.js'
 import { assertMayWriteSession } from './chat-session/session-write-gate.js'
 
+/** 초대 알림 — 발송은 호스트의 기전을 그대로 쓴다(`sendInviteNotification`, 문 셋이 같은 한 곳). */
+async function notifyInvited(context: any, invited: string[], inviter: any, sessionName?: string): Promise<void> {
+  await sendInviteNotification(context.state?.notify, invited, inviter, sessionName, undefined, requestTranslator(context))
+}
+
 /**
- * 초대 알림 — 발송은 호스트의 기전을 그대로 쓴다(중복 구현 금지).
- *
- * 알림이 안 가도 초대 자체는 이미 일어났다. 그래서 실패를 삼키되, 초대를 되돌리지는 않는다 —
- * 참여자 목록이 정본이고 알림은 그것을 알리는 편지다.
+ * A private room is the owner's alone (ADR-0073 decision 3) - closing a room to private sends its members out.
+ * Returns who left, so their lists can be told once.
  */
-async function notifyInvited(context: any, invited: string[], inviter: any, sessionName?: string): Promise<void> {
-  if (invited.length === 0) return
-  const payload = buildInviteNotification(invited, undefined, inviter, sessionName)
-  if (!payload) return
-  try {
-    await context.state?.notify?.(payload)
-  } catch {
-    /* 편지가 못 갔다고 방에 들어온 사실이 취소되지는 않는다. */
-  }
+async function sendOutMembers(domainId: string, sessionId: string, tx?: any): Promise<string[]> {
+  const repo = getRepository(ChatSessionParticipant, tx)
+  const seats = await repo.find({ where: { domain: { id: domainId }, session: { id: sessionId }, role: 'member' } as any })
+  for (const seat of seats) await repo.softDelete(seat.id!)
+  return seats.map(seat => (seat as any).userId).filter(Boolean)
 }
 
 /** Every door that writes into a conversation passes this first (`session-write-gate.ts`). */
@@ -123,7 +124,7 @@ class ChatSessionInboxEntry {
   hidden?: boolean
 
   /* 목록이 공개 범위를 그리고, owner 만 그것을 바꾸는 단추를 받는다 — 판정은 setSessionVisibility 가 다시 한다. */
-  @Field({ description: "Who may read the session: 'open' (everyone in the domain) or 'private' (participants only)." })
+  @Field({ description: "Who may read the session: 'open' (everyone in the domain), 'group' (the owner and the people brought in) or 'private' (the owner alone)." })
   visibility!: string
 
   @Field({ description: 'Whether this viewer is the owner of the session - only the owner may change its visibility.' })
@@ -176,8 +177,15 @@ export class ChatSessionResolver {
     @Arg('id') id: string,
     @Ctx() context: ResolverContext
   ): Promise<ChatSession | null> {
-    const { domain } = context.state
-    return (await getRepository(ChatSession).findOneBy({ id, domain: { id: domain.id } })) ?? null
+    const { domain, user } = context.state
+    const session = await getRepository(ChatSession).findOneBy({ id, domain: { id: domain.id } })
+    if (!session) return null
+    /*
+     * The row carries the name, the last preview and the summary of older messages - the conversation in
+     * short. A room the caller cannot enter answers as a missing one (ADR-0073: every reading path passes the gate).
+     */
+    if (!isOpenRoom((session as any).visibility) && !mayReadSession((session as any).visibility, await isSessionParticipant(domain.id, id, user?.id))) return null
+    return session
   }
 
   @Query(() => [ChatSession], {
@@ -453,7 +461,7 @@ export class ChatSessionResolver {
    */
   @Mutation(() => Boolean, {
     description:
-      "Open this conversation to everyone in the domain, or close it to its participants. Only the owner may change it. Opening exposes what is already written — the screen says so before asking. Door checks on assistant answers are unaffected (ADR-0073)."
+      "Set who reads this conversation: 'open' (everyone in the domain), 'group' (the owner and the people the owner brings in) or 'private' (the owner alone - the members are sent out). Only the owner may change it. Opening exposes what is already written — the screen says so before asking. Door checks on assistant answers are unaffected (ADR-0073)."
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
   async setSessionVisibility(
@@ -476,7 +484,68 @@ export class ChatSessionResolver {
 
     if ((session as any).visibility === visibility) return true
 
+    /*
+     * Private is the owner's alone (ADR-0073 decision 3). The members leave with the change - a private room
+     * with people still seated in it would be a group under another name. Bringing them back is inviting
+     * them again, in a group.
+     */
+    const sentOut = visibility === 'private' ? await sendOutMembers(domain.id, sessionId) : []
+
     await getRepository(ChatSession).update(sessionId, { visibility, updater: user } as any)
+    publishSessionActivity({
+      domainId: domain.id,
+      sessionId,
+      kind: 'meta',
+      anchorType: (session as any).anchorType,
+      anchorId: (session as any).anchorId,
+      actorId: user?.id,
+      alsoTo: sentOut
+    })
+    return true
+  }
+
+  /**
+   * Bring people into this conversation - the same seat a mention gives, by the same rule (`maySeat`): anyone
+   * in an open room, the owner in a group, nobody in a private one. Each person seated is told
+   * (`notifyInvited`). People outside the domain are not seated.
+   */
+  @Mutation(() => [String], {
+    description:
+      "Bring people into this conversation and tell them. In a group only the owner may; a private conversation takes nobody (make it a group first). Returns the ids of the people seated now - people already in it are left out."
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
+  async inviteToAISession(
+    @Arg('sessionId') sessionId: string,
+    @Arg('userIds', () => [String]) userIds: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<string[]> {
+    const { domain, user } = context.state
+    const session = await getRepository(ChatSession).findOneBy({ id: sessionId, domain: { id: domain.id } as any })
+    if (!session) throw new Error('chat session not found')
+
+    /* Only people of this domain - an id from elsewhere is not a colleague here. */
+    const wanted = [...new Set((userIds ?? []).filter(id => typeof id === 'string' && id))].slice(0, 50)
+    if (wanted.length === 0) return []
+    const members = await buildDomainUsersQueryBuilder(domain.id, 'USER').andWhere('USER.id IN (:...ids)', { ids: wanted }).getMany()
+    const known = new Set(members.map(member => member.id))
+
+    const seat = await seatParticipants({
+      sessionId,
+      domainId: domain.id,
+      inviter: user,
+      userIds: wanted.filter(id => known.has(id)),
+      participants: getRepository(ChatSessionParticipant),
+      visibility: (session as any).visibility
+    })
+    if (seat.notSeated?.length) {
+      throw new Error(
+        (session as any).visibility === 'private'
+          ? requestTranslator(context)('ai-assistant.text.invite-private-refused', { defaultValue: 'a private conversation is yours alone. make it a group to bring people in.' })
+          : requestTranslator(context)('ai-assistant.text.invite-owner-only', { defaultValue: 'only the person who started this group conversation can bring people in.' })
+      )
+    }
+
+    await notifyInvited(context, seat.invited, user, (session as any).name)
     publishSessionActivity({
       domainId: domain.id,
       sessionId,
@@ -484,7 +553,92 @@ export class ChatSessionResolver {
       anchorType: (session as any).anchorType,
       anchorId: (session as any).anchorId,
       actorId: user?.id
-    } as any)
+    })
+    return seat.invited
+  }
+
+  /**
+   * Send a member out - the owner only, and never the owner themself. In a group the seat was the key, so the
+   * person no longer reads or writes here (every gate asks the seat). Their list is told once and drops it.
+   */
+  @Mutation(() => Boolean, {
+    description: 'Send a member out of this conversation. Only the owner may, and the owner cannot be sent out. In a group the person no longer reads or writes here.'
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
+  async removeFromAISession(
+    @Arg('sessionId') sessionId: string,
+    @Arg('userId') userId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, user } = context.state
+    const repo = getRepository(ChatSessionParticipant)
+    const seats = await repo.find({ where: { domain: { id: domain.id } as any, session: { id: sessionId } as any } as any })
+    const mine = seats.find(seat => (seat as any).userId === user?.id)
+    if (mine?.role !== 'owner') {
+      throw new Error(requestTranslator(context)('ai-assistant.text.remove-owner-only', { defaultValue: 'only the person who started this conversation can send someone out.' }))
+    }
+    const theirs = seats.find(seat => (seat as any).userId === userId && seat.role === 'member')
+    if (!theirs) return false
+    return await this._leave(sessionId, theirs, context)
+  }
+
+  /**
+   * Leave this conversation - a member steps out of their own seat. The owner does not leave: the room would be
+   * nobody's. They delete it, or make it private.
+   */
+  @Mutation(() => Boolean, {
+    description: 'Leave this conversation. A member may; the owner cannot (delete it or make it private instead). In a group, leaving ends reading and writing here.'
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
+  async leaveAISession(@Arg('sessionId') sessionId: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, user } = context.state
+    if (!user?.id) return false
+    const mine = await getRepository(ChatSessionParticipant).findOne({
+      where: { domain: { id: domain.id } as any, session: { id: sessionId } as any, user: { id: user.id } as any }
+    })
+    if (mine?.role === 'owner') {
+      throw new Error(requestTranslator(context)('ai-assistant.text.owner-cannot-leave', { defaultValue: 'you started this conversation, so you cannot leave it. delete it, or make it private.' }))
+    }
+    if (mine?.role !== 'member') return false
+    return await this._leave(sessionId, mine, context)
+  }
+
+  private async _leave(sessionId: string, seat: ChatSessionParticipant, context: ResolverContext): Promise<boolean> {
+    const { domain, user } = context.state
+    const session = await getRepository(ChatSession).findOneBy({ id: sessionId, domain: { id: domain.id } as any })
+    await getRepository(ChatSessionParticipant).softDelete(seat.id!)
+    publishSessionActivity({
+      domainId: domain.id,
+      sessionId,
+      kind: 'meta',
+      anchorType: (session as any)?.anchorType,
+      anchorId: (session as any)?.anchorId,
+      actorId: user?.id,
+      alsoTo: [(seat as any).userId].filter(Boolean)
+    })
+    return true
+  }
+
+  /**
+   * "I am typing" - a notice to the others in the room, stored nowhere. Only a person who may write here is
+   * typing here (the write gate), and the listeners pass the room's read gate (`ChatTypingSubscription`).
+   */
+  @Mutation(() => Boolean, {
+    description: 'Tell the others in this conversation that the caller is typing. Nothing is stored; send it every few seconds while typing. Only a person who may write here may send it.'
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
+  async sayTyping(@Arg('sessionId') sessionId: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, user } = context.state
+    const session = await getRepository(ChatSession).findOneBy({ id: sessionId, domain: { id: domain.id } as any })
+    if (!session) return false
+    await writeGate(session, context)
+    const notice = typingNotice({ domainId: domain.id, sessionId, user })
+    if (!notice) return false
+    try {
+      pubsub.publish(CHAT_TYPING_TOPIC, notice)
+    } catch {
+      /* a missed notice is a line that does not show - nothing else rests on it */
+    }
     return true
   }
 
@@ -583,6 +737,24 @@ export class ChatSessionResolver {
     })
   }
 
+  /**
+   * May the caller seat someone here - the server's answer to the screen, so the screen keeps no copy of the
+   * rule (`maySeat`). The invite button and the line under a mention read it; the doors decide again.
+   */
+  @Query(() => Boolean, {
+    description: "Whether the caller may bring people into this conversation now - anyone in an open one, the owner of a group, nobody in a private one. A hint for the screen; the invite and the mention decide again."
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
+  async mayInviteToAISession(@Arg('sessionId') sessionId: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, user } = context.state
+    const session = await getRepository(ChatSession).findOneBy({ id: sessionId, domain: { id: domain.id } as any })
+    if (!session || !user?.id) return false
+    const seat = await getRepository(ChatSessionParticipant).findOne({
+      where: { domain: { id: domain.id } as any, session: { id: sessionId } as any, user: { id: user.id } as any }
+    })
+    return maySeat((session as any).visibility, seat?.role)
+  }
+
   @Mutation(() => Boolean, {
     description: 'Presence heartbeat — bump current user\'s lastSeenAt in the session (online indicator).'
   })
@@ -617,7 +789,7 @@ export class ChatSessionResolver {
      * 공개 대화는 도메인 안이면 누구나 읽는다 — 초대 절차가 없다(ADR-0073 판정 2). 비공개 대화는
      * 참여자만. 여기서 막히는 것은 **방**이고, 방에 들어온 뒤 값을 읽는 일은 아래 문 판정이 따로 본다.
      */
-    if ((session as any).visibility === 'private') {
+    if (!isOpenRoom((session as any).visibility)) {
       /* A hide-only `viewer` row is not being in the room - it must not open a private conversation. */
       const part = await isSessionParticipant(domain.id, sessionId, user?.id)
       if (!mayReadSession((session as any).visibility, part)) return []
@@ -902,9 +1074,9 @@ export class ChatSessionResolver {
 
     /*
      * 멘션은 사람을 불러들인다 — **사람의 말을 저장하는 문**만 이것을 한다(ADR-0071 결정 1 ①).
-     * 초대는 방에 있는 사람(owner · member)만 할 수 있고, 거절되면 그 사실이 화면으로 돌아간다.
+     * 누가 자리를 주는지는 `maySeat` 가 정한다. 공개 방에서는 말한 사람도 앉는다(`seatTurn`).
      */
-    const invite = await inviteMentionedUsers({
+    const invite = await seatTurn({
       content: body,
       sessionId: session.id!,
       domainId: domain.id,
@@ -913,7 +1085,7 @@ export class ChatSessionResolver {
       /* 비공개 대화에서는 이름만 닿는다 — ADR-0073 판정 2. */
       visibility: (session as any).visibility
     })
-    await notifyInvited(context, invite.invited, user)
+    await notifyInvited(context, invite.invited, user, (session as any).name)
 
     /* 사람의 말이다 — 목록의 최근 활동과 다른 참여자의 안 읽음이 이것으로 움직인다. */
     try {
@@ -1055,7 +1227,12 @@ export class ChatSessionResolver {
       saved.push(previous!)
     }
 
-    if (carried && (session as any).visibility !== 'private') {
+    /*
+     * Carried words do not land in front of the whole domain. An open room closes to its owner; a group stays
+     * a group - its people were chosen by the owner, and carrying into it is writing to them.
+     */
+    if (carried && isOpenRoom((session as any).visibility)) {
+      await sendOutMembers(domain.id, session.id!, tx)
       await getRepository(ChatSession, tx).update(session.id!, { visibility: 'private', updater: user } as any)
     }
 

package/server/service/data-entry/data-entry-update.test.ts

@@ -74,6 +74,17 @@ describe('which record is meant', () => {
     expect(resolveChangeRefs('office.expense-line', [{ ref: 'current', values: {} }], { record: { target: 'office.contract', id: 'c1' } }).unresolved).toEqual(['current'])
   })
 
+  /* 2026-10-23: the open record is named to the model by its key; a change naming it so found nothing. */
+  it('★ the key a record was shown by names it - `<axis>:<id>`, the axis being the target key\'s last part', () => {
+    const id = 'f92c04ec-40c4-4be8-8160-080cff20e750'
+    const picked = (key: string, ref: string) => resolveChangeRefs(key, [{ ref, values: {} }], undefined).picked.map(one => one.id)
+    expect(picked('office.contract-round', `contract-round:${id}`)).toEqual([id])
+    expect(picked('office.contract-round', id)).toEqual([id])
+    /* Another record's key is not this record, whatever its uuid - it is looked up as written and found by nobody. */
+    expect(picked('office.contract-round', `contract:${id}`)).toEqual([`contract:${id}`])
+    expect(picked('office.contract', `contract-round:${id}`)).toEqual([`contract-round:${id}`])
+  })
+
   it('★ an id from the screen is only a candidate - a record the person cannot read is not found, and nothing is shown of it', async () => {
     const result: any = await proposeChanges(expense, { changes: [{ ref: 'current', values: { amount: 13000 } }] }, { host: { record: { id: 'someone-elses' } } }, run)
     expect(result.rows[0].issues).toEqual([{ code: 'record-not-found', blocking: true }])
@@ -202,6 +213,14 @@ describe('declaring and offering', () => {
     ])
   })
 
+  /* 2026-10-24: having read 568 bank lines, the model said nothing was selected and asked the person to pick rows. */
+  it('★ the change tool takes the ids a list read returned - nothing need be selected', () => {
+    const change = (entryCategoryOf(expense, () => run).specs as any[]).find(spec => spec.name === changeToolName('office.expense-line'))
+    expect(change.description).toMatch(/the id a list read or a find tool returned/)
+    expect(change.description).toMatch(/nothing need be selected to change rows a read found/)
+    expect(change.schema.properties.changes.items.properties.ref.description).toMatch(/a list read or a find tool/)
+  })
+
   it('stillAsProposed marks a record gone since as not found', () => {
     const rows = stillAsProposed(expense, [{ index: 0, id: 'gone', via: 'id', before: { amount: 1 }, values: { amount: 2 }, issues: [] }], new Map())
     expect(rows[0].issues).toEqual([{ code: 'record-not-found', blocking: true }])