@things-factory/ai-assistant 10.1.207 → 10.1.210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.207",
+  "version": "10.1.210",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -30,18 +30,18 @@
     "@operato/graphql": "^10.29.39",
     "@operato/i18n": "^10.0.0",
     "@operato/input": "^10.29.39",
-    "@operato/layout": "^10.29.39",
+    "@operato/layout": "^10.29.49",
     "@operato/popup": "^10.29.39",
     "@operato/shell": "^10.29.39",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.39",
-    "@things-factory/ai-client-base": "^10.1.207",
-    "@things-factory/apptool-base": "^10.1.206",
-    "@things-factory/attachment-base": "^10.1.206",
-    "@things-factory/auth-base": "^10.1.206",
+    "@things-factory/ai-client-base": "^10.1.208",
+    "@things-factory/apptool-base": "^10.1.208",
+    "@things-factory/attachment-base": "^10.1.208",
+    "@things-factory/auth-base": "^10.1.208",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.206",
-    "@things-factory/shell": "^10.1.206",
+    "@things-factory/setting-base": "^10.1.208",
+    "@things-factory/shell": "^10.1.208",
     "dompurify": "^3.0.0",
     "exceljs": "4.2.0",
     "graphql-scalars": "^1.22.0",
@@ -55,5 +55,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "e6e3fbf5c353629adbeb8850093150b14254e059"
+  "gitHead": "89fbda12d43d8532ba4e95ba6d6d7e05e2da2502"
 }

package/server/explicit-graphql-types.test.ts

@@ -8,7 +8,7 @@
  * 컴파일은 통과하므로 타입검사도 못 잡는다. plant 레인이 설치본을 올리다 잡아 알려 주었다(2026-09-18).
  *
  * ── 왜 스키마를 안 세우고 글자를 읽나 ─────────────────────────────────────
- * 이 꾸러미의 시험기는 babel 이라 데코레이터 metadata 가 없다. 스키마를 세우면 리플렉션이 없어 전부
+ * 이 패키지의 시험기는 babel 이라 데코레이터 metadata 가 없다. 스키마를 세우면 리플렉션이 없어 전부
  * 같은 오류가 나고, 그러면 이 시험은 아무것도 못 가른다. 대신 선언을 읽는다 — 데코레이터가 형을
  * 인자로 받고 있는지만 본다. 그것이 빠진 자리가 정확히 터지는 자리다.
  */

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

@@ -45,8 +45,8 @@ import { ChatSessionParticipant } from './chat-session-participant/chat-session-
 import { doorsForAnswer } from './chat-message/message-doors.js'
 import { judgeSessionKind } from './chat-session/session-kind.js'
 import { readerGate } from './chat-message/reader-gate.js'
-import { inviteMentionedUsers } from './chat-session-participant/mention-invite.js'
-import { buildInviteNotification } from './chat-session-participant/invite-notification.js'
+import { seatTurn } from './chat-session-participant/mention-invite.js'
+import { sendInviteNotification } from './chat-session-participant/invite-notification.js'
 import { isSessionParticipant } from './chat-session-participant/participant-lookup.js'
 import { assertMayWriteSession } from './chat-session/session-write-gate.js'
 import { attachmentHistoryLine, refuseAttachments, textCharsOf } from './chat-session/attachment-policy.js'
@@ -383,9 +383,10 @@ export class AssistantChatResolver {
 
       /*
        * 사람이 `@이름` 으로 부른 사람은 이 대화에 들어온다(ADR-0071 결정 1). 이 문은 **사람의 턴**을
-       * 저장하는 문이라 그 일을 한다 — 모델의 답이나 도구 결과는 아무도 초대하지 않는다.
+       * 저장하는 문이라 그 일을 한다 — 모델의 답이나 도구 결과는 아무도 초대하지 않는다. 공개 방에서 말한 사람도
+       * 이때 자리에 앉는다(`seatTurn`) — 참여자 줄 · 접속 표시 · 안 읽음이 실제로 말한 사람과 맞도록.
        */
-      const invite = await inviteMentionedUsers({
+      const invite = await seatTurn({
         content: lastUserMessage.content,
         sessionId: session.id!,
         domainId: domain.id,
@@ -393,14 +394,8 @@ export class AssistantChatResolver {
         participants: getRepository(ChatSessionParticipant),
         visibility: (session as any).visibility
       })
-      if (invite.invited.length > 0) {
-        const payload = buildInviteNotification(invite.invited, undefined, user, (session as any)?.name)
-        try {
-          if (payload) await (context.state as any)?.notify?.(payload)
-        } catch {
-          /* 편지가 못 갔다고 방에 들어온 사실이 취소되지는 않는다. */
-        }
-      }
+      /* 편지가 못 갔다고 방에 들어온 사실이 취소되지는 않는다(`sendInviteNotification`). */
+      await sendInviteNotification((context.state as any)?.notify, invite.invited, user, (session as any)?.name, undefined, requestTranslator(context))
 
       publishChatMessage({ domainId: domain.id, sessionId: session.id, message: saved } as any)
       publishSessionActivity({

package/server/service/assistant-mode/index.ts

@@ -12,6 +12,6 @@ export {
   clearAssistantModes
 } from './registry.js'
 export { resolveModeSettings, assistantModeView } from './resolve.js'
-export { ABSENCE_RULE, NEXT_REQUEST_RULE, conversationPrompt, splitNextRequest } from './screen-rules.js'
+export { ABSENCE_RULE, FINISH_RULE, NEXT_REQUEST_RULE, SPEAKER_RULE, conversationPrompt, isPersonRequest, splitNextRequest } from './screen-rules.js'
 export type { AssistantModeSpec, AssistantModeSlash, AssistantModeWarning, UnattendedLimits } from './types.js'
 export type { AssistantModeRef, ModeSettings, AssistantModeView, AssistantModeSlashView, Translate } from './resolve.js'

package/server/service/assistant-mode/mode-categories.ts

@@ -1,5 +1,6 @@
 /* Read by the resolver and by the boot report, so the report and the conversation open the same tools. */
-import { readTargetOf } from '../data-read/read-target.js'
+import { entryTargetOf } from '../data-entry/entry-target.js'
+import { detailReadOf, readTargetOf } from '../data-read/read-target.js'
 /**
  * The categories a mode opens: its own, the AI 작업판 (design/ai/workspace.md), the attachment reader when it
  * takes files (design/ai/shared-dock.md §9-4), and one propose tool per record it may enter (design/ai/data-entry.md).
@@ -42,7 +43,14 @@ type FrontMode = { toolCategories?: string[]; attachments?: { kinds?: string[] }
  */
 export function screenTargetKeys(mode: FrontMode, screen: TurnScreen, routeOf: (key: string) => string | undefined = key => readTargetOf(key)?.screen?.route): string[] {
   const keys = [...new Set([...(mode.readTargets ?? []), ...(mode.entryTargets ?? [])])]
-  return keys.filter(key => (!!screen.page && routeOf(key) === screen.page) || (!!screen.subjectAxis && key.split('.').pop() === screen.subjectAxis))
+  return keys.filter(key => (!!screen.page && routeOf(key) === screen.page) || (!!screen.subjectAxis && axesOfKey(mode, key).includes(screen.subjectAxis)))
+}
+
+/** The records a key is about: its last part, and the axes a card joins or a whole answer covers (EntryTarget.axes · DetailRead.axes). */
+function axesOfKey(mode: FrontMode, key: string): string[] {
+  const card = (mode.entryTargets ?? []).includes(key) ? entryTargetOf(key)?.axes ?? [] : []
+  const answer = (mode.readTargets ?? []).includes(key) ? detailReadOf(key)?.axes ?? [] : []
+  return [key.split('.').pop()!, ...card, ...answer]
 }
 
 /**
@@ -66,6 +74,6 @@ export function modeFrontCategories(mode: FrontMode, screen: TurnScreen = {}): s
 export function modeScreens(mode: FrontMode, routeOf: (key: string) => string | undefined = key => readTargetOf(key)?.screen?.route): TurnScreen[] {
   const keys = [...new Set([...(mode.readTargets ?? []), ...(mode.entryTargets ?? [])])]
   const pages = [...new Set(keys.map(routeOf).filter(Boolean) as string[])]
-  const axes = [...new Set(keys.map(key => key.split('.').pop()!))]
+  const axes = [...new Set(keys.flatMap(key => axesOfKey(mode, key)))]
   return [{}, ...pages.map(page => ({ page })), ...axes.map(subjectAxis => ({ subjectAxis }))]
 }

package/server/service/assistant-mode/mode-front.test.ts

@@ -2,9 +2,10 @@
  * What a turn puts in front when its mode's tools do not fit in one call (ADR-0061 decision 9) - the open screen's
  * records, found from what is already declared: a list's screen route and a key's last part.
  */
-import { clearReadTargets, declareReadTarget } from '../data-read/read-target'
+import { clearReadTargets, declareDetailRead, declareReadTarget } from '../data-read/read-target'
 import { listReadTarget } from '../data-read/list-read'
 import { modeFrontCategories, modeScreens, screenTargetKeys } from './mode-categories'
+import { clearEntryTargets, declareEntryTarget } from '../data-entry/entry-target'
 
 const list = (key: string, route?: string) =>
   listReadTarget({ key, title: `title.${key}`, name: key, listQuery: 'rows', selection: 'id name', columns: [{ name: 'name', type: 'string' }], ...(route ? { route } : {}) } as any)
@@ -63,3 +64,54 @@ describe('the open screen decides what goes in front', () => {
     ])
   })
 })
+
+/* 2026-10-24: asked to link a deposit from its 360, the model read the evidence and never opened the link card. */
+describe('a card about several records is in front on each of their screens', () => {
+  const link = {
+    key: 'office.tax-invoice-binding',
+    labelKey: 'label.link',
+    description: 'a link of an invoice to a bank line or a round.',
+    mutation: 'mutation ($binding: Binding!) { bind(binding: $binding) { id } }',
+    variables: (row: any) => ({ binding: row.values }),
+    appliedOf: (data: any) => ({ id: data?.bind?.id }),
+    fields: [{ name: 'amount', type: 'number' as const, required: true }],
+    axes: ['cash-transaction', 'tax-invoice', 'contract-round']
+  }
+  const linking = { ...mode, entryTargets: [...mode.entryTargets, link.key] }
+  beforeEach(() => {
+    clearEntryTargets()
+    declareEntryTarget(link as any)
+  })
+
+  it('★ a deposit\'s 360 puts the link card in front with the deposit\'s own', () => {
+    expect(screenTargetKeys(linking, { subjectAxis: 'cash-transaction' })).toEqual(['office.cash-transaction', 'office.tax-invoice-binding'])
+    expect(modeFrontCategories(linking, { subjectAxis: 'cash-transaction' })).toContain('data-entry:office.tax-invoice-binding')
+    expect(screenTargetKeys(linking, { subjectAxis: 'contract-round' })).toEqual(['office.contract-round', 'office.tax-invoice-binding'])
+  })
+
+  it('★ not on a screen of a record it does not join, and not for a mode that does not enter it', () => {
+    expect(screenTargetKeys(linking, { subjectAxis: 'contract' })).toEqual(['office.contract'])
+    expect(screenTargetKeys(mode, { subjectAxis: 'cash-transaction' })).toEqual(['office.cash-transaction'])
+  })
+
+  it('the boot report walks the axes a card declares, so its screens are counted against the budget', () => {
+    expect(modeScreens(linking)).toContainEqual({ subjectAxis: 'tax-invoice' })
+  })
+})
+
+/* 2026-10-24: asked on a deposit's 360 why it was in the management check, the model never opened the check read. */
+describe('a whole answer about any record is in front on their screens', () => {
+  const checks = { key: 'office.checks', description: 'the management check.', query: 'query { officeChecks { today } }', axes: ['cash-transaction', 'contract'] }
+  const reading = { ...mode, readTargets: [...mode.readTargets, checks.key] }
+  beforeEach(() => declareDetailRead(checks as any))
+
+  it('★ the check read is in front on a deposit\'s and a contract\'s 360', () => {
+    expect(modeFrontCategories(reading, { subjectAxis: 'cash-transaction' })).toContain('data-read:office.checks')
+    expect(modeFrontCategories(reading, { subjectAxis: 'contract' })).toContain('data-read:office.checks')
+  })
+
+  it('★ not on a record it does not cover, nor for a mode that does not read it', () => {
+    expect(modeFrontCategories(reading, { subjectAxis: 'expense-line' })).not.toContain('data-read:office.checks')
+    expect(modeFrontCategories(mode, { subjectAxis: 'cash-transaction' })).not.toContain('data-read:office.checks')
+  })
+})

package/server/service/assistant-mode/resolve.test.ts

@@ -8,7 +8,7 @@
  */
 import { clearAssistantModes, registerAssistantMode } from './registry'
 import { assistantModeView, resolveModeSettings } from './resolve'
-import { ABSENCE_RULE, NEXT_REQUEST_RULE, conversationPrompt } from './screen-rules'
+import { ABSENCE_RULE, FINISH_RULE, NEXT_REQUEST_RULE, conversationPrompt } from './screen-rules'
 
 /** Stands in for `context.t` — returns the key and params so the test can see what was translated. */
 const t = (key: string, params?: Record<string, any>) => `t(${key}${params?.count !== undefined ? `,${params.count}` : ''})`
@@ -48,6 +48,7 @@ it('★ every conversation carries the absence rule and the next-request rule on
   expect(systemPrompt.startsWith('you answer about one space')).toBe(true)
   expect(systemPrompt.split(ABSENCE_RULE)).toHaveLength(2)
   expect(systemPrompt.split(NEXT_REQUEST_RULE)).toHaveLength(2)
+  expect(systemPrompt.split(FINISH_RULE)).toHaveLength(2)
 })
 
 it('★ an unregistered kind is refused — no plain-conversation fallback', () => {

package/server/service/assistant-mode/screen-rules.test.ts

@@ -1,7 +1,7 @@
 /*
  * The rules every conversation follows (operato-application design/ai/screen-pattern.md §4).
  */
-import { ABSENCE_RULE, NEXT_REQUEST_RULE, conversationPrompt, splitNextRequest } from './screen-rules'
+import { ABSENCE_RULE, FINISH_RULE, NEXT_REQUEST_RULE, SPEAKER_RULE, conversationPrompt, isPersonRequest, splitNextRequest } from './screen-rules'
 
 describe('the next request an answer names', () => {
   it('★ the last line is taken off the reply and becomes the suggestion', () => {
@@ -24,16 +24,54 @@ describe('the next request an answer names', () => {
     expect(splitNextRequest('It has 3 blades.')).toEqual({ reply: 'It has 3 blades.' })
   })
 
+  /* 2026-10-23, an office link: the input offered a sentence telling the person what to say, with the invoice's key in it. */
+  it('★ a line that tells the person what to say is taken off and offered as nothing', () => {
+    const answer = '계산서 연결 후보를 찾았습니다.'
+    const line = 'Next: "2026-01-20 계산서(tax-invoice:fe0e8503-ec5f-4da4-9c07-2d342c93d498)로 연결 제안 진행해줘”라고 해줘.'
+    expect(splitNextRequest(`${answer}\n${line}`)).toEqual({ reply: answer })
+    expect(splitNextRequest(`${answer}\nNext: "연결 진행해줘"라고 말해 주세요`)).toEqual({ reply: answer })
+    expect(splitNextRequest(`${answer}\nNext: 「연결해 줘」라고 해 줘`)).toEqual({ reply: answer })
+  })
+
+  it('★ a line that carries an id or a record key is no request - nobody types one', () => {
+    expect(splitNextRequest('Found it.\nNext: tax-invoice:fe0e8503-ec5f 로 연결해 줘')).toEqual({ reply: 'Found it.' })
+    expect(splitNextRequest('Found it.\nNext: fe0e8503-ec5f-4da4-9c07-2d342c93d498 계산서로 연결해 줘')).toEqual({ reply: 'Found it.' })
+  })
+
+  it('a request in the person\'s words is offered, apostrophes and numbers included', () => {
+    expect(isPersonRequest("Show me last month's deposits")).toBe(true)
+    expect(isPersonRequest('2026-01 승화푸드 입금 550,000원도 연결해 줘')).toBe(true)
+    expect(isPersonRequest('')).toBe(false)
+  })
+
   it('a reply that is only the line keeps it - an empty answer is worse than an odd one', () => {
     expect(splitNextRequest('Next: 날개를 늘려 줘')).toEqual({ reply: 'Next: 날개를 늘려 줘' })
   })
 })
 
 describe('the prompt every conversation gets', () => {
-  it('★ the persona first, then the absence rule and the next-request rule', () => {
+  it('★ the persona first, then the absence rule, the finish rule and the next-request rule', () => {
     const prompt = conversationPrompt('You edit figures.')
     expect(prompt.indexOf('You edit figures.')).toBe(0)
     expect(prompt.indexOf(ABSENCE_RULE)).toBeGreaterThan(0)
-    expect(prompt.indexOf(NEXT_REQUEST_RULE)).toBeGreaterThan(prompt.indexOf(ABSENCE_RULE))
+    expect(prompt.indexOf(FINISH_RULE)).toBeGreaterThan(prompt.indexOf(ABSENCE_RULE))
+    expect(prompt.indexOf(NEXT_REQUEST_RULE)).toBeGreaterThan(prompt.indexOf(FINISH_RULE))
+  })
+
+  /* What the two rules must keep saying - a softer wording let the model ask before a card and hand the person a script. */
+  it('★ a card is proposed in the turn, never asked about; the next request is the person\'s own words', () => {
+    expect(FINISH_RULE).toMatch(/in the same turn/)
+    expect(FINISH_RULE).toMatch(/never ask whether to propose it/)
+    expect(FINISH_RULE).toMatch(/never ask the person to confirm, repeat or resend/)
+    expect(FINISH_RULE).toMatch(/no internal ids, keys, field names or codes/)
+    expect(NEXT_REQUEST_RULE).toMatch(/no quotation marks/)
+    expect(NEXT_REQUEST_RULE).toMatch(/Never a yes to your own question/)
+    expect(NEXT_REQUEST_RULE).toMatch(/no ids or keys/)
+    /* 2026-10-24, gpt-5.4-nano answering in Korean wrote 「다음:」 - the line stayed in the answer. */
+    expect(NEXT_REQUEST_RULE).toMatch(/the word Next: in English whatever language you answer in/)
+    /* 2026-10-24: the asker's name in the message's [writer → addressee] bracket was searched as a counterparty. */
+    expect(conversationPrompt('x')).toContain(SPEAKER_RULE)
+    expect(SPEAKER_RULE).toMatch(/\[writer → addressee\]/)
+    expect(SPEAKER_RULE).toMatch(/Never search for, filter by or fill a field with the writer's name/)
   })
 })

package/server/service/assistant-mode/screen-rules.ts

@@ -13,18 +13,56 @@ export const ABSENCE_RULE =
   'When a tool says something is absent or refuses, state that and what the person can do. ' +
   'Do not guess why, and do not describe our machinery - words like passed, delivered or loaded name our plumbing, not their situation.'
 
+/**
+ * §4-3 — a request is finished in the turn it is asked (2026-10-23, the user: 「한번에 끝낼 일을 왜 자꾸 확인하고, 프롬프트를
+ * 또 입력하게 만드는가」). Asked to link a deposit, the model found the invoice, then asked whether to propose the link
+ * and offered 「…진행해줘"라고 해줘」 as the next request - a second turn for what the first could do. A proposal card is
+ * the person's review; asking before it is asking twice.
+ */
+export const FINISH_RULE =
+  'Finish what was asked in this turn: read what it needs and, when it changes records, propose the card in the same turn - ' +
+  'the card is the person\'s review, so never ask whether to propose it, and never ask the person to confirm, repeat or ' +
+  'resend the request. Do not ask for an id, a number or a name your tools can read. Ask only when the records leave a ' +
+  'choice that only the person can make, and then ask just that choice. Answer briefly: what was found and what the card ' +
+  'does, in the person\'s words - no internal ids, keys, field names or codes.'
+
+/**
+ * Who spoke, never what was asked (ADR-0070 A15 decision 2 labels every person's message `[writer → addressee]`, a
+ * conversation of one included). Asked 「거래처 미등록 입출금에 등록 거래처를 연결해 줘」, the model read the asker's name in
+ * that bracket as part of the request and searched the bank lines for it (2026-10-24).
+ */
+export const SPEAKER_RULE =
+  "A person's message begins with [writer → addressee]: it says who wrote it and to whom, nothing more. Never search for, " +
+  'filter by or fill a field with the writer\'s name unless the request itself names them.'
+
 /** The line a reply ends with when a next request is natural (§4-1). */
 const NEXT_PREFIX = 'Next:'
 
 /** §4-1 — the reply names the next request, and the input offers it. */
 export const NEXT_REQUEST_RULE =
-  `After answering, when there is a natural next request, end the reply with one last line "${NEXT_PREFIX} <request>": ` +
-  "the request the person is most likely to make next, written as they would type it, in the language they wrote in. " +
-  'Offer only what this conversation can do with its tools. When nothing natural follows, leave the line out.'
+  `After answering, when there is a natural next request, end the reply with one last line "${NEXT_PREFIX} <request>" - the word ${NEXT_PREFIX} in English whatever language you answer in: ` +
+  'a new request the person is most likely to make next, exactly the words they would type, in the language they wrote in - ' +
+  'no quotation marks, no "say ..." or "ask me ...", no ids or keys. Never a yes to your own question and never what this ' +
+  'reply could have done - do that now instead. Offer only what this conversation can do with its tools. ' +
+  'When nothing natural follows, leave the line out.'
 
 /** A mode's persona with the rules every conversation follows. */
 export function conversationPrompt(modePrompt: string): string {
-  return [modePrompt.trim(), ABSENCE_RULE, NEXT_REQUEST_RULE].join('\n\n')
+  return [modePrompt.trim(), ABSENCE_RULE, FINISH_RULE, SPEAKER_RULE, NEXT_REQUEST_RULE].join('\n\n')
+}
+
+/** Quotation marks inside a request: it quotes another sentence, so it is about a request, not one. */
+const QUOTED = /["“”‘「」『』`]/
+/** An id or a record key - nothing a person types. */
+const MACHINE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|\b[a-z]+(?:-[a-z]+)*:[0-9a-f-]{8,}/i
+
+/**
+ * Whether the line names a request the person could send as it is. The input offers it to be sent with one key, so a
+ * line that tells the person what to say (「"…진행해줘"라고 해줘」) or carries an id is no request: offered, it is sent
+ * back to the model as the person's words.
+ */
+export function isPersonRequest(text: string): boolean {
+  return !!text && !QUOTED.test(text) && !MACHINE.test(text)
 }
 
 /**
@@ -43,5 +81,6 @@ export function splitNextRequest(reply: string): { reply: string; suggestion?: s
   const suggestion = match[1].replace(/^["“'`]+|["”'`]+$/g, '').trim()
   const rest = lines.slice(0, -1).join('\n').replace(/\s+$/, '')
   if (!suggestion || !rest) return { reply: text }
-  return { reply: rest, suggestion }
+  /* The line is ours either way - a line that is no request is taken off and offered as nothing. */
+  return isPersonRequest(suggestion) ? { reply: rest, suggestion } : { reply: rest }
 }

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

@@ -92,7 +92,7 @@ describe('chatRoomLookup — both questions stay inside the caller\'s domain', (
   }
 
   it('★ the session and the seat are both looked up with the domain', async () => {
-    const { deps, seen } = repos({ id: 's1', visibility: 'private' }, { id: 'p1' })
+    const { deps, seen } = repos({ id: 's1', visibility: 'private' }, { id: 'p1', role: 'member' })
     const lookup = chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: 'u1' })
 
     expect(await lookup.visibility()).toBe('private')
@@ -106,8 +106,13 @@ describe('chatRoomLookup — both questions stay inside the caller\'s domain', (
     expect(await chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: 'u1' }).visibility()).toBeUndefined()
   })
 
+  it('★ a hide-only viewer row is not a seat - the stream asks what the stored path asks', async () => {
+    const { deps } = repos({ id: 's1', visibility: 'group' }, { id: 'p1', role: 'viewer' })
+    expect(await chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: 'u1' }).isParticipant()).toBe(false)
+  })
+
   it('a caller with no user sits nowhere', async () => {
-    const { deps, seen } = repos({ id: 's1', visibility: 'private' }, { id: 'p1' })
+    const { deps, seen } = repos({ id: 's1', visibility: 'private' }, { id: 'p1', role: 'member' })
     expect(await chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: undefined }).isParticipant()).toBe(false)
     expect(seen).toEqual([])
   })

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

@@ -13,6 +13,7 @@ import { filter, pipe } from 'graphql-yoga'
 import { pubsub } from '@things-factory/shell'
 
 import { CHAT_MESSAGE_TOPIC, chatMessageRoomFilter, type ChatRoomLookup } from './chat-message-broadcast.js'
+import { isRoomRole } from '../chat-session-participant/participant-lookup-roles.js'
 
 interface FindOne {
   findOne(options: { where: any; select?: any }): Promise<any>
@@ -37,7 +38,8 @@ export function chatRoomLookup(
       const seat = await repos.participants.findOne({
         where: { session: { id: who.sessionId }, user: { id: who.userId }, domain: { id: who.domainId } }
       })
-      return !!seat
+      /* A hide-only `viewer` row is not a seat - the stored path asks the same (`isSessionParticipant`). */
+      return isRoomRole(seat?.role)
     }
   }
 }

package/server/service/chat-message/chat-typing-subscription.ts

@@ -0,0 +1,52 @@
+/*
+ * ChatTypingSubscription - "someone is typing" in a conversation, live. The rules are in `chat-typing.ts`;
+ * this file holds only pubsub and the decorators, which jest cannot read.
+ */
+import { Resolver, Subscription, Root, Arg, ObjectType, Field } from 'type-graphql'
+import { filter, pipe } from 'graphql-yoga'
+import { assertDomainSubscribeAllowed, getRepository, pubsub } from '@things-factory/shell'
+
+import { ChatSession } from '../chat-session/chat-session.js'
+import { ChatSessionParticipant } from '../chat-session-participant/chat-session-participant.js'
+import { mayHearRoom } from './chat-message-broadcast.js'
+import { chatRoomLookup } from './chat-message-room.js'
+import { CHAT_TYPING_TOPIC, chatTypingFilter, type ChatTypingPayload } from './chat-typing.js'
+
+@ObjectType({ description: 'Someone in the conversation is typing. Nothing is stored; the screen lets the notice fade without the next one.' })
+export class ChatTyping {
+  @Field({ description: 'Conversation the person is typing in.' })
+  sessionId!: string
+
+  @Field({ description: 'User who is typing.' })
+  userId!: string
+
+  @Field({ description: 'Name the room shows for that user.' })
+  name!: string
+
+  @Field({ description: 'When the notice was sent (ISO).' })
+  at!: string
+}
+
+@Resolver(ChatTyping)
+export class ChatTypingSubscription {
+  @Subscription(() => ChatTyping, {
+    description: 'Subscribes to "someone is typing" notices of a conversation the caller may read - never the caller\'s own.',
+    subscribe: async ({ args, context }) => {
+      const { domain, user } = context.state
+      const { sessionId } = args
+      await assertDomainSubscribeAllowed(domain, user, (d, u) => process.superUserGranted(d, u))
+
+      /* The same room question the messages ask - refused in the words of a missing session. */
+      const room = chatRoomLookup(
+        { sessions: getRepository(ChatSession), participants: getRepository(ChatSessionParticipant) },
+        { domainId: domain.id, sessionId, userId: user?.id }
+      )
+      if (!(await mayHearRoom(room))) throw new Error('chat session not found')
+
+      return pipe(pubsub.subscribe(CHAT_TYPING_TOPIC), filter(chatTypingFilter(domain.id, sessionId, user?.id, room)))
+    }
+  })
+  chatTyping(@Root() payload: ChatTypingPayload, @Arg('sessionId') sessionId: string): ChatTyping {
+    return { sessionId: payload.sessionId, userId: payload.userId, name: payload.name, at: payload.at }
+  }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * "Someone is typing" - who hears it. The same room question the messages ask, asked again at every notice,
+ * and never the listener's own notice.
+ */
+import { chatTypingFilter, typingNotice } from './chat-typing'
+
+const room = (visibility: string | null | undefined, seated: boolean) => ({ visibility: async () => visibility, isParticipant: async () => seated })
+const notice = (over: any = {}) => ({ domainId: 'd1', sessionId: 's1', userId: 'u2', name: 'kim', at: '2026-10-24T00:00:00.000Z', ...over })
+
+describe('chat typing', () => {
+  it('★ a seated listener of a group hears the others typing', async () => {
+    expect(await chatTypingFilter('d1', 's1', 'u1', room('group', true))(notice())).toBe(true)
+  })
+
+  it('★ someone outside a group or private room hears nothing', async () => {
+    expect(await chatTypingFilter('d1', 's1', 'u1', room('group', false))(notice())).toBe(false)
+    expect(await chatTypingFilter('d1', 's1', 'u1', room('private', false))(notice())).toBe(false)
+  })
+
+  it('★ sent out while listening, the next notice does not reach them', async () => {
+    let seated = true
+    const filter = chatTypingFilter('d1', 's1', 'u1', { visibility: async () => 'group', isParticipant: async () => seated })
+    expect(await filter(notice())).toBe(true)
+    seated = false
+    expect(await filter(notice())).toBe(false)
+  })
+
+  it('anyone in the domain hears an open room', async () => {
+    expect(await chatTypingFilter('d1', 's1', 'u1', room('open', false))(notice())).toBe(true)
+  })
+
+  it('never your own notice, never another session or domain, never a missing room', async () => {
+    const filter = chatTypingFilter('d1', 's1', 'u1', room('open', false))
+    expect(await filter(notice({ userId: 'u1' }))).toBe(false)
+    expect(await filter(notice({ sessionId: 's2' }))).toBe(false)
+    expect(await filter(notice({ domainId: 'd2' }))).toBe(false)
+    expect(await chatTypingFilter('d1', 's1', 'u1', room(undefined, true))(notice())).toBe(false)
+  })
+
+  it('the notice says who and when, a name on one line', () => {
+    const now = new Date('2026-10-24T01:02:03.000Z')
+    expect(typingNotice({ domainId: 'd1', sessionId: 's1', user: { id: 'u2', name: 'Kim\nJi' } }, now)).toEqual({ domainId: 'd1', sessionId: 's1', userId: 'u2', name: 'Kim Ji', at: '2026-10-24T01:02:03.000Z' })
+    expect(typingNotice({ domainId: 'd1', sessionId: 's1', user: {} })).toBeNull()
+  })
+})

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

@@ -0,0 +1,48 @@
+/*
+ * "Someone is typing" - the room's live line, pure part (topic, payload, filter). No pubsub, no decorators,
+ * so the tests run what the subscription runs (`chat-typing.test.ts`).
+ *
+ * Nothing is stored. A person typing is not a message, and a line that outlives the typing would lie, so a
+ * notice says only who and when, and the screen lets it fade after a few seconds without a new one.
+ *
+ * Who hears it is the room's question, asked as the messages ask it (`mayHearRoom`): an open room anyone in
+ * the domain, a group or private room the people seated in it - at subscribe time and again at every notice,
+ * because a member can be sent out while listening. Who may say it is the write gate's question: only a
+ * person who may write here is typing here.
+ */
+import { mayHearRoom, type ChatRoomLookup } from './chat-message-broadcast.js'
+
+export const CHAT_TYPING_TOPIC = 'ai-assistant-chat-typing'
+
+/** How long a notice stands on the screen without the next one. The client sends one every few seconds while typing. */
+export const TYPING_NOTICE_MS = 6_000
+
+export interface ChatTypingPayload {
+  domainId: string
+  sessionId: string
+  userId: string
+  /** The name the room shows - the same name a message's sender line shows. */
+  name: string
+  /** ISO time the notice was sent. */
+  at: string
+}
+
+/** The notice a typing person sends - a name is cut to one line, as the room's other names are. */
+export function typingNotice(input: { domainId: string; sessionId: string; user: { id?: string; name?: string | null; email?: string | null } }, now = new Date()): ChatTypingPayload | null {
+  if (!input.user?.id || !input.sessionId) return null
+  const name = String(input.user.name || input.user.email || '').replace(/[\r\n\t]+/g, ' ').trim().slice(0, 80)
+  return { domainId: input.domainId, sessionId: input.sessionId, userId: input.user.id, name, at: now.toISOString() }
+}
+
+/**
+ * Passes a notice of the same domain and session, not the listener's own, and only while the room is open to
+ * the listener.
+ */
+export function chatTypingFilter(domainId: string, sessionId: string, listenerId: string | undefined, room: ChatRoomLookup) {
+  return async (payload: ChatTypingPayload): Promise<boolean> =>
+    !!payload &&
+    payload.domainId === domainId &&
+    payload.sessionId === sessionId &&
+    payload.userId !== listenerId &&
+    (await mayHearRoom(room))
+}

package/server/service/chat-message/fold-history-window.test.ts

@@ -17,7 +17,7 @@
  * ④ 워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리는 쪽보다 다시 요약하는 쪽이 안전하다.
  *
  * ── 왜 여기로 왔나 (2026-09-18) ────────────────────────────────────────────
- * 요약 접기를 `board-ai` 에서 이 꾸러미로 옮기면서(`4257583d1b`) 이 시험만 board-ai 에 남았다. 읽는
+ * 요약 접기를 `board-ai` 에서 이 패키지로 옮기면서(`4257583d1b`) 이 시험만 board-ai 에 남았다. 읽는
  * 파일이 사라졌으니 board-ai 의 `npm test` 가 그날부터 실패했다 — 옮긴 사람이 시험을 두고 온 것이다.
  * 여기 오면서 `dist-server` 를 거치지 않고 소스를 바로 읽는다.
  */

package/server/service/chat-session/attachment-tool-result.test.ts

@@ -4,7 +4,7 @@
 /* The source, not the built package - the two land together and the test must see the change before a build. */
 import { takeToolImages } from '../../../../ai-client-base/server/service/agentic-loop/agentic-loop'
 
-import { attachmentToolResult } from './attachment-tool-result'
+import { attachmentToolResult, NO_SUCH_ATTACHMENT } from './attachment-tool-result'
 
 describe('a file opened again in a later turn', () => {
   const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 9])
@@ -24,3 +24,11 @@ describe('a file opened again in a later turn', () => {
     expect(attachmentToolResult('t1', { type: 'text', text: 'a', name: 'x.csv', truncated: true })).toMatchObject({ note: 'the file is longer; this is its beginning.' })
   })
 })
+
+/* 2026-10-24: a deposit's id was asked for as a file eight times in one turn. */
+describe('an id that names no file', () => {
+  it('★ is told it is no attachment and not to ask again', () => {
+    expect(NO_SUCH_ATTACHMENT).toMatch(/it is not an attachment/)
+    expect(NO_SUCH_ATTACHMENT).toMatch(/Do not ask for it again/)
+  })
+})

package/server/service/chat-session/attachment-tool-result.ts

@@ -16,3 +16,10 @@ export function attachmentToolResult(attachmentId: string, file: FileForModel) {
     ? { attachmentId, name: file.name, type: 'image', images: [{ data: file.data, mediaType: file.mediaType }], note: 'the picture is attached right after this result - look at it.' }
     : { attachmentId, name: file.name, type: 'text', text: file.text, ...(file.truncated ? { note: 'the file is longer; this is its beginning.' } : {}) }
 }
+
+/*
+ * What an id that names no file of the conversation gets (2026-10-24): given a deposit's id, the model asked for it as a
+ * file eight times in one turn. The answer says the id is no file and where a record is read instead.
+ */
+export const NO_SUCH_ATTACHMENT =
+  'there is no file with this id in a conversation here - it is not an attachment. Do not ask for it again; a record is read with its own read tool.'

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

@@ -18,7 +18,7 @@ import { isSessionParticipant } from '../chat-session-participant/participant-lo
 import { attachmentForModel, CHAT_ATTACHMENT_REF } from './session-attachments.js'
 import { textCharsOf } from './attachment-policy.js'
 import { getAssistantMode } from '../assistant-mode/registry.js'
-import { attachmentToolResult } from './attachment-tool-result.js'
+import { attachmentToolResult, NO_SUCH_ATTACHMENT } from './attachment-tool-result.js'
 
 export const CHAT_ATTACHMENT_CATEGORY = 'chat-attachments'
 
@@ -41,12 +41,12 @@ const readChatAttachment: ToolSpec = {
 
     const row: any = await getRepository(Attachment).findOne({ where: { id, domain: { id: domain.id }, refType: CHAT_ATTACHMENT_REF } as any })
     const session: any = row && (await getRepository(ChatSession).findOne({ where: { id: row.refBy, domain: { id: domain.id } } as any }))
-    if (!row || !session) return { absent: 'not-found', attachmentId: id, message: 'there is no such attachment in a conversation here.' }
+    if (!row || !session) return { absent: 'not-found', attachmentId: id, message: NO_SUCH_ATTACHMENT }
 
     const participant = await isSessionParticipant(domain.id, session.id, user?.id)
     if (!mayReadSession(session.visibility, participant)) {
       /* Same answer as absent - saying "it exists but is private" would itself leak. */
-      return { absent: 'not-found', attachmentId: id, message: 'there is no such attachment in a conversation here.' }
+      return { absent: 'not-found', attachmentId: id, message: NO_SUCH_ATTACHMENT }
     }
 
     const file = await attachmentForModel(row, textCharsOf(getAssistantMode(session.kind || '')?.attachments))