@things-factory/ai-assistant 10.1.27 → 10.1.29

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

@@ -0,0 +1,125 @@
+/*
+ * What this guards: `@name` in a conversation brings that person in — and only when the person
+ * typing it is in the room themselves (ADR-0071 decision 1).
+ *
+ * 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'
+
+const marker = (id: string) => `@someone{userId:${id}}`
+
+function participants(rows: any[]) {
+  const saved: any[] = []
+  const updated: any[] = []
+  return {
+    saved,
+    updated,
+    repo: {
+      find: async () => rows,
+      save: async (row: any) => saved.push(row),
+      update: async (id: string, patch: any) => updated.push({ id, patch })
+    }
+  }
+}
+
+const owner = { id: 'p1', userId: 'me', role: 'owner' }
+
+it('★ a mentioned colleague joins as a member', async () => {
+  const { repo, saved } = participants([owner])
+
+  const result = await inviteMentionedUsers({
+    content: `${marker('u2')} 이것 좀 봐주세요`,
+    sessionId: 's1',
+    domainId: 'dom-1',
+    inviter: { id: 'me' },
+    participants: repo
+  })
+
+  expect(result.invited).toEqual(['u2'])
+  expect(saved[0]).toMatchObject({ role: 'member', user: { id: 'u2' } })
+})
+
+it('★ 공개 대화에서는 자리에 상관없이 이름을 부를 수 있다 — 줄 것이 없으므로 조건도 없다', async () => {
+  /* 보기만 하던 사람도, 아직 앉지 않은 사람도 부른다. ADR-0073 이 자격 검사를 걷어냈다. */
+  for (const inviter of [{ id: 'me' }, { id: 'stranger' }]) {
+    const { repo, saved } = participants([{ id: 'p9', userId: 'me', role: 'viewer' }])
+
+    const result = await inviteMentionedUsers({
+      content: marker('u2'),
+      sessionId: 's1',
+      domainId: 'dom-1',
+      inviter,
+      participants: repo
+    })
+
+    expect(result).toEqual({ invited: ['u2'] })
+    expect(saved[0]).toMatchObject({ role: 'member', user: { id: 'u2' } })
+  }
+})
+
+it('★ 비공개 대화에서는 이름만 알리고 앉히지 않는다 — 거기서는 앉히는 일이 접근을 주는 일이다', async () => {
+  const { repo, saved } = participants([owner])
+
+  const result = await inviteMentionedUsers({
+    content: marker('u2'),
+    sessionId: 's1',
+    domainId: 'dom-1',
+    inviter: { id: 'me' },
+    participants: repo,
+    visibility: 'private'
+  })
+
+  expect(result).toEqual({ invited: [], notSeated: ['u2'] })
+  expect(saved).toEqual([])
+})
+
+it('★ someone who left is brought back, not added twice', async () => {
+  const { repo, saved, updated } = participants([owner, { id: 'p2', userId: 'u2', role: 'member', deletedAt: new Date() }])
+
+  const result = await inviteMentionedUsers({
+    content: marker('u2'),
+    sessionId: 's1',
+    domainId: 'dom-1',
+    inviter: { id: 'me' },
+    participants: repo
+  })
+
+  expect(result.invited).toEqual(['u2'])
+  expect(saved).toEqual([])
+  expect(updated[0]).toMatchObject({ id: 'p2', patch: { deletedAt: null, role: 'member' } })
+})
+
+it('mentioning someone already here, or yourself, invites nobody', async () => {
+  const { repo, saved } = participants([owner, { id: 'p2', userId: 'u2', role: 'member' }])
+
+  const result = await inviteMentionedUsers({
+    content: `${marker('u2')} ${marker('me')}`,
+    sessionId: 's1',
+    domainId: 'dom-1',
+    inviter: { id: 'me' },
+    participants: repo
+  })
+
+  expect(result).toEqual({ invited: [] })
+  expect(saved).toEqual([])
+})
+
+it('a turn with no mention reads nothing and touches nothing', async () => {
+  const { repo } = participants([owner])
+
+  expect(await inviteMentionedUsers({ content: '그냥 한 말', sessionId: 's1', domainId: 'dom-1', inviter: { id: 'me' }, participants: repo })).toEqual({
+    invited: []
+  })
+})
+
+describe('the pure parts', () => {
+  it('reads each mentioned id once, in the order they appear', () => {
+    expect(extractMentionUserIds(`${marker('a')} ${marker('b')} ${marker('a')}`)).toEqual(['a', 'b'])
+    expect(extractMentionUserIds(undefined)).toEqual([])
+  })
+
+  it('leaves out who is already here and who is asking', () => {
+    expect(newParticipantUserIds(['a', 'b', 'me'], ['b'], 'me')).toEqual(['a'])
+  })
+})

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

@@ -0,0 +1,121 @@
+/*
+ * Mentioning someone tells them (ADR-0071 decision 1, as amended by ADR-0073).
+ *
+ * The machinery existed in the board product only: `@name` in a board chat added a participant and
+ * sent them an invite, and the same `@name` in a twin deliberation added nobody. The person typing
+ * it had every reason to believe they had called a colleague in.
+ *
+ * ── What a mention is now ─────────────────────────────────────────────────────
+ * A conversation in the domain is open: anyone may walk in, with nothing to approve and nobody to
+ * ask (ADR-0073 decision 2). So a mention grants nothing — it points. It seats the named person so
+ * the conversation reaches their list, and it tells them their name came up. Somebody who was never
+ * mentioned can read the same room by opening it.
+ *
+ * Two rules survive the amendment:
+ *   ① only a door that stores **a person's turn** mentions — never the model, a tool, or the
+ *      assistant's own answer. What the assistant writes must not seat people.
+ *   ② whoever is named joins as a member and is told.
+ *
+ * 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.
+ */
+
+/** 본문에서 `@user{userId:UUID}` 마커의 userId 를 뽑는다 — 첫 등장 순, 중복 제거. */
+export function extractMentionUserIds(text: string | null | undefined): string[] {
+  if (!text) return []
+  const re = /\{userId:([^}\s]+)\}/g
+  const seen = new Set<string>()
+  const out: string[] = []
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text)) !== null) {
+    const id = m[1]
+    if (!seen.has(id)) {
+      seen.add(id)
+      out.push(id)
+    }
+  }
+  return out
+}
+
+/** 멘션된 사람 중 **아직 참여자가 아니고 자기 자신도 아닌** 새 사람만. */
+export function newParticipantUserIds(
+  mentioned: ReadonlyArray<string>,
+  existing: ReadonlyArray<string>,
+  selfUserId?: string | null
+): string[] {
+  const have = new Set(existing)
+  if (selfUserId) have.add(selfUserId)
+  const out: string[] = []
+  const seen = new Set<string>()
+  for (const id of mentioned) {
+    if (!id || have.has(id) || seen.has(id)) continue
+    seen.add(id)
+    out.push(id)
+  }
+  return out
+}
+
+export interface MentionInviteResult {
+  /** 이번에 새로 앉은 사람들. 알림은 이들에게 간다. */
+  invited: string[]
+  /** 비공개 대화라 앉히지 못한 사람들 — 이름은 불렸고 방에는 못 들어온다. 화면이 그대로 말한다. */
+  notSeated?: string[]
+}
+
+export interface MentionInviteInput {
+  /** 저장된 **사람의 말**. 어시스턴트의 답이나 도구 결과를 여기에 넘기지 않는다(조건 ①). */
+  content: string
+  sessionId: string
+  domainId: string
+  inviter: { id?: string } | undefined | null
+  /** 참여자 저장소 — 시험이 가짜를 넣는다. */
+  participants: any
+  /** 이 대화가 공개인가(ADR-0073 판정 2). 비공개면 이름만 알리고 앉히지 않는다. */
+  visibility?: string | null
+}
+
+/**
+ * 멘션된 사람을 참여자로 앉힌다.
+ *
+ * 나갔던 사람(soft delete)은 되살린다 — 다시 부른 것이지 새 사람이 아니다.
+ */
+export async function inviteMentionedUsers(input: MentionInviteInput): Promise<MentionInviteResult> {
+  const mentioned = extractMentionUserIds(input.content)
+  if (mentioned.length === 0) return { invited: [] }
+
+  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)
+  if (fresh.length === 0) return { invited: [] }
+
+  /*
+   * 비공개 대화에서는 이름을 불러도 앉히지 않는다. 공개 대화에서는 앉히는 일이 아무것도 주지 않지만
+   * (누구나 들어온다), 비공개에서는 그것이 곧 접근을 주는 일이다. 부르는 사람이 아니라 owner 가 열
+   * 일이다 — 이름이 불렸다는 것만 알린다.
+   */
+  if ((input.visibility ?? 'open') !== 'open') 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)
+    }
+  }
+
+  return { invited: fresh }
+}

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

@@ -15,6 +15,30 @@ import { In } from 'typeorm'
 import { ChatSession } from './chat-session/chat-session.js'
 import { anchorColumns, anchorWhere } from './chat-session/session-anchor.js'
 import { buildInbox, applyHidden, activityPatch, searchInbox, INBOX_SCAN_CAP } from './chat-session/session-inbox.js'
+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'
+
+/**
+ * 초대 알림 — 발송은 호스트의 기전을 그대로 쓴다(중복 구현 금지).
+ *
+ * 알림이 안 가도 초대 자체는 이미 일어났다. 그래서 실패를 삼키되, 초대를 되돌리지는 않는다 —
+ * 참여자 목록이 정본이고 알림은 그것을 알리는 편지다.
+ */
+async function notifyInvited(context: any, invited: string[], inviter: any): Promise<void> {
+  if (invited.length === 0) return
+  const payload = buildInviteNotification(invited, undefined, inviter)
+  if (!payload) return
+  try {
+    await context.state?.notify?.(payload)
+  } catch {
+    /* 편지가 못 갔다고 방에 들어온 사실이 취소되지는 않는다. */
+  }
+}
+import { formatProposalOutcomeLine, PROPOSAL_VERDICTS, type ProposalOutcome } from './chat-message/proposal-outcome.js'
 import { publishSessionActivity } from './chat-session/session-activity-publish.js'
 import { ChatMessage } from './chat-message/chat-message.js'
 import { ChatSessionParticipant } from './chat-session-participant/chat-session-participant.js'
@@ -31,6 +55,10 @@ class ChatSessionInboxEntry {
   @Field({ nullable: true, description: 'User-given session name (tab label).' })
   name?: string
 
+  /** 어느 대화인가 — 목록에서 고른 것이 지금 열린 대화와 다르면 화면이 그 대화로 따라간다. */
+  @Field({ nullable: true, description: 'Which conversation this session is — the registered mode kind.' })
+  kind?: string
+
   @Field({ nullable: true, description: "What the session is anchored to: 'board' | 'space' | 'instance' | 'none'." })
   anchorType?: string
 
@@ -46,6 +74,10 @@ class ChatSessionInboxEntry {
   @Field({ nullable: true, description: 'Short preview of the last message.' })
   lastMessagePreview?: string
 
+  /** 미리보기가 이 사람에게 가려져 나갔는가 — 목록도 대화와 같은 관문을 지난다(ADR-0073 판정 1). */
+  @Field({ nullable: true, description: 'True when the preview was replaced because this reader does not pass the doors of the message it came from.' })
+  previewRedacted?: boolean
+
   @Field({ nullable: true, description: 'Session creation timestamp.' })
   createdAt?: Date
 
@@ -206,7 +238,22 @@ export class ChatSessionResolver {
       mine: createdByMe.has(entry.id)
     }))
     /* showHidden=true 로 불러 **전체**를 얻는다 — 숨김 여부 판정을 두 곳에 복제하지 않기 위함. */
-    return applyHidden(entries as any, hiddenAt, true) as any
+    const shown = applyHidden(entries as any, hiddenAt, true) as any[]
+
+    /*
+     * 목록도 같은 관문을 지난다 — ADR-0073 판정 1. 미리보기는 그 답을 **다시 읽는 두 번째 길**이고,
+     * 한 길만 막으면 같은 문장이 다른 길로 그대로 나간다. 미리보기 자리를 `content` 로 바꿔 넣고
+     * 가려진 것만 되돌려 담는다.
+     */
+    const gate = readerGate(context)
+    const judged = await gate(
+      shown.map(entry => ({ doors: entry.lastMessageDoors, content: entry.lastMessagePreview ?? '' }))
+    )
+    return shown.map((entry, index) => ({
+      ...entry,
+      lastMessagePreview: judged[index].content,
+      previewRedacted: (judged[index] as any).redacted === true
+    })) as any
   }
 
   /**
@@ -297,6 +344,52 @@ export class ChatSessionResolver {
    * 변경은 **meta 활동**으로 방송한다 — 모든 참여자 목록에 즉시 반영되지만 안 읽음 배지는 올리지 않는다
    * (이름 변경을 "새 소식" 으로 알리면 소음이다).
    */
+  /**
+   * 이 대화를 도메인 안 누구나 읽게 할 것인가 — ADR-0073 판정 2.
+   *
+   * owner 만 바꾼다. 이름 바꾸기는 어느 참여자나 하지만(되돌릴 수 있고 값을 드러내지 않는다), 공개로
+   * 바꾸는 일은 이미 쓰인 글을 도메인 전체에 여는 일이다 — 되돌려도 읽힌 것은 읽힌 것이다.
+   *
+   * 화면은 공개로 바꾸기 전에 한 줄을 먼저 보인다(문구는 클라이언트가 가진다). 그 한 줄은 이 문이
+   * 강제하지 않는다 — 문이 막을 수 있는 것은 누가 바꾸느냐까지다.
+   */
+  @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)."
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation")')
+  async setSessionVisibility(
+    @Arg('sessionId') sessionId: string,
+    @Arg('visibility') visibility: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, user } = context.state
+    if (!SESSION_VISIBILITIES.includes(visibility as any)) {
+      throw new Error(`unknown visibility '${visibility}' — use ${SESSION_VISIBILITIES.join(' or ')}`)
+    }
+
+    const session = await getRepository(ChatSession).findOneBy({ id: sessionId, domain: { id: domain.id } as any })
+    if (!session) 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') return false
+
+    if ((session as any).visibility === visibility) return true
+
+    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
+    } as any)
+    return true
+  }
+
   @Mutation(() => Boolean, {
     description:
       'Rename a chat session. Any participant may rename it — the name is the topic label of a shared deliberation and the change is reversible. Broadcast as meta activity so every participant sees it without raising unread badges.'
@@ -354,7 +447,7 @@ export class ChatSessionResolver {
 
   @Query(() => [User], {
     description:
-      'List users in the current domain for `@` mention popup. board-ai 권한이면 누구나 멘션용 검색 가능 (관리자 전용 users() 와 별도).'
+      'List users in the current domain for the `@` mention popup. Anyone with the chat privilege may search here; this is separate from the admin-only users().'
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "query")')
   async domainUsersForMention(
@@ -415,13 +508,25 @@ export class ChatSessionResolver {
     @Arg('offset', () => Int, { nullable: true, defaultValue: 0 }) offset: number,
     @Ctx() context: ResolverContext
   ): Promise<ChatMessage[]> {
-    const { domain } = context.state
+    const { domain, user } = context.state
     const session = await getRepository(ChatSession).findOneBy({
       id: sessionId,
       domain: { id: domain.id }
     })
     if (!session) return []
-    return await getRepository(ChatMessage).find({
+
+    /*
+     * 공개 대화는 도메인 안이면 누구나 읽는다 — 초대 절차가 없다(ADR-0073 판정 2). 비공개 대화는
+     * 참여자만. 여기서 막히는 것은 **방**이고, 방에 들어온 뒤 값을 읽는 일은 아래 문 판정이 따로 본다.
+     */
+    if ((session as any).visibility === 'private') {
+      const part = await getRepository(ChatSessionParticipant).findOne({
+        where: { session: { id: sessionId } as any, user: { id: user.id } as any, domain: { id: domain.id } as any }
+      })
+      if (!mayReadSession((session as any).visibility, !!part)) return []
+    }
+
+    const rows = await getRepository(ChatMessage).find({
       where: { session: { id: sessionId } as any },
       // creator: 그룹챗 발신자 표시(name) + 자기 여부 판정(email). 내부 관리키(id)에 의존하지 않는다.
       relations: { creator: true },
@@ -429,6 +534,12 @@ export class ChatSessionResolver {
       take: limit,
       skip: offset
     })
+
+    /*
+     * 어시스턴트의 답은 도구 결과를 평문으로 옮겨 적은 것이다. 읽는 사람이 그 도구가 지난 문을 못 지나면
+     * 본문 대신 한 줄이 나간다 — 행이 있다는 사실은 보이고 값만 안 보인다(ADR-0073 판정 1).
+     */
+    return await readerGate(context)(rows)
   }
 
   @Directive('@transaction')
@@ -451,6 +562,8 @@ export class ChatSessionResolver {
     const session = await repo.save({
       domain,
       ...anchorColumns(anchorType, anchorId),
+      /* 앵커가 있는 대화는 공개로 태어난다 — ADR-0073 판정 2. */
+      visibility: initialVisibility({ anchorType }),
       creator: user,
       updater: user
     } as any)
@@ -469,13 +582,13 @@ export class ChatSessionResolver {
   @Directive('@transaction')
   @Mutation(() => ChatSession, {
     description:
-      'Always create a new AI chat session anchored to a target (no idempotent reuse). For multi-session UX — 새 탭 열기.'
+      'Always create a new AI chat session anchored to a target (no idempotent reuse). For multi-session UX — opening another tab.'
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "mutation")')
   async createAISession(
     @Arg('anchorType') anchorType: string,
     @Arg('anchorId') anchorId: string,
-    @Arg('name', { nullable: true, description: 'Optional name (defaults to auto-generated `세션 N`).' }) name: string | undefined,
+    @Arg('name', { nullable: true, description: 'Optional name. Defaults to a generated one, numbered within the anchor.' }) name: string | undefined,
     @Ctx() context: ResolverContext
   ): Promise<ChatSession> {
     const { domain, user, tx } = context.state
@@ -485,12 +598,14 @@ export class ChatSessionResolver {
     let finalName = name?.trim()
     if (!finalName) {
       const count = await repo.count({ where: anchorWhere(domain.id, anchorType, anchorId) })
-      finalName = `세션 ${count + 1}`
+      /* The name is stored, so it is written in the language of whoever created it (context.t), and read back as is. */
+      finalName = context.t('ai-assistant.session.default-name', { n: count + 1, defaultValue: 'conversation {n}' })
     }
 
     const session = await repo.save({
       domain,
       ...anchorColumns(anchorType, anchorId),
+      visibility: initialVisibility({ anchorType }),
       creator: user,
       updater: user,
       name: finalName
@@ -525,6 +640,124 @@ export class ChatSessionResolver {
     return true
   }
 
+  @Directive('@transaction')
+  @Mutation(() => Boolean, {
+    description:
+      "What the host did with a proposal the assistant made. The host calls this once per card it was asked to run; the server records it as a system row, so the panel shows it, a refreshed panel still shows it, and the model reads on its next turn that its proposal was refused instead of assuming it landed (ADR-0070)."
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation")')
+  async reportProposalOutcome(
+    @Arg('sessionId') sessionId: string,
+    @Arg('proposalKey') proposalKey: string,
+    @Arg('outcome', () => GraphQLJSON) outcome: ProposalOutcome,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, user, tx } = context.state
+    const session = await getRepository(ChatSession, tx).findOneBy({ id: sessionId, domain: { id: domain.id } })
+    if (!session) throw new Error(`ChatSession ${sessionId} not found`)
+
+    const key = (proposalKey ?? '').trim()
+    if (!key) return false
+
+    /*
+     * 낱말은 ADR-0042 의 것에 `declined` 하나다. 모르는 낱말을 받으면 그대로 적지 않는다 — 카드가
+     * 읽지 못하는 상태가 되고, 그때 화면은 아무 말도 못 한다.
+     */
+    if (!PROPOSAL_VERDICTS.includes(outcome?.verdict as any)) {
+      throw new Error(
+        `[ai-assistant] '${outcome?.verdict}' is not a proposal verdict. Use one of ${PROPOSAL_VERDICTS.join(', ')}.`
+      )
+    }
+
+    const body = formatProposalOutcomeLine(key, outcome)
+
+    const previousLast = await getRepository(ChatMessage, tx).findOne({
+      where: { session: { id: session.id } as any },
+      order: { createdAt: 'DESC' }
+    })
+    const sysMsg = await getRepository(ChatMessage, tx).save({
+      session: { id: session.id } as any,
+      role: 'system',
+      content: body,
+      creator: user,
+      updater: user,
+      parentMessage: previousLast ? ({ id: previousLast.id } as any) : undefined
+    } as any)
+
+    /* 목록의 미리보기는 사람의 말로 두는 편이 낫다 — 이 줄은 기계의 기록이다. 방송만 한다. */
+    publishChatMessage({ domainId: domain.id, sessionId: session.id, message: sysMsg })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(() => String, {
+    nullable: true,
+    description:
+      "Say something to the people in this session. The turn is stored as the speaker's, addressed to the room, and the assistant is not called — it reads the line as context the next time someone asks it something. Returns the stored message id, or null when there was nothing to say (ADR-0070)."
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation")')
+  async sayToRoom(
+    @Arg('sessionId') sessionId: string,
+    @Arg('content') content: string,
+    @Ctx() context: ResolverContext
+  ): Promise<string | null> {
+    const { domain, user, tx } = context.state
+    const session = await getRepository(ChatSession, tx).findOneBy({ id: sessionId, domain: { id: domain.id } })
+    if (!session) throw new Error(`ChatSession ${sessionId} not found`)
+
+    const body = roomMessageBody(content)
+    if (!body) return null
+
+    const previousLast = await getRepository(ChatMessage, tx).findOne({
+      where: { session: { id: session.id } as any },
+      order: { createdAt: 'DESC' }
+    })
+    const saved = await getRepository(ChatMessage, tx).save({
+      session: { id: session.id } as any,
+      role: 'user',
+      content: body,
+      /* 대상은 문이 정한다 — 이 문은 사람들에게 하는 말이다(ADR-0070 A15 결정 ①). */
+      addressee: 'room',
+      creator: user,
+      updater: user,
+      parentMessage: previousLast ? ({ id: previousLast.id } as any) : undefined
+    } as any)
+
+    /*
+     * 멘션은 사람을 불러들인다 — **사람의 말을 저장하는 문**만 이것을 한다(ADR-0071 결정 1 ①).
+     * 초대는 방에 있는 사람(owner · member)만 할 수 있고, 거절되면 그 사실이 화면으로 돌아간다.
+     */
+    const invite = await inviteMentionedUsers({
+      content: body,
+      sessionId: session.id!,
+      domainId: domain.id,
+      inviter: user,
+      participants: getRepository(ChatSessionParticipant, tx),
+      /* 비공개 대화에서는 이름만 닿는다 — ADR-0073 판정 2. */
+      visibility: (session as any).visibility
+    })
+    await notifyInvited(context, invite.invited, user)
+
+    /* 사람의 말이다 — 목록의 최근 활동과 다른 참여자의 안 읽음이 이것으로 움직인다. */
+    try {
+      await getRepository(ChatSession, tx).update(session.id!, activityPatch(body) as any)
+    } catch {
+      /* 목록이 한 박자 늦는 것이 말을 못 하게 할 이유는 아니다. */
+    }
+    publishSessionActivity({
+      domainId: domain.id,
+      sessionId: session.id!,
+      kind: 'message',
+      anchorType: (session as any).anchorType,
+      anchorId: (session as any).anchorId,
+      preview: body,
+      actorId: user?.id
+    })
+    publishChatMessage({ domainId: domain.id, sessionId: session.id, message: saved })
+
+    return saved.id ?? null
+  }
+
   @Directive('@transaction')
   @Mutation(() => Boolean, {
     description:
@@ -578,7 +811,7 @@ export class ChatSessionResolver {
   @Directive('@transaction')
   @Mutation(() => Boolean, {
     description:
-      'Carry a conversation from another surface into this session as its own turns (user / assistant), preserving order. Use when a lightweight exchange is promoted into a persistent discussion — the participants should read it as the conversation continuing, not as a machine dump.'
+      "Carry a conversation from another surface into this session as its own turns, preserving order. A person's turns are stored as theirs, addressed to the room. An assistant turn is stored as the assistant's only when it names its original (sourceSessionId, sourceMessageId) and the server can read it; otherwise it is kept as a quotation on a system row — roles are the server's to write (ADR-0070)."
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "mutation")')
   async appendSessionTurns(
@@ -593,13 +826,34 @@ export class ChatSessionResolver {
     /* 옮겨온 대화는 **그 대화의 발언 그대로** 들어간다 — 한 덩어리 기록으로 뭉치면 사람이 읽을 수 없고
      * (화면 하나를 잡아먹는 이탤릭 덩어리), 마크다운도 죽는다. 대신 개수·길이는 제한한다: 맥락 전달이
      * 목적이고 전문 보존이 아니다. */
-    const rows = (Array.isArray(turns) ? turns : [])
-      .map(t => ({
-        role: t?.role === 'ai' || t?.role === 'assistant' ? 'assistant' : t?.role === 'user' ? 'user' : 'system',
-        content: (t?.content ?? '').trim().slice(0, 4000)
-      }))
-      .filter(t => t.content)
-      .slice(-40)
+    /* **역할은 서버가 쓴다**(ADR-0070 A15 결정 ③). 어시스턴트의 답은 원본을 읽어 복사하고, 원본이 없으면
+     * 인용문으로 `system` 행에 남긴다 — 클라이언트가 보낸 글자를 어시스턴트의 말로 저장하지 않는다. */
+    const planned = planCarriedTurns(turns as any)
+    const rows: { role: string; content: string; addressee?: string; doors?: string[] }[] = []
+    /* 옮겨 적힌 원문이 소급해서 공개되지 않게, 받는 대화는 이 순간부터 비공개다 — ADR-0073 판정 2. */
+    let carried = false
+    for (const row of planned) {
+      if (!row.copyOf) {
+        rows.push({ role: row.role, content: row.content, addressee: row.addressee })
+        continue
+      }
+      /* 원본은 이 테넌트 안에서만 찾는다 — 남의 도메인 메시지를 옮겨 오는 길이 되지 않게. */
+      const original = await getRepository(ChatMessage, tx).findOne({
+        where: carriedOriginalWhere(domain.id, row.copyOf),
+        relations: ['session']
+      })
+      carried = true
+      if (original && original.role === 'assistant') {
+        /*
+         * 답과 함께 **그 답이 지나온 문**을 옮긴다 — ADR-0073 판정 1. 문을 두고 글만 옮기면, 문 하나를
+         * 지나 얻은 값이 문 없는 행이 되어 아무나 읽는다. 옮겨 적기가 권한을 씻는 길이 된다.
+         */
+        rows.push({ role: 'assistant', content: original.content, doors: (original as any).doors ?? [] })
+      } else {
+        /* 인용문에도 원문의 문을 실어 둔다 — 인용이라고 값이 달라지지 않는다. */
+        rows.push({ role: 'system', content: quoteCarriedAnswer(row.content), doors: (original as any)?.doors ?? [] })
+      }
+    }
     if (!rows.length) return false
 
     let previous = await getRepository(ChatMessage, tx).findOne({
@@ -612,6 +866,9 @@ export class ChatSessionResolver {
         session: { id: session.id } as any,
         role: row.role,
         content: row.content,
+        /* 사람의 말은 방을 향한 것이다 — 이 문은 어시스턴트를 부르는 문이 아니다. */
+        addressee: row.addressee,
+        doors: row.doors,
         creator: user,
         updater: user,
         parentMessage: previous ? ({ id: previous.id } as any) : undefined
@@ -619,6 +876,10 @@ export class ChatSessionResolver {
       saved.push(previous!)
     }
 
+    if (carried && (session as any).visibility !== 'private') {
+      await getRepository(ChatSession, tx).update(session.id!, { visibility: 'private', updater: user } as any)
+    }
+
     /* 활동은 마지막 발언 기준 한 번만 — 옮긴 줄마다 목록을 흔들 이유가 없다. */
     const last = rows[rows.length - 1]
     try {